Bump version (#2792 )

Update uom and heim dependencies (#2767 )
v0.29.0 and earlier versions of `uom` fail to compile on nightly because of now-ambiguous trait bounds. The issue was corrected in v0.30.0 of `uom`. `uom` and `heim` dependencies have been updated to the latest version to include this fix and allow nushell to compile on nightly. Co-authored-by: Boutin, Michael <mjboutin@ecolab.com>
2025-07-01 07:00:37 +02:00 · 2020-12-16 09:13:18 +13:00 · 2020-12-15 13:27:21 -06:00 · 2020-12-16 06:30:50 +13:00 · 2020-12-16 05:37:12 +13:00 · 2020-12-12 12:18:03 -06:00
457 changed files with 19633 additions and 5554 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@ -0,0 +1,6 @@
+# use LLD as linker on Windows because it could be faster
+# for full and incremental builds compared to default
+
+[target.x86_64-pc-windows-msvc]
+#linker = "lld-link.exe"
+rustflags = ["-C", "link-args=-stack:10000000"]
--- a/.gitpod.Dockerfile
+++ b/.gitpod.Dockerfile
@ -1,5 +1,9 @@
 FROM gitpod/workspace-full

+# Gitpod will not rebuild Nushell's dev image unless *some* change is made to this Dockerfile.
+# To force a rebuild, simply increase this counter:
+ENV TRIGGER_REBUILD 1
+
 USER gitpod

 RUN sudo apt-get update && \
@ -11,4 +15,4 @@ RUN sudo apt-get update && \
        rust-lldb \
    && sudo rm -rf /var/lib/apt/lists/*

-ENV RUST_LLDB=/usr/bin/lldb-8
+ENV RUST_LLDB=/usr/bin/lldb-11
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -31,6 +31,11 @@ cargo build
  cargo build --release && cargo run --release
  ```

+- Build and run with extra features:
+  ```shell
+  cargo build --release --features=extra && cargo run --release --features=extra
+  ```
+
 - Run Clippy on Nushell:

  ```shell
@ -60,3 +65,11 @@ cargo build
  ```shell
  cargo fmt --all
  ```
+
+### Debugging Tips
+
+- To view verbose logs when developing, enable the `trace` log level.
+
+  ```shell
+  cargo build --release --features=extra && cargo run --release --features=extra -- --loglevel trace
+  ```
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -10,7 +10,7 @@ license = "MIT"
 name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-version = "0.20.0"
+version = "0.24.1"

 [workspace]
 members = ["crates/*/"]
@ -18,51 +18,59 @@ members = ["crates/*/"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-nu-cli = {version = "0.20.0", path = "./crates/nu-cli"}
-nu-data = {version = "0.20.0", path = "./crates/nu-data"}
-nu-errors = {version = "0.20.0", path = "./crates/nu-errors"}
-nu-parser = {version = "0.20.0", path = "./crates/nu-parser"}
-nu-plugin = {version = "0.20.0", path = "./crates/nu-plugin"}
-nu-protocol = {version = "0.20.0", path = "./crates/nu-protocol"}
-nu-source = {version = "0.20.0", path = "./crates/nu-source"}
-nu-value-ext = {version = "0.20.0", path = "./crates/nu-value-ext"}
+nu-cli = {version = "0.24.1", path = "./crates/nu-cli"}
+nu-data = {version = "0.24.1", path = "./crates/nu-data"}
+nu-errors = {version = "0.24.1", path = "./crates/nu-errors"}
+nu-parser = {version = "0.24.1", path = "./crates/nu-parser"}
+nu-plugin = {version = "0.24.1", path = "./crates/nu-plugin"}
+nu-protocol = {version = "0.24.1", path = "./crates/nu-protocol"}
+nu-source = {version = "0.24.1", path = "./crates/nu-source"}
+nu-value-ext = {version = "0.24.1", path = "./crates/nu-value-ext"}

-nu_plugin_binaryview = {version = "0.20.0", path = "./crates/nu_plugin_binaryview", optional = true}
-nu_plugin_fetch = {version = "0.20.0", path = "./crates/nu_plugin_fetch", optional = true}
-nu_plugin_from_bson = {version = "0.20.0", path = "./crates/nu_plugin_from_bson", optional = true}
-nu_plugin_from_sqlite = {version = "0.20.0", path = "./crates/nu_plugin_from_sqlite", optional = true}
-nu_plugin_inc = {version = "0.20.0", path = "./crates/nu_plugin_inc", optional = true}
-nu_plugin_match = {version = "0.20.0", path = "./crates/nu_plugin_match", optional = true}
-nu_plugin_post = {version = "0.20.0", path = "./crates/nu_plugin_post", optional = true}
-nu_plugin_ps = {version = "0.20.0", path = "./crates/nu_plugin_ps", optional = true}
-nu_plugin_s3 = {version = "0.20.0", path = "./crates/nu_plugin_s3", optional = true}
-nu_plugin_start = {version = "0.20.0", path = "./crates/nu_plugin_start", optional = true}
-nu_plugin_sys = {version = "0.20.0", path = "./crates/nu_plugin_sys", optional = true}
-nu_plugin_textview = {version = "0.20.0", path = "./crates/nu_plugin_textview", optional = true}
-nu_plugin_to_bson = {version = "0.20.0", path = "./crates/nu_plugin_to_bson", optional = true}
-nu_plugin_to_sqlite = {version = "0.20.0", path = "./crates/nu_plugin_to_sqlite", optional = true}
-nu_plugin_tree = {version = "0.20.0", path = "./crates/nu_plugin_tree", optional = true}
-
-crossterm = {version = "0.17", optional = true}
-semver = {version = "0.10.0", optional = true}
-url = {version = "2.1.1", optional = true}
+nu_plugin_binaryview = {version = "0.24.1", path = "./crates/nu_plugin_binaryview", optional = true}
+nu_plugin_chart = {version = "0.24.1", path = "./crates/nu_plugin_chart", optional = true}
+nu_plugin_fetch = {version = "0.24.1", path = "./crates/nu_plugin_fetch", optional = true}
+nu_plugin_from_bson = {version = "0.24.1", path = "./crates/nu_plugin_from_bson", optional = true}
+nu_plugin_from_sqlite = {version = "0.24.1", path = "./crates/nu_plugin_from_sqlite", optional = true}
+nu_plugin_inc = {version = "0.24.1", path = "./crates/nu_plugin_inc", optional = true}
+nu_plugin_match = {version = "0.24.1", path = "./crates/nu_plugin_match", optional = true}
+nu_plugin_post = {version = "0.24.1", path = "./crates/nu_plugin_post", optional = true}
+nu_plugin_ps = {version = "0.24.1", path = "./crates/nu_plugin_ps", optional = true}
+nu_plugin_s3 = {version = "0.24.1", path = "./crates/nu_plugin_s3", optional = true}
+nu_plugin_start = {version = "0.24.1", path = "./crates/nu_plugin_start", optional = true}
+nu_plugin_sys = {version = "0.24.1", path = "./crates/nu_plugin_sys", optional = true}
+nu_plugin_textview = {version = "0.24.1", path = "./crates/nu_plugin_textview", optional = true}
+nu_plugin_to_bson = {version = "0.24.1", path = "./crates/nu_plugin_to_bson", optional = true}
+nu_plugin_to_sqlite = {version = "0.24.1", path = "./crates/nu_plugin_to_sqlite", optional = true}
+nu_plugin_tree = {version = "0.24.1", path = "./crates/nu_plugin_tree", optional = true}
+nu_plugin_xpath = {version = "0.24.1", path = "./crates/nu_plugin_xpath", optional = true}
+nu_plugin_selector = {version = "0.24.1", path = "./crates/nu_plugin_selector", optional = true}

+# Required to bootstrap the main binary
 clap = "2.33.3"
-ctrlc = "3.1.6"
-dunce = "1.0.1"
+ctrlc = {version = "3.1.6", optional = true}
 futures = {version = "0.3.5", features = ["compat", "io-compat"]}
 log = "0.4.11"
 pretty_env_logger = "0.4.0"
-quick-xml = "0.18.1"
+itertools = "0.9.0"

 [dev-dependencies]
-nu-test-support = {version = "0.20.0", path = "./crates/nu-test-support"}
+dunce = "1.0.1"
+nu-test-support = {version = "0.24.1", path = "./crates/nu-test-support"}

 [build-dependencies]
-serde = {version = "1.0.115", features = ["derive"]}
-toml = "0.5.6"

 [features]
+ctrlc-support = ["nu-cli/ctrlc"]
+directories-support = ["nu-cli/directories", "nu-cli/dirs", "nu-data/directories", "nu-data/dirs"]
+git-support = ["nu-cli/git2"]
+ptree-support = ["nu-cli/ptree"]
+rich-benchmark = ["nu-cli/rich-benchmark"]
+rustyline-support = ["nu-cli/rustyline-support"]
+term-support = ["nu-cli/term"]
+uuid-support = ["nu-cli/uuid_crate"]
+which-support = ["nu-cli/ichwh", "nu-cli/which"]
+
 default = [
  "sys",
  "ps",
@ -80,39 +88,43 @@ default = [
  "post",
  "fetch",
  "rich-benchmark",
+  "zip-support"
 ]
-extra = ["default", "binaryview", "tree", "clipboard-cli", "trash-support", "start", "bson", "sqlite", "s3"]
+extra = ["default", "binaryview", "tree", "clipboard-cli", "trash-support", "start", "bson", "sqlite", "s3", "chart", "xpath", "selector"]
 stable = ["default"]

-# Default
-inc = ["semver", "nu_plugin_inc"]
-ps = ["nu_plugin_ps"]
-sys = ["nu_plugin_sys"]
-textview = ["crossterm", "url", "nu_plugin_textview"]
+wasi = ["inc", "match", "directories-support", "ptree-support", "match", "tree", "rustyline-support"]

-# Stable
-binaryview = ["nu_plugin_binaryview"]
-bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+trace = ["nu-parser/trace"]
+
+# Stable (Default)
 fetch = ["nu_plugin_fetch"]
+inc = ["nu_plugin_inc"]
 match = ["nu_plugin_match"]
 post = ["nu_plugin_post"]
+ps = ["nu_plugin_ps"]
+sys = ["nu_plugin_sys"]
+textview = ["nu_plugin_textview"]
+zip-support = ["nu-cli/zip"]
+
+# Extra
+binaryview = ["nu_plugin_binaryview"]
+bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+chart = ["nu_plugin_chart"]
+clipboard-cli = ["nu-cli/clipboard-cli"]
 s3 = ["nu_plugin_s3"]
 sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
 start = ["nu_plugin_start"]
-trace = ["nu-parser/trace"]
-tree = ["nu_plugin_tree"]
-
-clipboard-cli = ["nu-cli/clipboard-cli"]
-ctrlc-support = ["nu-cli/ctrlc"]
-directories-support = ["nu-cli/directories", "nu-cli/dirs", "nu-data/directories", "nu-data/dirs"]
-git-support = ["nu-cli/git2"]
-ptree-support = ["nu-cli/ptree"]
-rich-benchmark = ["nu-cli/rich-benchmark"]
-rustyline-support = ["nu-cli/rustyline-support"]
-term-support = ["nu-cli/term"]
 trash-support = ["nu-cli/trash-support"]
-uuid-support = ["nu-cli/uuid_crate"]
-which-support = ["nu-cli/ichwh", "nu-cli/which"]
+tree = ["nu_plugin_tree"]
+xpath = ["nu_plugin_xpath"]
+selector = ["nu_plugin_selector"]
+
+[profile.release]
+#strip = "symbols" #Couldn't get working +nightly
+opt-level = 'z' #Optimize for size
+lto = true #Link Time Optimization
+codegen-units = 1 #Reduce parallel codegen units

 # Core plugins that ship with `cargo install nu` by default
 # Currently, Cargo limits us to installing only one binary
@ -174,6 +186,46 @@ name = "nu_plugin_extra_s3"
 path = "src/plugins/nu_plugin_extra_s3.rs"
 required-features = ["s3"]

+[[bin]]
+name = "nu_plugin_extra_chart_bar"
+path = "src/plugins/nu_plugin_extra_chart_bar.rs"
+required-features = ["chart"]
+
+[[bin]]
+name = "nu_plugin_extra_chart_line"
+path = "src/plugins/nu_plugin_extra_chart_line.rs"
+required-features = ["chart"]
+
+[[bin]]
+name = "nu_plugin_extra_xpath"
+path = "src/plugins/nu_plugin_extra_xpath.rs"
+required-features = ["xpath"]
+
+[[bin]]
+name = "nu_plugin_extra_selector"
+path = "src/plugins/nu_plugin_extra_selector.rs"
+required-features = ["selector"]
+
+[[bin]]
+name = "nu_plugin_extra_from_bson"
+path = "src/plugins/nu_plugin_extra_from_bson.rs"
+required-features = ["bson"]
+
+[[bin]]
+name = "nu_plugin_extra_to_bson"
+path = "src/plugins/nu_plugin_extra_to_bson.rs"
+required-features = ["bson"]
+
+[[bin]]
+name = "nu_plugin_extra_from_sqlite"
+path = "src/plugins/nu_plugin_extra_from_sqlite.rs"
+required-features = ["sqlite"]
+
+[[bin]]
+name = "nu_plugin_extra_to_sqlite"
+path = "src/plugins/nu_plugin_extra_to_sqlite.rs"
+required-features = ["sqlite"]
+
 # Main nu binary
 [[bin]]
 name = "nu"
--- a/README.md
+++ b/README.md
@ -7,7 +7,7 @@
 [![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
 [![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)

-## Nu Shell
+## Nushell

 A new type of shell.

@ -34,7 +34,7 @@ There are also [good first issues](https://github.com/nushell/nushell/issues?q=i

 We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell) if you'd like to come and chat with us.

-You can also find more learning resources in our [documentation](https://www.nushell.sh/documentation.html) site.
+You can also find information on more specific topics in our [cookbook](https://www.nushell.sh/cookbook/).

 Try it in Gitpod.

@ -44,9 +44,9 @@ Try it in Gitpod.

 ### Local

-Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/en/installation.html).  **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
+Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html).  **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.

-To build Nu, you will need to use the **latest stable (1.41 or later)** version of the compiler.
+To build Nu, you will need to use the **latest stable (1.47 or later)** version of the compiler.

 Required dependencies:

@ -219,15 +219,15 @@ We can pipeline this into a command that gets the contents of one of the columns
 name          │ nu
 readme        │ README.md
 repository    │ https://github.com/nushell/nushell
- version       │ 0.15.1
+ version       │ 0.21.0
 ───────────────┴────────────────────────────────────
 ```

 Finally, we can use commands outside of Nu once we have the data we want:

 ```shell
-> open Cargo.toml | get package.version | echo $it
-0.15.1
+> open Cargo.toml | get package.version
+0.21.0
 ```

 Here we use the variable `$it` to refer to the value being piped to the external command.
@ -307,7 +307,7 @@ Nu is in heavy development, and will naturally change as it matures and people u

 ## Current Roadmap

-We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release as well as capture some important issues we'd like to see in NuShell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
+We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release as well as capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).

 ## Contributing

--- a/TODO.md
+++ b/TODO.md
--- a/crates/nu-cli/Cargo.toml
+++ b/crates/nu-cli/Cargo.toml
@ -4,58 +4,64 @@ description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
 name = "nu-cli"
-version = "0.20.0"
+version = "0.24.1"
+build = "build.rs"

 [lib]
 doctest = false

 [dependencies]
-nu-data = {version = "0.20.0", path = "../nu-data"}
-nu-errors = {version = "0.20.0", path = "../nu-errors"}
-nu-parser = {version = "0.20.0", path = "../nu-parser"}
-nu-plugin = {version = "0.20.0", path = "../nu-plugin"}
-nu-protocol = {version = "0.20.0", path = "../nu-protocol"}
-nu-source = {version = "0.20.0", path = "../nu-source"}
-nu-table = {version = "0.20.0", path = "../nu-table"}
-nu-test-support = {version = "0.20.0", path = "../nu-test-support"}
-nu-value-ext = {version = "0.20.0", path = "../nu-value-ext"}
+nu-data = {version = "0.24.1", path = "../nu-data"}
+nu-errors = {version = "0.24.1", path = "../nu-errors"}
+nu-json = {version = "0.24.1", path = "../nu-json"}
+nu-parser = {version = "0.24.1", path = "../nu-parser"}
+nu-plugin = {version = "0.24.1", path = "../nu-plugin"}
+nu-protocol = {version = "0.24.1", path = "../nu-protocol"}
+nu-source = {version = "0.24.1", path = "../nu-source"}
+nu-table = {version = "0.24.1", path = "../nu-table"}
+nu-test-support = {version = "0.24.1", path = "../nu-test-support"}
+nu-value-ext = {version = "0.24.1", path = "../nu-value-ext"}

 ansi_term = "0.12.1"
 async-recursion = "0.3.1"
 async-trait = "0.1.40"
-base64 = "0.12.3"
+base64 = "0.13.0"
 bigdecimal = {version = "0.2.0", features = ["serde"]}
 byte-unit = "4.0.9"
 bytes = "0.5.6"
 calamine = "0.16.1"
 chrono = {version = "0.4.15", features = ["serde"]}
+chrono-tz = "0.5.3"
 clap = "2.33.3"
+clipboard = {version = "0.5.0", optional = true}
 codespan-reporting = "0.9.5"
 csv = "1.1.3"
 ctrlc = {version = "3.1.6", optional = true}
 derive-new = "0.5.8"
 directories = {version = "3.0.1", optional = true}
 dirs = {version = "3.0.1", optional = true}
-dtparse = "1.1.0"
+dtparse = "1.2.0"
 dunce = "1.0.1"
 eml-parser = "0.1.0"
+encoding_rs = "0.8.24"
 filesize = "0.2.0"
 fs_extra = "1.2.0"
 futures = {version = "0.3.5", features = ["compat", "io-compat"]}
-futures-util = "0.3.5"
 futures_codec = "0.4.1"
+futures-util = "0.3.5"
 getset = "0.1.1"
 git2 = {version = "0.13.11", default_features = false, optional = true}
 glob = "0.3.0"
-heim = {version = "0.1.0-beta.3", optional = true}
+heim = {version = "0.1.0-rc.1", optional = true}
 htmlescape = "0.3.1"
 ical = "0.6.0"
 ichwh = {version = "0.3.4", optional = true}
 indexmap = {version = "1.6.0", features = ["serde-1"]}
+Inflector = "0.11"
 itertools = "0.9.0"
+lazy_static = "1.*"
 log = "0.4.11"
 meval = "0.2.0"
-natural = "0.5.0"
 num-bigint = {version = "0.3.0", features = ["serde"]}
 num-format = {version = "0.4.0", features = ["with-num-bigint"]}
 num-traits = "0.2.12"
@ -64,13 +70,14 @@ pin-utils = "0.1.0"
 pretty-hex = "0.2.0"
 ptree = {version = "0.3.0", optional = true}
 query_interface = "0.3.5"
+quick-xml = "0.18.1"
 rand = "0.7.3"
+rayon = "1.4.0"
 regex = "1.3.9"
 roxmltree = "0.13.0"
 rust-embed = "5.6.0"
 rustyline = {version = "6.3.0", optional = true}
 serde = {version = "1.0.115", features = ["derive"]}
-serde-hjson = "0.9.1"
 serde_bytes = "0.11.5"
 serde_ini = "0.2.0"
 serde_json = "1.0.57"
@ -79,25 +86,22 @@ serde_yaml = "0.8.13"
 sha2 = "0.9.1"
 shellexpand = "2.0.0"
 strip-ansi-escapes = "0.1.0"
+sxd-document = "0.3.2"
+sxd-xpath = "0.4.2"
 tempfile = "3.1.0"
 term = {version = "0.6.1", optional = true}
 term_size = "0.3.2"
 termcolor = "1.1.0"
+titlecase = "1.0"
 toml = "0.5.6"
+trash = {version = "1.2.0", optional = true}
 unicode-segmentation = "1.6.0"
-uom = {version = "0.28.0", features = ["f64", "try-from"]}
+uom = {version = "0.30.0", features = ["f64", "try-from"]}
+url = "2.1.1"
 uuid_crate = {package = "uuid", version = "0.8.1", features = ["v4"], optional = true}
 which = {version = "4.0.2", optional = true}
 zip = {version = "0.5.7", optional = true}

-Inflector = "0.11"
-clipboard = {version = "0.5.0", optional = true}
-encoding_rs = "0.8.24"
-quick-xml = "0.18.1"
-rayon = "1.4.0"
-trash = {version = "1.1.1", optional = true}
-url = "2.1.1"
-
 [target.'cfg(unix)'.dependencies]
 umask = "1.0.0"
 users = "0.10.0"
@ -111,10 +115,10 @@ users = "0.10.0"
 [dependencies.rusqlite]
 features = ["bundled", "blob"]
 optional = true
-version = "0.24.0"
+version = "0.24.1"

 [build-dependencies]
-git2 = {version = "0.13.11", optional = true}
+shadow-rs = "0.3.20"

 [dev-dependencies]
 quickcheck = "0.9.2"
--- a/crates/nu-cli/build.rs
+++ b/crates/nu-cli/build.rs
@ -1,36 +1,6 @@
-use std::path::Path;
-use std::{env, fs, io};
-
-fn main() -> Result<(), io::Error> {
-    let out_dir = env::var_os("OUT_DIR").expect(
-    "\
-        OUT_DIR environment variable not found. \
-        OUT_DIR is guaranteed to to exist in a build script by cargo - see \
-        https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-build-scripts\
-    ");
-
-    let latest_commit_hash = latest_commit_hash(env::current_dir()?).unwrap_or_default();
-
-    let commit_hash_path = Path::new(&out_dir).join("git_commit_hash");
-    fs::write(commit_hash_path, latest_commit_hash)?;
-
+fn main() -> shadow_rs::SdResult<()> {
+    let src_path = std::env::var("CARGO_MANIFEST_DIR")?;
+    let out_path = std::env::var("OUT_DIR")?;
+    shadow_rs::Shadow::build(src_path, out_path)?;
    Ok(())
 }
-
-#[allow(unused_variables)]
-fn latest_commit_hash<P: AsRef<Path>>(dir: P) -> Result<String, Box<dyn std::error::Error>> {
-    #[cfg(feature = "git2")]
-    {
-        use git2::Repository;
-        let dir = dir.as_ref();
-        Ok(Repository::discover(dir)?
-            .head()?
-            .peel_to_commit()?
-            .id()
-            .to_string())
-    }
-    #[cfg(not(feature = "git2"))]
-    {
-        Ok(String::new())
-    }
-}
--- a/crates/nu-cli/src/cli.rs
+++ b/crates/nu-cli/src/cli.rs
@ -9,7 +9,7 @@ use crate::EnvironmentSyncer;
 use futures_codec::FramedRead;
 use nu_errors::ShellError;
 use nu_protocol::hir::{ClassifiedCommand, Expression, InternalCommand, Literal, NamedArguments};
-use nu_protocol::{Primitive, ReturnSuccess, UntaggedValue, Value};
+use nu_protocol::{Primitive, ReturnSuccess, Scope, UntaggedValue, Value};

 use log::{debug, trace};
 #[cfg(feature = "rustyline-support")]
@ -86,8 +86,10 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(Touch),
            whole_stream_command(Cpy),
            whole_stream_command(Date),
+            whole_stream_command(DateListTimeZone),
            whole_stream_command(DateNow),
-            whole_stream_command(DateUTC),
+            whole_stream_command(DateToTable),
+            whole_stream_command(DateToTimeZone),
            whole_stream_command(DateFormat),
            whole_stream_command(Cal),
            whole_stream_command(Mkdir),
@ -95,7 +97,7 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(Kill),
            whole_stream_command(Version),
            whole_stream_command(Clear),
-            whole_stream_command(What),
+            whole_stream_command(Describe),
            whole_stream_command(Which),
            whole_stream_command(Debug),
            whole_stream_command(Alias),
@ -114,10 +116,14 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(Shells),
            whole_stream_command(Enter),
            whole_stream_command(Exit),
+            // Viz
+            whole_stream_command(Chart),
            // Viewers
            whole_stream_command(Autoview),
            whole_stream_command(Table),
            // Text manipulation
+            whole_stream_command(Hash),
+            whole_stream_command(HashBase64),
            whole_stream_command(Split),
            whole_stream_command(SplitColumn),
            whole_stream_command(SplitRow),
@ -145,7 +151,9 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(StrEndsWith),
            whole_stream_command(StrCollect),
            whole_stream_command(StrLength),
+            whole_stream_command(StrLPad),
            whole_stream_command(StrReverse),
+            whole_stream_command(StrRPad),
            whole_stream_command(StrCamelCase),
            whole_stream_command(StrPascalCase),
            whole_stream_command(StrKebabCase),
@ -155,7 +163,7 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(Ansi),
            whole_stream_command(Char),
            // Column manipulation
-            whole_stream_command(MoveColumn),
+            whole_stream_command(Move),
            whole_stream_command(Reject),
            whole_stream_command(Select),
            whole_stream_command(Get),
@ -176,6 +184,7 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(Nth),
            whole_stream_command(Drop),
            whole_stream_command(Format),
+            whole_stream_command(FileSize),
            whole_stream_command(Where),
            whole_stream_command(If),
            whole_stream_command(Compact),
@ -192,8 +201,9 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(Each),
            whole_stream_command(EachGroup),
            whole_stream_command(EachWindow),
-            whole_stream_command(IsEmpty),
+            whole_stream_command(Empty),
            // Table manipulation
+            whole_stream_command(Flatten),
            whole_stream_command(Move),
            whole_stream_command(Merge),
            whole_stream_command(Shuffle),
@ -207,6 +217,7 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(AutoenvTrust),
            whole_stream_command(AutoenvUnTrust),
            whole_stream_command(Math),
+            whole_stream_command(MathAbs),
            whole_stream_command(MathAverage),
            whole_stream_command(MathEval),
            whole_stream_command(MathMedian),
@ -217,6 +228,9 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(MathSummation),
            whole_stream_command(MathVariance),
            whole_stream_command(MathProduct),
+            whole_stream_command(MathRound),
+            whole_stream_command(MathFloor),
+            whole_stream_command(MathCeil),
            // File format output
            whole_stream_command(To),
            whole_stream_command(ToCSV),
@ -254,6 +268,8 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            #[cfg(feature = "uuid_crate")]
            whole_stream_command(RandomUUID),
            whole_stream_command(RandomInteger),
+            whole_stream_command(RandomDecimal),
+            whole_stream_command(RandomChars),
            // Path
            whole_stream_command(PathBasename),
            whole_stream_command(PathCommand),
@ -269,6 +285,8 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
            whole_stream_command(UrlPath),
            whole_stream_command(UrlHost),
            whole_stream_command(UrlQuery),
+            whole_stream_command(Seq),
+            whole_stream_command(SeqDates),
        ]);

        #[cfg(feature = "clipboard-cli")]
@ -313,6 +331,7 @@ pub async fn run_vec_of_pipelines(
 #[cfg(feature = "rustyline-support")]
 fn convert_rustyline_result_to_string(input: Result<String, ReadlineError>) -> LineResult {
    match input {
+        Ok(s) if s == "history -c" || s == "history --clear" => LineResult::ClearHistory,
        Ok(s) => LineResult::Success(s),
        Err(ReadlineError::Interrupted) => LineResult::CtrlC,
        Err(ReadlineError::Eof) => LineResult::CtrlD,
@ -382,57 +401,56 @@ pub async fn cli(mut context: EvaluationContext) -> Result<(), Box<dyn Error>> {
            if let Some(prompt) = configuration.var("prompt") {
                let prompt_line = prompt.as_string()?;

-                match nu_parser::lite_parse(&prompt_line, 0).map_err(ShellError::from) {
-                    Ok(result) => {
-                        let mut prompt_block =
-                            nu_parser::classify_block(&result, context.registry());
+                let (result, err) = nu_parser::lite_parse(&prompt_line, 0);

-                        let env = context.get_env();
+                if err.is_some() {
+                    use crate::git::current_branch;
+                    format!(
+                        "\x1b[32m{}{}\x1b[m> ",
+                        cwd,
+                        match current_branch() {
+                            Some(s) => format!("({})", s),
+                            None => "".to_string(),
+                        }
+                    )
+                } else {
+                    let prompt_block = nu_parser::classify_block(&result, context.registry());

-                        prompt_block.block.expand_it_usage();
+                    let env = context.get_env();

-                        match run_block(
-                            &prompt_block.block,
-                            &mut context,
-                            InputStream::empty(),
-                            &Value::nothing(),
-                            &IndexMap::new(),
-                            &env,
-                        )
-                        .await
-                        {
-                            Ok(result) => match result.collect_string(Tag::unknown()).await {
-                                Ok(string_result) => {
-                                    let errors = context.get_errors();
-                                    context.maybe_print_errors(Text::from(prompt_line));
-                                    context.clear_errors();
-
-                                    if !errors.is_empty() {
-                                        "> ".to_string()
-                                    } else {
-                                        string_result.item
-                                    }
-                                }
-                                Err(e) => {
-                                    crate::cli::print_err(e, &Text::from(prompt_line));
-                                    context.clear_errors();
+                    match run_block(
+                        &prompt_block.block,
+                        &mut context,
+                        InputStream::empty(),
+                        Scope::from_env(env),
+                    )
+                    .await
+                    {
+                        Ok(result) => match result.collect_string(Tag::unknown()).await {
+                            Ok(string_result) => {
+                                let errors = context.get_errors();
+                                context.maybe_print_errors(Text::from(prompt_line));
+                                context.clear_errors();

+                                if !errors.is_empty() {
                                    "> ".to_string()
+                                } else {
+                                    string_result.item
                                }
-                            },
+                            }
                            Err(e) => {
                                crate::cli::print_err(e, &Text::from(prompt_line));
                                context.clear_errors();

                                "> ".to_string()
                            }
-                        }
-                    }
-                    Err(e) => {
-                        crate::cli::print_err(e, &Text::from(prompt_line));
-                        context.clear_errors();
+                        },
+                        Err(e) => {
+                            crate::cli::print_err(e, &Text::from(prompt_line));
+                            context.clear_errors();

-                        "> ".to_string()
+                            "> ".to_string()
+                        }
                    }
                }
            } else {
@ -494,6 +512,11 @@ pub async fn cli(mut context: EvaluationContext) -> Result<(), Box<dyn Error>> {
                context.maybe_print_errors(Text::from(line));
            }

+            LineResult::ClearHistory => {
+                rl.clear_history();
+                let _ = rl.save_history(&history_path);
+            }
+
            LineResult::Error(line, err) => {
                rl.add_history_entry(&line);
                let _ = rl.save_history(&history_path);
@ -667,6 +690,9 @@ fn default_rustyline_editor_configuration() -> Editor<Helper> {
        Cmd::Move(Movement::ForwardWord(1, At::AfterEnd, Word::Vi)),
    );

+    // workaround for multiline-paste hang in rustyline (see https://github.com/kkawakam/rustyline/issues/202)
+    rl.bind_sequence(KeyPress::BracketedPasteStart, rustyline::Cmd::Noop);
+
    // Let's set the defaults up front and then override them later if the user indicates
    // defaults taken from here https://github.com/kkawakam/rustyline/blob/2fe886c9576c1ea13ca0e5808053ad491a6fe049/src/config.rs#L150-L167
    rl.set_max_history_size(100);
@ -826,8 +852,8 @@ fn rustyline_hinter(config: &dyn nu_data::config::Conf) -> Option<rustyline::hin
 }

 fn chomp_newline(s: &str) -> &str {
-    if s.ends_with('\n') {
-        &s[..s.len() - 1]
+    if let Some(s) = s.strip_suffix('\n') {
+        s
    } else {
        s
    }
@ -840,20 +866,23 @@ pub enum LineResult {
    Break,
    CtrlC,
    CtrlD,
+    ClearHistory,
 }

 pub async fn parse_and_eval(line: &str, ctx: &mut EvaluationContext) -> Result<String, ShellError> {
-    let line = if line.ends_with('\n') {
-        &line[..line.len() - 1]
+    let line = if let Some(s) = line.strip_suffix('\n') {
+        s
    } else {
        line
    };

-    let lite_result = nu_parser::lite_parse(&line, 0)?;
+    let (lite_result, err) = nu_parser::lite_parse(&line, 0);
+    if let Some(err) = err {
+        return Err(err.into());
+    }

    // TODO ensure the command whose examples we're testing is actually in the pipeline
-    let mut classified_block = nu_parser::classify_block(&lite_result, ctx.registry());
-    classified_block.block.expand_it_usage();
+    let classified_block = nu_parser::classify_block(&lite_result, ctx.registry());

    let input_stream = InputStream::empty();
    let env = ctx.get_env();
@ -862,9 +891,7 @@ pub async fn parse_and_eval(line: &str, ctx: &mut EvaluationContext) -> Result<S
        &classified_block.block,
        ctx,
        input_stream,
-        &Value::nothing(),
-        &IndexMap::new(),
-        &env,
+        Scope::from_env(env),
    )
    .await?
    .collect_string(Tag::unknown())
@ -885,18 +912,16 @@ pub async fn process_line(
        let line = chomp_newline(line);
        ctx.raw_input = line.to_string();

-        let result = match nu_parser::lite_parse(&line, 0) {
-            Err(err) => {
-                return LineResult::Error(line.to_string(), err.into());
-            }
+        let (result, err) = nu_parser::lite_parse(&line, 0);

-            Ok(val) => val,
-        };
+        if let Some(err) = err {
+            return LineResult::Error(line.to_string(), err.into());
+        }

        debug!("=== Parsed ===");
        debug!("{:#?}", result);

-        let mut classified_block = nu_parser::classify_block(&result, ctx.registry());
+        let classified_block = nu_parser::classify_block(&result, ctx.registry());

        debug!("{:#?}", classified_block);
        //println!("{:#?}", pipeline);
@ -1013,17 +1038,13 @@ pub async fn process_line(
            InputStream::empty()
        };

-        classified_block.block.expand_it_usage();
-
        trace!("{:#?}", classified_block);
        let env = ctx.get_env();
        match run_block(
            &classified_block.block,
            ctx,
            input_stream,
-            &Value::nothing(),
-            &IndexMap::new(),
-            &env,
+            Scope::from_env(env),
        )
        .await
        {
@ -1092,7 +1113,8 @@ pub fn print_err(err: ShellError, source: &Text) {
 mod tests {
    #[quickcheck]
    fn quickcheck_parse(data: String) -> bool {
-        if let Ok(lite_block) = nu_parser::lite_parse(&data, 0) {
+        let (lite_block, err) = nu_parser::lite_parse(&data, 0);
+        if err.is_none() {
            let context = crate::evaluation_context::EvaluationContext::basic().unwrap();
            let _ = nu_parser::classify_block(&lite_block, context.registry());
        }
--- a/crates/nu-cli/src/commands.rs
+++ b/crates/nu-cli/src/commands.rs
@ -17,6 +17,7 @@ pub(crate) mod build_string;
 pub(crate) mod cal;
 pub(crate) mod cd;
 pub(crate) mod char_;
+pub(crate) mod chart;
 pub(crate) mod classified;
 #[cfg(feature = "clipboard-cli")]
 pub(crate) mod clip;
@ -29,16 +30,19 @@ pub(crate) mod cp;
 pub(crate) mod date;
 pub(crate) mod debug;
 pub(crate) mod default;
+pub(crate) mod describe;
 pub(crate) mod do_;
 pub(crate) mod drop;
 pub(crate) mod du;
 pub(crate) mod each;
 pub(crate) mod echo;
+pub(crate) mod empty;
 pub(crate) mod enter;
 pub(crate) mod every;
 pub(crate) mod exec;
 pub(crate) mod exit;
 pub(crate) mod first;
+pub(crate) mod flatten;
 pub(crate) mod format;
 pub(crate) mod from;
 pub(crate) mod from_csv;
@ -58,6 +62,7 @@ pub(crate) mod from_yaml;
 pub(crate) mod get;
 pub(crate) mod group_by;
 pub(crate) mod group_by_date;
+pub(crate) mod hash_;
 pub(crate) mod headers;
 pub(crate) mod help;
 pub(crate) mod histogram;
@ -65,7 +70,6 @@ pub(crate) mod history;
 pub(crate) mod if_;
 pub(crate) mod insert;
 pub(crate) mod into_int;
-pub(crate) mod is_empty;
 pub(crate) mod keep;
 pub(crate) mod last;
 pub(crate) mod lines;
@ -95,6 +99,8 @@ pub(crate) mod run_alias;
 pub(crate) mod run_external;
 pub(crate) mod save;
 pub(crate) mod select;
+pub(crate) mod seq;
+pub(crate) mod seq_dates;
 pub(crate) mod shells;
 pub(crate) mod shuffle;
 pub(crate) mod size;
@ -120,7 +126,6 @@ pub(crate) mod uniq;
 pub(crate) mod update;
 pub(crate) mod url_;
 pub(crate) mod version;
-pub(crate) mod what;
 pub(crate) mod where_;
 pub(crate) mod which_;
 pub(crate) mod with_env;
@ -134,7 +139,7 @@ pub(crate) use command::{

 pub(crate) use alias::Alias;
 pub(crate) use ansi::Ansi;
-pub(crate) use append::Append;
+pub(crate) use append::Command as Append;
 pub(crate) use autoenv::Autoenv;
 pub(crate) use autoenv_trust::AutoenvTrust;
 pub(crate) use autoenv_untrust::AutoenvUnTrust;
@ -142,15 +147,17 @@ pub(crate) use benchmark::Benchmark;
 pub(crate) use build_string::BuildString;
 pub(crate) use cal::Cal;
 pub(crate) use char_::Char;
+pub(crate) use chart::Chart;
 pub(crate) use compact::Compact;
 pub(crate) use config::{
    Config, ConfigClear, ConfigGet, ConfigLoad, ConfigPath, ConfigRemove, ConfigSet, ConfigSetInto,
 };
 pub(crate) use count::Count;
 pub(crate) use cp::Cpy;
-pub(crate) use date::{Date, DateFormat, DateNow, DateUTC};
+pub(crate) use date::{Date, DateFormat, DateListTimeZone, DateNow, DateToTable, DateToTimeZone};
 pub(crate) use debug::Debug;
 pub(crate) use default::Default;
+pub(crate) use describe::Describe;
 pub(crate) use do_::Do;
 pub(crate) use drop::Drop;
 pub(crate) use du::Du;
@ -158,10 +165,10 @@ pub(crate) use each::Each;
 pub(crate) use each::EachGroup;
 pub(crate) use each::EachWindow;
 pub(crate) use echo::Echo;
+pub(crate) use empty::Command as Empty;
 pub(crate) use if_::If;
-pub(crate) use is_empty::IsEmpty;
 pub(crate) use nu::NuPlugin;
-pub(crate) use update::Update;
+pub(crate) use update::Command as Update;
 pub(crate) mod kill;
 pub(crate) use kill::Kill;
 pub(crate) mod clear;
@ -172,7 +179,8 @@ pub(crate) use every::Every;
 pub(crate) use exec::Exec;
 pub(crate) use exit::Exit;
 pub(crate) use first::First;
-pub(crate) use format::Format;
+pub(crate) use flatten::Command as Flatten;
+pub(crate) use format::{FileSize, Format};
 pub(crate) use from::From;
 pub(crate) use from_csv::FromCSV;
 pub(crate) use from_eml::FromEML;
@ -190,25 +198,26 @@ pub(crate) use from_xml::FromXML;
 pub(crate) use from_yaml::FromYAML;
 pub(crate) use from_yaml::FromYML;
 pub(crate) use get::Get;
-pub(crate) use group_by::GroupBy;
+pub(crate) use group_by::Command as GroupBy;
 pub(crate) use group_by_date::GroupByDate;
+pub(crate) use hash_::{Hash, HashBase64};
 pub(crate) use headers::Headers;
 pub(crate) use help::Help;
 pub(crate) use histogram::Histogram;
 pub(crate) use history::History;
-pub(crate) use insert::Insert;
+pub(crate) use insert::Command as Insert;
 pub(crate) use into_int::IntoInt;
 pub(crate) use keep::{Keep, KeepUntil, KeepWhile};
 pub(crate) use last::Last;
 pub(crate) use lines::Lines;
 pub(crate) use ls::Ls;
 pub(crate) use math::{
-    Math, MathAverage, MathEval, MathMaximum, MathMedian, MathMinimum, MathMode, MathProduct,
-    MathStddev, MathSummation, MathVariance,
+    Math, MathAbs, MathAverage, MathCeil, MathEval, MathFloor, MathMaximum, MathMedian,
+    MathMinimum, MathMode, MathProduct, MathRound, MathStddev, MathSummation, MathVariance,
 };
 pub(crate) use merge::Merge;
 pub(crate) use mkdir::Mkdir;
-pub(crate) use move_::{Move, MoveColumn, Mv};
+pub(crate) use move_::{Move, Mv};
 pub(crate) use next::Next;
 pub(crate) use nth::Nth;
 pub(crate) use open::Open;
@ -223,7 +232,9 @@ pub(crate) use prev::Previous;
 pub(crate) use pwd::Pwd;
 #[cfg(feature = "uuid_crate")]
 pub(crate) use random::RandomUUID;
-pub(crate) use random::{Random, RandomBool, RandomDice, RandomInteger};
+pub(crate) use random::{
+    Random, RandomBool, RandomChars, RandomDecimal, RandomDice, RandomInteger,
+};
 pub(crate) use range::Range;
 pub(crate) use reduce::Reduce;
 pub(crate) use reject::Reject;
@ -233,6 +244,8 @@ pub(crate) use rm::Remove;
 pub(crate) use run_external::RunExternalCommand;
 pub(crate) use save::Save;
 pub(crate) use select::Select;
+pub(crate) use seq::Seq;
+pub(crate) use seq_dates::SeqDates;
 pub(crate) use shells::Shells;
 pub(crate) use shuffle::Shuffle;
 pub(crate) use size::Size;
@ -243,9 +256,9 @@ pub(crate) use split::{Split, SplitChars, SplitColumn, SplitRow};
 pub(crate) use split_by::SplitBy;
 pub(crate) use str_::{
    Str, StrCamelCase, StrCapitalize, StrCollect, StrContains, StrDowncase, StrEndsWith,
-    StrFindReplace, StrFrom, StrIndexOf, StrKebabCase, StrLength, StrPascalCase, StrReverse,
-    StrScreamingSnakeCase, StrSet, StrSnakeCase, StrStartsWith, StrSubstring, StrToDatetime,
-    StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
+    StrFindReplace, StrFrom, StrIndexOf, StrKebabCase, StrLPad, StrLength, StrPascalCase, StrRPad,
+    StrReverse, StrScreamingSnakeCase, StrSet, StrSnakeCase, StrStartsWith, StrSubstring,
+    StrToDatetime, StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
 };
 pub(crate) use table::Table;
 pub(crate) use tags::Tags;
@ -263,8 +276,50 @@ pub(crate) use touch::Touch;
 pub(crate) use uniq::Uniq;
 pub(crate) use url_::{UrlCommand, UrlHost, UrlPath, UrlQuery, UrlScheme};
 pub(crate) use version::Version;
-pub(crate) use what::What;
 pub(crate) use where_::Where;
 pub(crate) use which_::Which;
 pub(crate) use with_env::WithEnv;
 pub(crate) use wrap::Wrap;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::commands::whole_stream_command;
+    use crate::examples::{test_anchors, test_examples};
+    use nu_errors::ShellError;
+
+    fn full_tests() -> Vec<Command> {
+        vec![
+            whole_stream_command(Append),
+            whole_stream_command(GroupBy),
+            whole_stream_command(Insert),
+            whole_stream_command(Move),
+            whole_stream_command(Update),
+            whole_stream_command(Empty),
+        ]
+    }
+
+    fn only_examples() -> Vec<Command> {
+        let mut commands = full_tests();
+        commands.extend(vec![whole_stream_command(Flatten)]);
+        commands
+    }
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        for cmd in only_examples() {
+            test_examples(cmd)?;
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn tracks_metadata() -> Result<(), ShellError> {
+        for cmd in full_tests() {
+            test_anchors(cmd)?;
+        }
+
+        Ok(())
+    }
+}
--- a/crates/nu-cli/src/commands/alias.rs
+++ b/crates/nu-cli/src/commands/alias.rs
@ -1,16 +1,16 @@
 use crate::command_registry::CommandRegistry;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
+
+use crate::types::deduction::{VarDeclaration, VarSyntaxShapeDeductor};
+use deduction_to_signature::DeductionToSignature;
+use log::trace;
 use nu_data::config;
 use nu_errors::ShellError;
-use nu_parser::SignatureRegistry;
-use nu_protocol::hir::{ClassifiedCommand, Expression, NamedValue, SpannedExpression, Variable};
 use nu_protocol::{
-    hir::Block, CommandAction, NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape,
-    UntaggedValue, Value,
+    hir::Block, CommandAction, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
 };
 use nu_source::Tagged;
-use std::collections::HashMap;

 pub struct Alias;

@ -86,7 +86,6 @@ pub async fn alias(
        },
        _ctx,
    ) = args.process(&registry).await?;
-    let mut processed_args: Vec<String> = vec![];

    if let Some(true) = save {
        let mut result = nu_data::config::read(name.clone().tag, &None)?;
@ -110,7 +109,7 @@ pub async fn alias(
        let alias: Value = raw_input.trim().to_string().into();
        let alias_start = raw_input.find('[').unwrap_or(0); // used to check if the same alias already exists

-        // add to startup if alias doesn't exist and replce if it does
+        // add to startup if alias doesn't exist and replace if it does
        match result.get_mut("startup") {
            Some(startup) => {
                if let UntaggedValue::Table(ref mut commands) = startup.value {
@ -132,219 +131,91 @@ pub async fn alias(
        config::write(&result, &None)?;
    }

-    for item in list.iter() {
-        if let Ok(string) = item.as_string() {
-            processed_args.push(format!("${}", string));
+    let mut processed_args: Vec<VarDeclaration> = vec![];
+    for (_, item) in list.iter().enumerate() {
+        match item.as_string() {
+            Ok(var_name) => {
+                let dollar_var_name = format!("${}", var_name);
+                processed_args.push(VarDeclaration {
+                    name: dollar_var_name,
+                    // type_decl: None,
+                    span: item.tag.span,
+                });
+            }
+            Err(_) => {
+                return Err(ShellError::labeled_error(
+                    "Expected a string",
+                    "expected a string",
+                    item.tag(),
+                ));
+            }
+        }
+    }
+    trace!("Found vars: {:?}", processed_args);
+
+    let inferred_shapes = {
+        if let Some(true) = infer {
+            VarSyntaxShapeDeductor::infer_vars(&processed_args, &block, &registry)?
        } else {
-            return Err(ShellError::labeled_error(
-                "Expected a string",
-                "expected a string",
-                item.tag(),
-            ));
+            processed_args.into_iter().map(|arg| (arg, None)).collect()
        }
-    }
-
-    if let Some(true) = infer {
-        Ok(OutputStream::one(ReturnSuccess::action(
-            CommandAction::AddAlias(
-                name.to_string(),
-                to_arg_shapes(processed_args, &block, &registry)?,
-                block,
-            ),
-        )))
-    } else {
-        Ok(OutputStream::one(ReturnSuccess::action(
-            CommandAction::AddAlias(
-                name.to_string(),
-                processed_args
-                    .into_iter()
-                    .map(|arg| (arg, SyntaxShape::Any))
-                    .collect(),
-                block,
-            ),
-        )))
-    }
-}
-
-fn to_arg_shapes(
-    args: Vec<String>,
-    block: &Block,
-    registry: &CommandRegistry,
-) -> Result<Vec<(String, SyntaxShape)>, ShellError> {
-    match find_block_shapes(block, registry) {
-        Ok(found) => Ok(args
-            .iter()
-            .map(|arg| {
-                (
-                    arg.clone(),
-                    match found.get(arg) {
-                        None | Some((_, None)) => SyntaxShape::Any,
-                        Some((_, Some(shape))) => *shape,
-                    },
-                )
-            })
-            .collect()),
-        Err(err) => Err(err),
-    }
-}
-
-type ShapeMap = HashMap<String, (Span, Option<SyntaxShape>)>;
-
-fn check_insert(
-    existing: &mut ShapeMap,
-    to_add: (String, (Span, Option<SyntaxShape>)),
-) -> Result<(), ShellError> {
-    match (to_add.1).1 {
-        None => match existing.get(&to_add.0) {
-            None => {
-                existing.insert(to_add.0, to_add.1);
-                Ok(())
-            }
-            Some(_) => Ok(()),
-        },
-        Some(new) => match existing.insert(to_add.0.clone(), ((to_add.1).0, Some(new))) {
-            None => Ok(()),
-            Some(exist) => match exist.1 {
-                None => Ok(()),
-                Some(shape) => match shape {
-                    SyntaxShape::Any => Ok(()),
-                    shape if shape == new => Ok(()),
-                    _ => Err(ShellError::labeled_error_with_secondary(
-                        "Type conflict in alias variable use",
-                        format!("{:?}", new),
-                        (to_add.1).0,
-                        format!("{:?}", shape),
-                        exist.0,
-                    )),
-                },
-            },
-        },
-    }
-}
-
-fn check_merge(existing: &mut ShapeMap, new: &ShapeMap) -> Result<(), ShellError> {
-    for (k, v) in new.iter() {
-        check_insert(existing, (k.clone(), *v))?;
-    }
-
-    Ok(())
-}
-
-fn find_expr_shapes(
-    spanned_expr: &SpannedExpression,
-    registry: &CommandRegistry,
-) -> Result<ShapeMap, ShellError> {
-    match &spanned_expr.expr {
-        // TODO range will need similar if/when invocations can be parsed within range expression
-        Expression::Binary(bin) => find_expr_shapes(&bin.left, registry).and_then(|mut left| {
-            find_expr_shapes(&bin.right, registry)
-                .and_then(|right| check_merge(&mut left, &right).map(|()| left))
-        }),
-        Expression::Block(b) => find_block_shapes(&b, registry),
-        Expression::Path(path) => match &path.head.expr {
-            Expression::Invocation(b) => find_block_shapes(&b, registry),
-            Expression::Variable(Variable::Other(var, _)) => {
-                let mut result = HashMap::new();
-                result.insert(var.to_string(), (spanned_expr.span, None));
-                Ok(result)
-            }
-            _ => Ok(HashMap::new()),
-        },
-        _ => Ok(HashMap::new()),
-    }
-}
-
-fn find_block_shapes(block: &Block, registry: &CommandRegistry) -> Result<ShapeMap, ShellError> {
-    let apply_shape = |found: ShapeMap, sig_shape: SyntaxShape| -> ShapeMap {
-        found
-            .iter()
-            .map(|(v, sh)| match sh.1 {
-                None => (v.clone(), (sh.0, Some(sig_shape))),
-                Some(shape) => (v.clone(), (sh.0, Some(shape))),
-            })
-            .collect()
    };
+    let signature = DeductionToSignature::get(&name.item, &inferred_shapes);
+    trace!("Inferred signature: {:?}", signature);

-    let mut arg_shapes = HashMap::new();
-    for pipeline in &block.block {
-        for classified in &pipeline.list {
-            match classified {
-                ClassifiedCommand::Expr(spanned_expr) => {
-                    let found = find_expr_shapes(&spanned_expr, registry)?;
-                    check_merge(&mut arg_shapes, &found)?
-                }
-                ClassifiedCommand::Internal(internal) => {
-                    if let Some(signature) = registry.get(&internal.name) {
-                        if let Some(positional) = &internal.args.positional {
-                            for (i, spanned_expr) in positional.iter().enumerate() {
-                                let found = find_expr_shapes(&spanned_expr, registry)?;
-                                if i >= signature.positional.len() {
-                                    if let Some((sig_shape, _)) = &signature.rest_positional {
-                                        check_merge(
-                                            &mut arg_shapes,
-                                            &apply_shape(found, *sig_shape),
-                                        )?;
-                                    } else {
-                                        unreachable!("should have error'd in parsing");
-                                    }
-                                } else {
-                                    let (pos_type, _) = &signature.positional[i];
-                                    match pos_type {
-                                        // TODO pass on mandatory/optional?
-                                        PositionalType::Mandatory(_, sig_shape)
-                                        | PositionalType::Optional(_, sig_shape) => {
-                                            check_merge(
-                                                &mut arg_shapes,
-                                                &apply_shape(found, *sig_shape),
-                                            )?;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        if let Some(named) = &internal.args.named {
-                            for (name, val) in named.iter() {
-                                if let NamedValue::Value(_, spanned_expr) = val {
-                                    let found = find_expr_shapes(&spanned_expr, registry)?;
-                                    match signature.named.get(name) {
-                                        None => {
-                                            unreachable!("should have error'd in parsing");
-                                        }
-                                        Some((named_type, _)) => {
-                                            if let NamedType::Mandatory(_, sig_shape)
-                                            | NamedType::Optional(_, sig_shape) = named_type
-                                            {
-                                                check_merge(
-                                                    &mut arg_shapes,
-                                                    &apply_shape(found, *sig_shape),
-                                                )?;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    } else {
-                        unreachable!("registry has lost name it provided");
-                    }
-                }
-                ClassifiedCommand::Dynamic(_) | ClassifiedCommand::Error(_) => (),
-            }
-        }
-    }
-
-    Ok(arg_shapes)
+    Ok(OutputStream::one(ReturnSuccess::action(
+        CommandAction::AddAlias(Box::new(signature), block),
+    )))
 }

 #[cfg(test)]
 mod tests {
    use super::Alias;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Alias {})
+        Ok(test_examples(Alias {})?)
+    }
+}
+
+mod deduction_to_signature {
+    //For now this logic is relativly simple.
+    //For each var, one mandatory positional is added.
+    //As soon as more support for optional positional arguments is arrived,
+    //this logic might be a little bit more tricky.
+    use crate::types::deduction::{Deduction, VarDeclaration};
+    use nu_protocol::{PositionalType, Signature, SyntaxShape};
+
+    pub struct DeductionToSignature {}
+    impl DeductionToSignature {
+        pub fn get(
+            cmd_name: &str,
+            deductions: &[(VarDeclaration, Option<Deduction>)],
+        ) -> Signature {
+            let mut signature = Signature::build(cmd_name);
+            for (decl, deduction) in deductions {
+                match deduction {
+                    None => signature.positional.push((
+                        PositionalType::optional(&decl.name, SyntaxShape::Any),
+                        decl.name.clone(),
+                    )),
+                    Some(deduction) => match deduction {
+                        Deduction::VarShapeDeduction(normal_var_deduction) => {
+                            signature.positional.push((
+                                PositionalType::optional(
+                                    &decl.name,
+                                    normal_var_deduction[0].deduction,
+                                ),
+                                decl.name.clone(),
+                            ))
+                        }
+                    },
+                }
+            }
+            signature
+        }
    }
 }
--- a/crates/nu-cli/src/commands/ansi.rs
+++ b/crates/nu-cli/src/commands/ansi.rs
@ -3,12 +3,15 @@ use crate::prelude::*;
 use ansi_term::Color;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;

 pub struct Ansi;

 #[derive(Deserialize)]
 struct AnsiArgs {
    color: Value,
+    escape: Option<Tagged<String>>,
+    osc: Option<Tagged<String>>,
 }

 #[async_trait]
@ -18,15 +21,70 @@ impl WholeStreamCommand for Ansi {
    }

    fn signature(&self) -> Signature {
-        Signature::build("ansi").required(
-            "color",
-            SyntaxShape::Any,
-            "the name of the color to use or 'reset' to reset the color",
-        )
+        Signature::build("ansi")
+            .optional(
+                "color",
+                SyntaxShape::Any,
+                "the name of the color to use or 'reset' to reset the color",
+            )
+            .named(
+                "escape", // \x1b
+                SyntaxShape::Any,
+                "escape sequence without the escape character(s)",
+                Some('e'),
+            )
+            .named(
+                "osc",
+                SyntaxShape::Any,
+                "operating system command (ocs) escape sequence without the escape character(s)",
+                Some('o'),
+            )
    }

    fn usage(&self) -> &str {
-        "Output ANSI codes to change color"
+        r#"Output ANSI codes to change color
+
+For escape sequences:
+Escape: '\x1b[' is not required for --escape parameter
+Format: #(;#)m
+Example: 1;31m for bold red or 2;37;41m for dimmed white fg with red bg
+There can be multiple text formatting sequence numbers
+separated by a ; and ending with an m where the # is of the
+following values:
+    attributes
+    0    reset / normal display
+    1    bold or increased intensity
+    2    faint or decreased intensity
+    3    italic on (non-mono font)
+    4    underline on
+    5    slow blink on
+    6    fast blink on
+    7    reverse video on
+    8    nondisplayed (invisible) on
+    9    strike-through on
+
+    foreground/bright colors    background/bright colors
+    30/90    black              40/100    black
+    31/91    red                41/101    red
+    32/92    green              42/102    green
+    33/93    yellow             43/103    yellow
+    34/94    blue               44/104    blue
+    35/95    magenta            45/105    magenta
+    36/96    cyan               46/106    cyan
+    37/97    white              47/107    white
+    https://en.wikipedia.org/wiki/ANSI_escape_code
+
+OSC: '\x1b]' is not required for --osc parameter
+Example: echo [$(ansi -o '0') 'some title' $(char bel)] | str collect
+Format: #
+    0 Set window title and icon name
+    1 Set icon name
+    2 Set window title
+    4 Set/read color palette
+    9 iTerm2 Grown notifications
+    10 Set foreground color (x11 color spec)
+    11 Set background color (x11 color spec)
+    ... others"#
    }

    fn examples(&self) -> Vec<Example> {
@ -49,6 +107,14 @@ impl WholeStreamCommand for Ansi {
                    "\u{1b}[1;31mHello \u{1b}[1;32mNu \u{1b}[1;35mWorld",
                )]),
            },
+            Example {
+                description:
+                    "Use ansi to color text (rb = red bold, gb = green bold, pb = purple bold)",
+                example: r#"echo [$(ansi -e '3;93;41m') Hello $(ansi reset) " " $(ansi gb) Nu " " $(ansi pb) World] | str collect"#,
+                result: Some(vec![Value::from(
+                    "\u{1b}[3;93;41mHello\u{1b}[0m \u{1b}[1;32mNu \u{1b}[1;35mWorld",
+                )]),
+            },
        ]
    }

@ -57,10 +123,41 @@ impl WholeStreamCommand for Ansi {
        args: CommandArgs,
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
-        let (AnsiArgs { color }, _) = args.process(&registry).await?;
+        let (AnsiArgs { color, escape, osc }, _) = args.process(&registry).await?;
+
+        if let Some(e) = escape {
+            let esc_vec: Vec<char> = e.item.chars().collect();
+            if esc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    e.tag(),
+                ));
+            }
+            let output = format!("\x1b[{}", e.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(e.tag()),
+            )));
+        }
+
+        if let Some(o) = osc {
+            let osc_vec: Vec<char> = o.item.chars().collect();
+            if osc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    o.tag(),
+                ));
+            }
+            //Operating system command aka osc  ESC ] <- note the right brace, not left brace for osc
+            // OCS's need to end with a bell '\x07' char
+            let output = format!("\x1b]{};", o.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(o.tag()),
+            )));
+        }

        let color_string = color.as_string()?;
-
        let ansi_code = str_to_ansi_color(color_string);

        if let Some(output) = ansi_code {
@ -74,6 +171,7 @@ impl WholeStreamCommand for Ansi {
                color.tag(),
            ))
        }
+        // }
    }
 }

@ -135,11 +233,12 @@ pub fn str_to_ansi_color(s: String) -> Option<String> {
 #[cfg(test)]
 mod tests {
    use super::Ansi;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Ansi {})
+        Ok(test_examples(Ansi {})?)
    }
 }
--- a/crates/nu-cli/src/commands/append.rs
+++ b/crates/nu-cli/src/commands/append.rs
@ -2,17 +2,17 @@ use crate::command_registry::CommandRegistry;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};

 #[derive(Deserialize)]
-struct AppendArgs {
-    row: Value,
+struct Arguments {
+    value: Value,
 }

-pub struct Append;
+pub struct Command;

 #[async_trait]
-impl WholeStreamCommand for Append {
+impl WholeStreamCommand for Command {
    fn name(&self) -> &str {
        "append"
    }
@ -26,7 +26,7 @@ impl WholeStreamCommand for Append {
    }

    fn usage(&self) -> &str {
-        "Append the given row to the table"
+        "Append a row to the table"
    }

    async fn run(
@ -34,35 +34,57 @@ impl WholeStreamCommand for Append {
        args: CommandArgs,
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
-        let (AppendArgs { row }, input) = args.process(registry).await?;
+        let (Arguments { mut value }, input) = args.process(registry).await?;

-        let eos = futures::stream::iter(vec![row]);
+        let input: Vec<Value> = input.collect().await;

-        Ok(input.chain(eos).to_output_stream())
+        if let Some(first) = input.get(0) {
+            value.tag = first.tag();
+        }
+
+        // Checks if we are trying to append a row literal
+        if let Value {
+            value: UntaggedValue::Table(values),
+            tag,
+        } = &value
+        {
+            if values.len() == 1 && values[0].is_row() {
+                value = values[0].value.clone().into_value(tag);
+            }
+        }
+
+        Ok(futures::stream::iter(
+            input
+                .into_iter()
+                .chain(vec![value])
+                .map(ReturnSuccess::value),
+        )
+        .to_output_stream())
    }

    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Add something to the end of a list or table",
-            example: "echo [1 2 3] | append 4",
-            result: Some(vec![
-                UntaggedValue::int(1).into(),
-                UntaggedValue::int(2).into(),
-                UntaggedValue::int(3).into(),
-                UntaggedValue::int(4).into(),
-            ]),
-        }]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Append;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Append {})
+        use nu_protocol::row;
+
+        vec![
+            Example {
+                description: "Add values to the end of the table",
+                example: "echo [1 2 3] | append 4",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+            Example {
+                description: "Add row value to the end of the table",
+                example: "echo [[country]; [Ecuador] ['New Zealand']] | append [[country]; [USA]]",
+                result: Some(vec![
+                    row! { "country".into() => Value::from("Ecuador")},
+                    row! { "country".into() => Value::from("New Zealand")},
+                    row! { "country".into() => Value::from("USA")},
+                ]),
+            },
+        ]
    }
 }
--- a/crates/nu-cli/src/commands/autoview/command.rs
+++ b/crates/nu-cli/src/commands/autoview/command.rs
@ -318,7 +318,7 @@ fn create_default_command_args(context: &RunnableContextWithoutInput) -> RawComm
                external_redirection: ExternalRedirection::Stdout,
            },
            name_tag: context.name.clone(),
-            scope: Scope::new(),
+            scope: Scope::create(),
        },
    }
 }
@ -326,11 +326,12 @@ fn create_default_command_args(context: &RunnableContextWithoutInput) -> RawComm
 #[cfg(test)]
 mod tests {
    use super::Command;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Command {})
+        Ok(test_examples(Command {})?)
    }
 }
--- a/crates/nu-cli/src/commands/autoview/options.rs
+++ b/crates/nu-cli/src/commands/autoview/options.rs
@ -10,25 +10,16 @@ pub enum AutoPivotMode {

 impl AutoPivotMode {
    pub fn is_auto(&self) -> bool {
-        match &self {
-            AutoPivotMode::Auto => true,
-            _ => false,
-        }
+        matches!(self, AutoPivotMode::Auto)
    }

    pub fn is_always(&self) -> bool {
-        match &self {
-            AutoPivotMode::Always => true,
-            _ => false,
-        }
+        matches!(self, AutoPivotMode::Always)
    }

    #[allow(unused)]
    pub fn is_never(&self) -> bool {
-        match &self {
-            AutoPivotMode::Never => true,
-            _ => false,
-        }
+        matches!(self, AutoPivotMode::Never)
    }
 }

--- a/crates/nu-cli/src/commands/benchmark.rs
+++ b/crates/nu-cli/src/commands/benchmark.rs
@ -8,6 +8,10 @@ use nu_protocol::{
    hir::{Block, ClassifiedCommand, Commands, InternalCommand},
    Dictionary, Scope, Signature, SyntaxShape, UntaggedValue, Value,
 };
+use rand::{
+    distributions::Alphanumeric,
+    prelude::{thread_rng, Rng},
+};
 use std::convert::TryInto;
 use std::time::{Duration, Instant};

@ -79,20 +83,18 @@ async fn benchmark(
    let scope = raw_args.call_info.scope.clone();
    let (BenchmarkArgs { block, passthrough }, input) = raw_args.process(&registry).await?;

+    let env = scope.env();
+    let name = generate_free_name(&env);
+    let mut env = IndexMap::new();
+    env.insert(name, generate_random_env_value());
+    let scope = Scope::append_env(scope, env);
+
    let start_time = Instant::now();

    #[cfg(feature = "rich-benchmark")]
    let start = time().await;

-    let result = run_block(
-        &block,
-        &mut context,
-        input,
-        &scope.it,
-        &scope.vars,
-        &scope.env,
-    )
-    .await;
+    let result = run_block(&block, &mut context, input, scope.clone()).await;
    let output = result?.into_vec().await;

    #[cfg(feature = "rich-benchmark")]
@ -108,7 +110,7 @@ async fn benchmark(

        let real_time = into_big_int(end_time - start_time);
        indexmap.insert("real time".to_string(), real_time);
-        benchmark_output(indexmap, output, passthrough, &tag, &mut context, &scope).await
+        benchmark_output(indexmap, output, passthrough, &tag, &mut context, scope).await
    }
    // return advanced stats
    #[cfg(feature = "rich-benchmark")]
@ -127,7 +129,7 @@ async fn benchmark(
        let idle_time = into_big_int(end.idle() - start.idle());
        indexmap.insert("idle time".to_string(), idle_time);

-        benchmark_output(indexmap, output, passthrough, &tag, &mut context, &scope).await
+        benchmark_output(indexmap, output, passthrough, &tag, &mut context, scope).await
    } else {
        Err(ShellError::untagged_runtime_error(
            "Could not retreive CPU time",
@ -141,7 +143,7 @@ async fn benchmark_output<T, Output>(
    passthrough: Option<Block>,
    tag: T,
    context: &mut EvaluationContext,
-    scope: &Scope,
+    scope: Arc<Scope>,
 ) -> Result<OutputStream, ShellError>
 where
    T: Into<Tag> + Copy,
@ -161,15 +163,7 @@ where
        // add autoview for an empty block
        let time_block = add_implicit_autoview(time_block);

-        let _ = run_block(
-            &time_block,
-            context,
-            benchmark_output,
-            &scope.it,
-            &scope.vars,
-            &scope.env,
-        )
-        .await?;
+        let _ = run_block(&time_block, context, benchmark_output, scope).await?;
        context.clear_errors();

        Ok(block_output.into())
@ -200,3 +194,19 @@ fn into_big_int<T: TryInto<Duration>>(time: T) -> BigInt {
        .as_nanos()
        .into()
 }
+
+fn generate_random_env_value() -> String {
+    let mut thread_rng = thread_rng();
+    let len = thread_rng.gen_range(1, 16 * 1024);
+    thread_rng.sample_iter(&Alphanumeric).take(len).collect()
+}
+
+fn generate_free_name(env: &indexmap::IndexMap<String, String>) -> String {
+    let mut thread_rng = thread_rng();
+    loop {
+        let candidate_name = format!("NU_RANDOM_VALUE_{}", thread_rng.gen::<usize>());
+        if !env.contains_key(&candidate_name) {
+            return candidate_name;
+        }
+    }
+}
--- a/crates/nu-cli/src/commands/cal.rs
+++ b/crates/nu-cli/src/commands/cal.rs
@ -339,11 +339,12 @@ fn add_month_to_table(
 #[cfg(test)]
 mod tests {
    use super::Cal;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Cal {})
+        Ok(test_examples(Cal {})?)
    }
 }
--- a/crates/nu-cli/src/commands/cd.rs
+++ b/crates/nu-cli/src/commands/cd.rs
@ -72,11 +72,12 @@ impl WholeStreamCommand for Cd {
 #[cfg(test)]
 mod tests {
    use super::Cd;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Cd {})
+        Ok(test_examples(Cd {})?)
    }
 }
--- a/crates/nu-cli/src/commands/char_.rs
+++ b/crates/nu-cli/src/commands/char_.rs
@ -9,6 +9,7 @@ pub struct Char;
 #[derive(Deserialize)]
 struct CharArgs {
    name: Tagged<String>,
+    unicode: bool,
 }

 #[async_trait]
@ -18,11 +19,13 @@ impl WholeStreamCommand for Char {
    }

    fn signature(&self) -> Signature {
-        Signature::build("ansi").required(
-            "character",
-            SyntaxShape::Any,
-            "the name of the character to output",
-        )
+        Signature::build("ansi")
+            .required(
+                "character",
+                SyntaxShape::Any,
+                "the name of the character to output",
+            )
+            .switch("unicode", "unicode string i.e. 1f378", Some('u'))
    }

    fn usage(&self) -> &str {
@ -45,6 +48,11 @@ impl WholeStreamCommand for Char {
                    UntaggedValue::string("\u{2261}").into(),
                ]),
            },
+            Example {
+                description: "Output unicode character",
+                example: r#"char -u 1f378"#,
+                result: Some(vec![Value::from("\u{1f378}")]),
+            },
        ]
    }

@ -53,24 +61,44 @@ impl WholeStreamCommand for Char {
        args: CommandArgs,
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
-        let (CharArgs { name }, _) = args.process(&registry).await?;
+        let (CharArgs { name, unicode }, _) = args.process(&registry).await?;

-        let special_character = str_to_character(&name.item);
-
-        if let Some(output) = special_character {
-            Ok(OutputStream::one(ReturnSuccess::value(
-                UntaggedValue::string(output).into_value(name.tag()),
-            )))
+        if unicode {
+            let decoded_char = string_to_unicode_char(&name.item);
+            if let Some(output) = decoded_char {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error decoding unicode character",
+                    "error decoding unicode character",
+                    name.tag(),
+                ))
+            }
        } else {
-            Err(ShellError::labeled_error(
-                "Unknown character",
-                "unknown character",
-                name.tag(),
-            ))
+            let special_character = str_to_character(&name.item);
+            if let Some(output) = special_character {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error finding named character",
+                    "error finding named character",
+                    name.tag(),
+                ))
+            }
        }
    }
 }

+fn string_to_unicode_char(s: &str) -> Option<char> {
+    u32::from_str_radix(s, 16)
+        .ok()
+        .and_then(std::char::from_u32)
+}
+
 fn str_to_character(s: &str) -> Option<String> {
    match s {
        "newline" | "enter" | "nl" => Some("\n".into()),
@ -78,6 +106,7 @@ fn str_to_character(s: &str) -> Option<String> {
        "sp" | "space" => Some(" ".into()),
        // Unicode names came from https://www.compart.com/en/unicode
        // Private Use Area (U+E000-U+F8FF)
+        // Unicode can't be mixed with Ansi or it will break width calculation
        "branch" => Some('\u{e0a0}'.to_string()),  // 
        "segment" => Some('\u{e0b0}'.to_string()), // 

@ -96,15 +125,14 @@ fn str_to_character(s: &str) -> Option<String> {
        "hash" | "hashtag" | "pound_sign" | "sharp" | "root" => Some("#".into()),   // #

        // Weather symbols
-        "sun" => Some("\x1b[33;1m\u{2600}\x1b[0m".to_string()), // Yellow Bold ☀
-        "moon" => Some("\x1b[36m\u{263d}\x1b[0m".to_string()),  // Cyan ☽
-        "clouds" => Some("\x1b[37;1m\u{2601}\x1b[0m".to_string()), // White Bold ☁
-        "rain" => Some("\x1b[37;1m\u{2614}\x1b[0m".to_string()), // White Bold ☔
-        "fog" => Some("\x1b[37;1m\u{2592}\x1b[0m".to_string()), // White Bold ▒
-        "mist" => Some("\x1b[34m\u{2591}\x1b[0m".to_string()),  // Blue ░
-        "haze" => Some("\x1b[33m\u{2591}\x1b[0m".to_string()),  // Yellow ░
-        "snow" => Some("\x1b[37;1m\u{2744}\x1b[0m".to_string()), // White Bold ❄
-        "thunderstorm" => Some("\x1b[33;1m\u{26a1}\x1b[0m".to_string()), // Yellow Bold ⚡
+        "sun" | "sunny" | "sunrise" => Some("☀️".to_string()),
+        "moon" => Some("🌛".to_string()),
+        "cloudy" | "cloud" | "clouds" => Some("☁️".to_string()),
+        "rainy" | "rain" => Some("🌦️".to_string()),
+        "foggy" | "fog" => Some("🌫️".to_string()),
+        "mist" | "haze" => Some("\u{2591}".to_string()),
+        "snowy" | "snow" => Some("❄️".to_string()),
+        "thunderstorm" | "thunder" => Some("🌩️".to_string()),

        // Reference for ansi codes https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
        // Another good reference http://ascii-table.com/ansi-escape-sequences.php
@ -123,6 +151,7 @@ fn str_to_character(s: &str) -> Option<String> {
        "erase_line_from_cursor_to_end" => Some("\x1b[0K".to_string()), // clears from cursor to end of line
        "erase_line_from_cursor_to_beginning" => Some("\x1b[1K".to_string()), // clears from cursor to start of line
        "erase_entire_line" => Some("\x1b[2K".to_string()),                   // clears entire line
+
        _ => None,
    }
 }
@ -130,11 +159,12 @@ fn str_to_character(s: &str) -> Option<String> {
 #[cfg(test)]
 mod tests {
    use super::Char;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Char {})
+        Ok(test_examples(Char {})?)
    }
 }
--- a/crates/nu-cli/src/commands/chart.rs
+++ b/crates/nu-cli/src/commands/chart.rs
@ -0,0 +1,53 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+#[derive(Clone)]
+pub struct Chart;
+
+#[async_trait]
+impl WholeStreamCommand for Chart {
+    fn name(&self) -> &str {
+        "chart"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("chart")
+    }
+
+    fn usage(&self) -> &str {
+        "Displays charts."
+    }
+
+    async fn run(
+        &self,
+        _args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        if registry.get_command("chart bar").is_none() {
+            return Err(ShellError::untagged_runtime_error(
+                "nu_plugin_chart not installed.",
+            ));
+        }
+
+        let registry = registry.clone();
+        Ok(OutputStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(crate::commands::help::get_help(&Chart, &registry))
+                .into_value(Tag::unknown()),
+        ))))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Chart;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Chart {})?)
+    }
+}
--- a/crates/nu-cli/src/commands/classified/block.rs
+++ b/crates/nu-cli/src/commands/classified/block.rs
@ -6,16 +6,14 @@ use crate::stream::InputStream;
 use futures::stream::TryStreamExt;
 use nu_errors::ShellError;
 use nu_protocol::hir::{Block, ClassifiedCommand, Commands};
-use nu_protocol::{ReturnSuccess, UntaggedValue, Value};
+use nu_protocol::{ReturnSuccess, Scope, UntaggedValue, Value};
 use std::sync::atomic::Ordering;

-pub(crate) async fn run_block(
+pub async fn run_block(
    block: &Block,
    ctx: &mut EvaluationContext,
    mut input: InputStream,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
+    scope: Arc<Scope>,
 ) -> Result<InputStream, ShellError> {
    let mut output: Result<InputStream, ShellError> = Ok(InputStream::empty());
    for pipeline in &block.block {
@ -54,7 +52,7 @@ pub(crate) async fn run_block(
                return Err(e);
            }
        }
-        output = run_pipeline(pipeline, ctx, input, it, vars, env).await;
+        output = run_pipeline(pipeline, ctx, input, scope.clone()).await;

        input = InputStream::empty();
    }
@ -66,9 +64,7 @@ async fn run_pipeline(
    commands: &Commands,
    ctx: &mut EvaluationContext,
    mut input: InputStream,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
+    scope: Arc<Scope>,
 ) -> Result<InputStream, ShellError> {
    for item in commands.list.clone() {
        input = match item {
@ -77,13 +73,13 @@ async fn run_pipeline(
            }

            ClassifiedCommand::Expr(expr) => {
-                run_expression_block(*expr, ctx, it, vars, env).await?
+                run_expression_block(*expr, ctx, scope.clone()).await?
            }

            ClassifiedCommand::Error(err) => return Err(err.into()),

            ClassifiedCommand::Internal(left) => {
-                run_internal_command(left, ctx, input, it, vars, env).await?
+                run_internal_command(left, ctx, input, scope.clone()).await?
            }
        };
    }
--- a/crates/nu-cli/src/commands/classified/expr.rs
+++ b/crates/nu-cli/src/commands/classified/expr.rs
@ -6,14 +6,12 @@ use log::{log_enabled, trace};
 use futures::stream::once;
 use nu_errors::ShellError;
 use nu_protocol::hir::SpannedExpression;
-use nu_protocol::Value;
+use nu_protocol::Scope;

 pub(crate) async fn run_expression_block(
    expr: SpannedExpression,
    context: &mut EvaluationContext,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
+    scope: Arc<Scope>,
 ) -> Result<InputStream, ShellError> {
    if log_enabled!(log::Level::Trace) {
        trace!(target: "nu::run::expr", "->");
@ -21,7 +19,7 @@ pub(crate) async fn run_expression_block(
    }

    let registry = context.registry().clone();
-    let output = evaluate_baseline_expr(&expr, &registry, it, vars, env).await?;
+    let output = evaluate_baseline_expr(&expr, &registry, scope).await?;

    Ok(once(async { Ok(output) }).to_input_stream())
 }
--- a/crates/nu-cli/src/commands/classified/external.rs
+++ b/crates/nu-cli/src/commands/classified/external.rs
@ -3,6 +3,7 @@ use crate::evaluate::evaluate_baseline_expr;
 use crate::futures::ThreadedReceiver;
 use crate::prelude::*;

+use std::borrow::Cow;
 use std::io::Write;
 use std::ops::Deref;
 use std::process::{Command, Stdio};
@ -13,6 +14,7 @@ use futures_codec::FramedRead;
 use log::trace;

 use nu_errors::ShellError;
+use nu_protocol::hir::Expression;
 use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
 use nu_protocol::{Primitive, Scope, ShellTypeName, UntaggedValue, Value};
 use nu_source::Tag;
@ -21,7 +23,7 @@ pub(crate) async fn run_external_command(
    command: ExternalCommand,
    context: &mut EvaluationContext,
    input: InputStream,
-    scope: &Scope,
+    scope: Arc<Scope>,
    external_redirection: ExternalRedirection,
 ) -> Result<InputStream, ShellError> {
    trace!(target: "nu::run::external", "-> {}", command.name);
@ -41,7 +43,7 @@ async fn run_with_stdin(
    command: ExternalCommand,
    context: &mut EvaluationContext,
    input: InputStream,
-    scope: &Scope,
+    scope: Arc<Scope>,
    external_redirection: ExternalRedirection,
 ) -> Result<InputStream, ShellError> {
    let path = context.shell_manager.path();
@ -50,9 +52,8 @@ async fn run_with_stdin(

    let mut command_args = vec![];
    for arg in command.args.iter() {
-        let value =
-            evaluate_baseline_expr(arg, &context.registry, &scope.it, &scope.vars, &scope.env)
-                .await?;
+        let is_literal = matches!(arg.expr, Expression::Literal(_));
+        let value = evaluate_baseline_expr(arg, &context.registry, scope.clone()).await?;

        // Skip any arguments that don't really exist, treating them as optional
        // FIXME: we may want to preserve the gap in the future, though it's hard to say
@ -67,8 +68,10 @@ async fn run_with_stdin(
                for t in table {
                    match &t.value {
                        UntaggedValue::Primitive(_) => {
-                            command_args
-                                .push(t.convert_to_string().trim_end_matches('\n').to_string());
+                            command_args.push((
+                                t.convert_to_string().trim_end_matches('\n').to_string(),
+                                is_literal,
+                            ));
                        }
                        _ => {
                            return Err(ShellError::labeled_error(
@ -82,14 +85,14 @@ async fn run_with_stdin(
            }
            _ => {
                let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
-                command_args.push(trimmed_value_string);
+                command_args.push((trimmed_value_string, is_literal));
            }
        }
    }

    let process_args = command_args
        .iter()
-        .map(|arg| {
+        .map(|(arg, _is_literal)| {
            let home_dir;

            #[cfg(feature = "dirs")]
@ -105,8 +108,9 @@ async fn run_with_stdin(

            #[cfg(not(windows))]
            {
-                if argument_contains_whitespace(&arg) && !argument_is_quoted(&arg) {
-                    add_quotes(&arg)
+                if !_is_literal {
+                    let escaped = escape_double_quotes(&arg);
+                    add_double_quotes(&escaped)
                } else {
                    arg.as_ref().to_string()
                }
@ -138,7 +142,7 @@ fn spawn(
    args: &[String],
    input: InputStream,
    external_redirection: ExternalRedirection,
-    scope: &Scope,
+    scope: Arc<Scope>,
 ) -> Result<InputStream, ShellError> {
    let command = command.clone();

@ -169,7 +173,7 @@ fn spawn(
    trace!(target: "nu::run::external", "cwd = {:?}", &path);

    process.env_clear();
-    process.envs(scope.env.iter());
+    process.envs(scope.env());

    // We want stdout regardless of what
    // we are doing ($it case or pipe stdin)
@ -221,36 +225,19 @@ fn spawn(
                        UntaggedValue::Primitive(Primitive::Nothing) => continue,
                        UntaggedValue::Primitive(Primitive::String(s))
                        | UntaggedValue::Primitive(Primitive::Line(s)) => {
-                            if let Err(e) = stdin_write.write(s.as_bytes()) {
-                                let message = format!("Unable to write to stdin (error = {})", e);
-
-                                let _ = stdin_write_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        message,
-                                        "application may have closed before completing pipeline",
-                                        &stdin_name_tag,
-                                    )),
-                                    tag: stdin_name_tag,
-                                }));
-                                return Err(());
+                            if stdin_write.write(s.as_bytes()).is_err() {
+                                // Other side has closed, so exit
+                                return Ok(());
                            }
                        }
                        UntaggedValue::Primitive(Primitive::Binary(b)) => {
-                            if let Err(e) = stdin_write.write(b) {
-                                let message = format!("Unable to write to stdin (error = {})", e);
-
-                                let _ = stdin_write_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        message,
-                                        "application may have closed before completing pipeline",
-                                        &stdin_name_tag,
-                                    )),
-                                    tag: stdin_name_tag,
-                                }));
-                                return Err(());
+                            if stdin_write.write(b).is_err() {
+                                // Other side has closed, so exit
+                                return Ok(());
                            }
                        }
                        unsupported => {
+                            println!("Unsupported: {:?}", unsupported);
                            let _ = stdin_write_tx.send(Ok(Value {
                                value: UntaggedValue::Error(ShellError::labeled_error(
                                    format!(
@ -496,11 +483,6 @@ where
    shellexpand::tilde_with_context(input, home_dir)
 }

-#[allow(unused)]
-pub fn argument_contains_whitespace(argument: &str) -> bool {
-    argument.chars().any(|c| c.is_whitespace())
-}
-
 fn argument_is_quoted(argument: &str) -> bool {
    if argument.len() < 2 {
        return false;
@ -511,10 +493,20 @@ fn argument_is_quoted(argument: &str) -> bool {
 }

 #[allow(unused)]
-fn add_quotes(argument: &str) -> String {
+fn add_double_quotes(argument: &str) -> String {
    format!("\"{}\"", argument)
 }

+#[allow(unused)]
+fn escape_double_quotes(argument: &str) -> Cow<'_, str> {
+    // allocate new string only if required
+    if argument.contains('"') {
+        Cow::Owned(argument.replace('"', r#"\""#))
+    } else {
+        Cow::Borrowed(argument)
+    }
+}
+
 #[allow(unused)]
 fn remove_quotes(argument: &str) -> Option<&str> {
    if !argument_is_quoted(argument) {
@ -540,7 +532,7 @@ fn shell_os_paths() -> Vec<std::path::PathBuf> {
 #[cfg(test)]
 mod tests {
    use super::{
-        add_quotes, argument_contains_whitespace, argument_is_quoted, expand_tilde, remove_quotes,
+        add_double_quotes, argument_is_quoted, escape_double_quotes, expand_tilde, remove_quotes,
    };
    #[cfg(feature = "which")]
    use super::{run_external_command, EvaluationContext, InputStream};
@ -580,7 +572,7 @@ mod tests {
            cmd,
            &mut ctx,
            input,
-            &Scope::new(),
+            Scope::create(),
            ExternalRedirection::Stdout
        )
        .await
@ -620,10 +612,10 @@ mod tests {
    }

    #[test]
-    fn checks_contains_whitespace_from_argument_to_be_passed_in() {
-        assert_eq!(argument_contains_whitespace("andrés"), false);
-        assert_eq!(argument_contains_whitespace("and rés"), true);
-        assert_eq!(argument_contains_whitespace(r#"and\ rés"#), true);
+    fn checks_escape_double_quotes() {
+        assert_eq!(escape_double_quotes("andrés"), "andrés");
+        assert_eq!(escape_double_quotes(r#"an"drés"#), r#"an\"drés"#);
+        assert_eq!(escape_double_quotes(r#""an"drés""#), r#"\"an\"drés\""#);
    }

    #[test]
@ -651,9 +643,8 @@ mod tests {
    }

    #[test]
-    fn adds_quotes_to_argument_to_be_passed_in() {
-        assert_eq!(add_quotes("andrés"), "\"andrés\"");
-        //assert_eq!(add_quotes("\"andrés\""), "\"andrés\"");
+    fn adds_double_quotes_to_argument_to_be_passed_in() {
+        assert_eq!(add_double_quotes("andrés"), "\"andrés\"");
    }

    #[test]
--- a/crates/nu-cli/src/commands/classified/internal.rs
+++ b/crates/nu-cli/src/commands/classified/internal.rs
@ -11,20 +11,13 @@ pub(crate) async fn run_internal_command(
    command: InternalCommand,
    context: &mut EvaluationContext,
    input: InputStream,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
+    scope: Arc<Scope>,
 ) -> Result<InputStream, ShellError> {
    if log_enabled!(log::Level::Trace) {
        trace!(target: "nu::run::internal", "->");
        trace!(target: "nu::run::internal", "{}", command.name);
    }

-    let scope = Scope {
-        it: it.clone(),
-        vars: vars.clone(),
-        env: env.clone(),
-    };
    let objects: InputStream = trace_stream!(target: "nu::trace_stream::internal", "input" = input);
    let internal_command = context.expect_command(&command.name);

@ -38,7 +31,7 @@ pub(crate) async fn run_internal_command(
                internal_command?,
                Tag::unknown_anchor(command.name_span),
                command.args.clone(),
-                &scope,
+                scope.clone(),
                objects,
            )
            .await?
@ -48,8 +41,6 @@ pub(crate) async fn run_internal_command(
    //let context = Arc::new(context.clone());
    let context = context.clone();
    let command = Arc::new(command);
-    let scope = Arc::new(scope);
-    // let scope = scope.clone();

    Ok(InputStream::from_stream(
        result
@ -90,7 +81,7 @@ pub(crate) async fn run_internal_command(
                                                external_redirection: ExternalRedirection::Stdout,
                                            },
                                            name_tag: Tag::unknown_anchor(command.name_span),
-                                            scope: (&*scope).clone(),
+                                            scope,
                                        },
                                    };
                                    let result = converter
@ -194,9 +185,9 @@ pub(crate) async fn run_internal_command(
                                ));
                                InputStream::from_stream(futures::stream::iter(vec![]))
                            }
-                            CommandAction::AddAlias(name, args, block) => {
+                            CommandAction::AddAlias(sig, block) => {
                                context.add_commands(vec![whole_stream_command(
-                                    AliasCommand::new(name, args, block),
+                                    AliasCommand::new(*sig, block),
                                )]);
                                InputStream::from_stream(futures::stream::iter(vec![]))
                            }
--- a/crates/nu-cli/src/commands/classified/plugin.rs
+++ b/crates/nu-cli/src/commands/classified/plugin.rs
@ -130,7 +130,7 @@ async fn run_filter(
        UntaggedValue::Primitive(Primitive::EndOfStream).into_untagged_value()
    ]);

-    let args = args.evaluate_once_with_scope(&registry, &scope).await?;
+    let args = args.evaluate_once_with_scope(&registry, scope).await?;

    let real_path = Path::new(&path);
    let ext = real_path.extension();
--- a/crates/nu-cli/src/commands/clear.rs
+++ b/crates/nu-cli/src/commands/clear.rs
@ -43,15 +43,3 @@ impl WholeStreamCommand for Clear {
        }]
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::Clear;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Clear {})
-    }
-}
--- a/crates/nu-cli/src/commands/clip.rs
+++ b/crates/nu-cli/src/commands/clip.rs
@ -32,11 +32,18 @@ impl WholeStreamCommand for Clip {
    }

    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Save text to the clipboard",
-            example: "echo 'secret value' | clip",
-            result: None,
-        }]
+        vec![
+            Example {
+                description: "Save text to the clipboard",
+                example: "echo 'secret value' | clip",
+                result: None,
+            },
+            Example {
+                description: "Save numbers to the clipboard",
+                example: "random integer 10000000..99999999 | clip",
+                result: None,
+            },
+        ]
    }
 }

@ -56,21 +63,19 @@ pub async fn clip(
            let mut first = true;
            for i in values.iter() {
                if !first {
-                    new_copy_data.push_str("\n");
+                    new_copy_data.push('\n');
                } else {
                    first = false;
                }

-                let string: String = match i.as_string() {
-                    Ok(string) => string.to_string(),
-                    Err(_) => {
-                        return Err(ShellError::labeled_error(
-                            "Given non-string data",
-                            "expected strings from pipeline",
-                            name,
-                        ))
-                    }
-                };
+                let string: String = i.convert_to_string();
+                if string.is_empty() {
+                    return Err(ShellError::labeled_error(
+                        "Unable to convert to string",
+                        "Unable to convert to string",
+                        name,
+                    ));
+                }

                new_copy_data.push_str(&string);
            }
@ -99,11 +104,12 @@ pub async fn clip(
 #[cfg(test)]
 mod tests {
    use super::Clip;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Clip {})
+        Ok(test_examples(Clip {})?)
    }
 }
--- a/crates/nu-cli/src/commands/command.rs
+++ b/crates/nu-cli/src/commands/command.rs
@ -17,27 +17,12 @@ use std::sync::atomic::AtomicBool;
 pub struct UnevaluatedCallInfo {
    pub args: hir::Call,
    pub name_tag: Tag,
-    pub scope: Scope,
+    pub scope: Arc<Scope>,
 }

 impl UnevaluatedCallInfo {
    pub async fn evaluate(self, registry: &CommandRegistry) -> Result<CallInfo, ShellError> {
-        let args = evaluate_args(&self.args, registry, &self.scope).await?;
-
-        Ok(CallInfo {
-            args,
-            name_tag: self.name_tag,
-        })
-    }
-
-    pub async fn evaluate_with_new_it(
-        self,
-        registry: &CommandRegistry,
-        it: &Value,
-    ) -> Result<CallInfo, ShellError> {
-        let mut scope = self.scope.clone();
-        scope.it = it.clone();
-        let args = evaluate_args(&self.args, registry, &scope).await?;
+        let args = evaluate_args(&self.args, registry, self.scope.clone()).await?;

        Ok(CallInfo {
            args,
@ -115,7 +100,7 @@ impl CommandArgs {
    pub async fn evaluate_once_with_scope(
        self,
        registry: &CommandRegistry,
-        scope: &Scope,
+        scope: Arc<Scope>,
    ) -> Result<EvaluatedWholeStreamCommandArgs, ShellError> {
        let host = self.host.clone();
        let ctrl_c = self.ctrl_c.clone();
@ -215,37 +200,6 @@ impl EvaluatedWholeStreamCommandArgs {
    }
 }

-#[derive(Getters)]
-#[get = "pub"]
-pub struct EvaluatedFilterCommandArgs {
-    args: EvaluatedCommandArgs,
-}
-
-impl Deref for EvaluatedFilterCommandArgs {
-    type Target = EvaluatedCommandArgs;
-    fn deref(&self) -> &Self::Target {
-        &self.args
-    }
-}
-
-impl EvaluatedFilterCommandArgs {
-    pub fn new(
-        host: Arc<parking_lot::Mutex<dyn Host>>,
-        ctrl_c: Arc<AtomicBool>,
-        shell_manager: ShellManager,
-        call_info: CallInfo,
-    ) -> EvaluatedFilterCommandArgs {
-        EvaluatedFilterCommandArgs {
-            args: EvaluatedCommandArgs {
-                host,
-                ctrl_c,
-                shell_manager,
-                call_info,
-            },
-        }
-    }
-}
-
 #[derive(Getters, new)]
 #[get = "pub(crate)"]
 pub struct EvaluatedCommandArgs {
@ -381,69 +335,6 @@ impl Command {
    }
 }

-pub struct FnFilterCommand {
-    name: String,
-    func: fn(EvaluatedFilterCommandArgs) -> Result<OutputStream, ShellError>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for FnFilterCommand {
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn usage(&self) -> &str {
-        "usage"
-    }
-
-    async fn run(
-        &self,
-        CommandArgs {
-            host,
-            ctrl_c,
-            shell_manager,
-            call_info,
-            input,
-            ..
-        }: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = Arc::new(registry.clone());
-        let func = self.func;
-
-        Ok(input
-            .then(move |it| {
-                let host = host.clone();
-                let registry = registry.clone();
-                let ctrl_c = ctrl_c.clone();
-                let shell_manager = shell_manager.clone();
-                let call_info = call_info.clone();
-                async move {
-                    let call_info = match call_info.evaluate_with_new_it(&*registry, &it).await {
-                        Err(err) => {
-                            return OutputStream::one(Err(err));
-                        }
-                        Ok(args) => args,
-                    };
-
-                    let args = EvaluatedFilterCommandArgs::new(
-                        host.clone(),
-                        ctrl_c.clone(),
-                        shell_manager.clone(),
-                        call_info,
-                    );
-
-                    match func(args) {
-                        Err(err) => return OutputStream::one(Err(err)),
-                        Ok(stream) => stream,
-                    }
-                }
-            })
-            .flatten()
-            .to_output_stream())
-    }
-}
-
 pub fn whole_stream_command(command: impl WholeStreamCommand + 'static) -> Command {
    Command(Arc::new(command))
 }
--- a/crates/nu-cli/src/commands/compact.rs
+++ b/crates/nu-cli/src/commands/compact.rs
@ -37,22 +37,11 @@ impl WholeStreamCommand for Compact {
    }

    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Filter out all null entries in a list",
-                example: "echo [1 2 $null 3 $null $null] | compact",
-                result: Some(vec![
-                    UntaggedValue::int(1).into(),
-                    UntaggedValue::int(2).into(),
-                    UntaggedValue::int(3).into(),
-                ]),
-            },
-            Example {
-                description: "Filter out all directory entries having no 'target'",
-                example: "ls -la | compact target",
-                result: None,
-            },
-        ]
+        vec![Example {
+            description: "Filter out all directory entries having no 'target'",
+            example: "ls -la | compact target",
+            result: None,
+        }]
    }
 }

@ -95,11 +84,12 @@ pub async fn compact(
 #[cfg(test)]
 mod tests {
    use super::Compact;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Compact {})
+        Ok(test_examples(Compact {})?)
    }
 }
--- a/crates/nu-cli/src/commands/config/get.rs
+++ b/crates/nu-cli/src/commands/config/get.rs
@ -2,14 +2,13 @@ use crate::command_registry::CommandRegistry;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};

 pub struct SubCommand;

 #[derive(Deserialize)]
 pub struct GetArgs {
-    get: Tagged<String>,
+    path: ColumnPath,
 }

 #[async_trait]
@ -21,7 +20,7 @@ impl WholeStreamCommand for SubCommand {
    fn signature(&self) -> Signature {
        Signature::build("config get").required(
            "get",
-            SyntaxShape::Any,
+            SyntaxShape::ColumnPath,
            "value to get from the config",
        )
    }
@ -51,17 +50,14 @@ pub async fn get(
    args: CommandArgs,
    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-    let (GetArgs { get }, _) = args.process(&registry).await?;
+    let name_tag = args.call_info.name_tag.clone();
+    let (GetArgs { path }, _) = args.process(&registry).await?;

    // NOTE: None because we are not loading a new config file, we just want to read from the
    // existing config
-    let result = nu_data::config::read(name_span, &None)?;
+    let result = UntaggedValue::row(nu_data::config::read(&name_tag, &None)?).into_value(&name_tag);

-    let key = get.to_string();
-    let value = result
-        .get(&key)
-        .ok_or_else(|| ShellError::labeled_error("Missing key in config", "key", get.tag()))?;
+    let value = crate::commands::get::get_column_path(&path, &result)?;

    Ok(match value {
        Value {
@ -75,9 +71,6 @@ pub async fn get(

            futures::stream::iter(list).to_output_stream()
        }
-        x => {
-            let x = x.clone();
-            OutputStream::one(ReturnSuccess::value(x))
-        }
+        x => OutputStream::one(ReturnSuccess::value(x)),
    })
 }
--- a/crates/nu-cli/src/commands/config/set.rs
+++ b/crates/nu-cli/src/commands/config/set.rs
@ -2,14 +2,13 @@ use crate::command_registry::CommandRegistry;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};

 pub struct SubCommand;

 #[derive(Deserialize)]
 pub struct SetArgs {
-    key: Tagged<String>,
+    path: ColumnPath,
    value: Value,
 }

@ -21,7 +20,7 @@ impl WholeStreamCommand for SubCommand {

    fn signature(&self) -> Signature {
        Signature::build("config set")
-            .required("key", SyntaxShape::String, "variable name to set")
+            .required("key", SyntaxShape::ColumnPath, "variable name to set")
            .required("value", SyntaxShape::Any, "value to use")
    }

@ -38,11 +37,28 @@ impl WholeStreamCommand for SubCommand {
    }

    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Set nonzero_exit_errors to true",
-            example: "config set nonzero_exit_errors $true",
-            result: None,
-        }]
+        vec![
+            Example {
+                description: "Set auto pivoting",
+                example: "config set pivot_mode always",
+                result: None,
+            },
+            Example {
+                description: "Set line editor options",
+                example: "config set line_editor [[edit_mode, completion_type]; [emacs circular]]",
+                result: None,
+            },
+            Example {
+                description: "Set coloring options",
+                example: "config set color_config [[header_align header_bold]; [left $true]]",
+                result: None,
+            },
+            Example {
+                description: "Set nested options",
+                example: "config set color_config.header_color white",
+                result: None,
+            },
+        ]
    }
 }

@ -50,18 +66,32 @@ pub async fn set(
    args: CommandArgs,
    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-    let (SetArgs { key, value }, _) = args.process(&registry).await?;
+    let name_tag = args.call_info.name_tag.clone();
+    let (SetArgs { path, mut value }, _) = args.process(&registry).await?;

    // NOTE: None because we are not loading a new config file, we just want to read from the
    // existing config
-    let mut result = nu_data::config::read(name_span, &None)?;
+    let raw_entries = nu_data::config::read(&name_tag, &None)?;
+    let configuration = UntaggedValue::row(raw_entries).into_value(&name_tag);

-    result.insert(key.to_string(), value.clone());
+    if let UntaggedValue::Table(rows) = &value.value {
+        if rows.len() == 1 && rows[0].is_row() {
+            value = rows[0].clone();
+        }
+    }

-    config::write(&result, &None)?;
+    match configuration.forgiving_insert_data_at_column_path(&path, value) {
+        Ok(Value {
+            value: UntaggedValue::Row(changes),
+            ..
+        }) => {
+            config::write(&changes.entries, &None)?;

-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::Row(result.into()).into_value(&value.tag),
-    )))
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::Row(changes).into_value(name_tag),
+            )))
+        }
+        Ok(_) => Ok(OutputStream::empty()),
+        Err(reason) => Err(reason),
+    }
 }
--- a/crates/nu-cli/src/commands/count.rs
+++ b/crates/nu-cli/src/commands/count.rs
@ -80,11 +80,12 @@ impl WholeStreamCommand for Count {
 #[cfg(test)]
 mod tests {
    use super::Count;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Count {})
+        Ok(test_examples(Count {})?)
    }
 }
--- a/crates/nu-cli/src/commands/cp.rs
+++ b/crates/nu-cli/src/commands/cp.rs
@ -66,11 +66,12 @@ impl WholeStreamCommand for Cpy {
 #[cfg(test)]
 mod tests {
    use super::Cpy;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Cpy {})
+        Ok(test_examples(Cpy {})?)
    }
 }
--- a/crates/nu-cli/src/commands/date/command.rs
+++ b/crates/nu-cli/src/commands/date/command.rs
@ -36,11 +36,12 @@ impl WholeStreamCommand for Command {
 #[cfg(test)]
 mod tests {
    use super::Command;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Command {})
+        Ok(test_examples(Command {})?)
    }
 }
--- a/crates/nu-cli/src/commands/date/format.rs
+++ b/crates/nu-cli/src/commands/date/format.rs
@ -1,18 +1,18 @@
-use crate::prelude::*;
-use chrono::{DateTime, Local};
-use nu_errors::ShellError;
-
-use crate::commands::date::utils::{date_to_value, date_to_value_raw};
 use crate::commands::WholeStreamCommand;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    Dictionary, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
 use nu_source::Tagged;
+use std::fmt::{self, write};

 pub struct Date;

 #[derive(Deserialize)]
 pub struct FormatArgs {
    format: Tagged<String>,
-    raw: Option<bool>,
+    table: bool,
 }

 #[async_trait]
@ -24,11 +24,11 @@ impl WholeStreamCommand for Date {
    fn signature(&self) -> Signature {
        Signature::build("date format")
            .required("format", SyntaxShape::String, "strftime format")
-            .switch("raw", "print date without tables", Some('r'))
+            .switch("table", "print date in a table", Some('t'))
    }

    fn usage(&self) -> &str {
-        "format the current date using the given format string."
+        "Format a given date using the given format string."
    }

    async fn run(
@ -38,6 +38,21 @@ impl WholeStreamCommand for Date {
    ) -> Result<OutputStream, ShellError> {
        format(args, registry).await
    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Format the current date",
+                example: "date now | date format '%Y.%m.%d_%H %M %S,%z'",
+                result: None,
+            },
+            Example {
+                description: "Format the current date and print in a table",
+                example: "date now | date format -t '%Y-%m-%d_%H:%M:%S %z'",
+                result: None,
+            },
+        ]
+    }
 }

 pub async fn format(
@ -46,18 +61,57 @@ pub async fn format(
 ) -> Result<OutputStream, ShellError> {
    let registry = registry.clone();
    let tag = args.call_info.name_tag.clone();
-    let (FormatArgs { format, raw }, _) = args.process(&registry).await?;
+    let (FormatArgs { format, table }, input) = args.process(&registry).await?;

-    let dt_fmt = format.to_string();
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => {
+                let mut output = String::new();
+                if let Err(fmt::Error) =
+                    write(&mut output, format_args!("{}", dt.format(&format.item)))
+                {
+                    Err(ShellError::labeled_error(
+                        "The date format is invalid",
+                        "invalid strftime format",
+                        &format.tag,
+                    ))
+                } else {
+                    let value = if table {
+                        let mut indexmap = IndexMap::new();
+                        indexmap.insert(
+                            "formatted".to_string(),
+                            UntaggedValue::string(&output).into_value(&tag),
+                        );

-    let value = {
-        let local: DateTime<Local> = Local::now();
-        if let Some(true) = raw {
-            UntaggedValue::string(date_to_value_raw(local, dt_fmt)).into_untagged_value()
-        } else {
-            date_to_value(local, tag, dt_fmt)
-        }
-    };
+                        UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag)
+                    } else {
+                        UntaggedValue::string(&output).into_value(&tag)
+                    };

-    Ok(OutputStream::one(value))
+                    ReturnSuccess::value(value)
+                }
+            }
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
 }
--- a/crates/nu-cli/src/commands/date/list_timezone.rs
+++ b/crates/nu-cli/src/commands/date/list_timezone.rs
@ -0,0 +1,82 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use chrono_tz::TZ_VARIANTS;
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date list-timezone"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date list-timezone")
+    }
+
+    fn usage(&self) -> &str {
+        "List supported time zones."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        list_timezone(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "List all supported time zones",
+                example: "date list-timezone",
+                result: None,
+            },
+            Example {
+                description: "List all supported European time zones",
+                example: "date list-timezone | where timezone =~ Europe",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn list_timezone(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once(&registry).await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let list = TZ_VARIANTS.iter().map(move |tz| {
+        let mut entries = IndexMap::new();
+
+        entries.insert(
+            "timezone".to_string(),
+            UntaggedValue::string(tz.name()).into_value(&tag),
+        );
+
+        Ok(ReturnSuccess::Value(
+            UntaggedValue::Row(Dictionary { entries }).into_value(&tag),
+        ))
+    });
+
+    Ok(futures::stream::iter(list).to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}
--- a/crates/nu-cli/src/commands/date/mod.rs
+++ b/crates/nu-cli/src/commands/date/mod.rs
@ -1,11 +1,15 @@
 pub mod command;
 pub mod format;
+pub mod list_timezone;
 pub mod now;
-pub mod utc;
+pub mod to_table;
+pub mod to_timezone;

-mod utils;
+mod parser;

 pub use command::Command as Date;
 pub use format::Date as DateFormat;
+pub use list_timezone::Date as DateListTimeZone;
 pub use now::Date as DateNow;
-pub use utc::Date as DateUTC;
+pub use to_table::Date as DateToTable;
+pub use to_timezone::Date as DateToTimeZone;
--- a/crates/nu-cli/src/commands/date/now.rs
+++ b/crates/nu-cli/src/commands/date/now.rs
@ -1,10 +1,8 @@
+use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use chrono::{DateTime, Local};
 use nu_errors::ShellError;
-
-use crate::commands::date::utils::date_to_value;
-use crate::commands::WholeStreamCommand;
-use nu_protocol::Signature;
+use nu_protocol::{Signature, UntaggedValue};

 pub struct Date;

@ -19,7 +17,7 @@ impl WholeStreamCommand for Date {
    }

    fn usage(&self) -> &str {
-        "return the current date."
+        "Get the current date."
    }

    async fn run(
@ -35,16 +33,25 @@ pub async fn now(
    args: CommandArgs,
    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
    let args = args.evaluate_once(&registry).await?;
    let tag = args.call_info.name_tag.clone();

-    let no_fmt = "".to_string();
+    let now: DateTime<Local> = Local::now();

-    let value = {
-        let local: DateTime<Local> = Local::now();
-        date_to_value(local, tag, no_fmt)
-    };
+    let value = UntaggedValue::date(now.with_timezone(now.offset())).into_value(&tag);

    Ok(OutputStream::one(value))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}
--- a/crates/nu-cli/src/commands/date/parser.rs
+++ b/crates/nu-cli/src/commands/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 })
+}
--- a/crates/nu-cli/src/commands/date/to_table.rs
+++ b/crates/nu-cli/src/commands/date/to_table.rs
@ -0,0 +1,113 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use chrono::{Datelike, Timelike};
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    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."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        to_table(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Print the current date in a table",
+            example: "date now | date to-table",
+            result: None,
+        }]
+    }
+}
+
+async fn to_table(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let args = args.evaluate_once(&registry).await?;
+    let tag = args.call_info.name_tag.clone();
+    let input = args.input;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => {
+                let mut indexmap = IndexMap::new();
+
+                indexmap.insert(
+                    "year".to_string(),
+                    UntaggedValue::int(dt.year()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "month".to_string(),
+                    UntaggedValue::int(dt.month()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "day".to_string(),
+                    UntaggedValue::int(dt.day()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "hour".to_string(),
+                    UntaggedValue::int(dt.hour()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "minute".to_string(),
+                    UntaggedValue::int(dt.minute()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "second".to_string(),
+                    UntaggedValue::int(dt.second()).into_value(&tag),
+                );
+
+                let tz = dt.offset();
+                indexmap.insert(
+                    "timezone".to_string(),
+                    UntaggedValue::string(format!("{}", tz)).into_value(&tag),
+                );
+
+                let value = UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag);
+
+                ReturnSuccess::value(value)
+            }
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}
--- a/crates/nu-cli/src/commands/date/to_timezone.rs
+++ b/crates/nu-cli/src/commands/date/to_timezone.rs
@ -0,0 +1,118 @@
+use crate::commands::date::parser::{datetime_in_timezone, ParseErrorKind};
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Date;
+
+#[derive(Deserialize)]
+struct DateToTimeZoneArgs {
+    timezone: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    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.
+        
+Use `date list-timezone` to list all supported time zones.
+        "
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        to_timezone(args, registry).await
+    }
+
+    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,
+            },
+        ]
+    }
+}
+
+async fn to_timezone(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let tag = args.call_info.name_tag.clone();
+    let (DateToTimeZoneArgs { timezone }, input) = args.process(&registry).await?;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => match datetime_in_timezone(&dt, &timezone.item) {
+                Ok(dt) => {
+                    let value = UntaggedValue::date(dt).into_value(&tag);
+
+                    ReturnSuccess::value(value)
+                }
+                Err(e) => Err(ShellError::labeled_error(
+                    error_message(e),
+                    "invalid time zone",
+                    &timezone.tag,
+                )),
+            },
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+fn error_message(err: ParseErrorKind) -> &'static str {
+    match err {
+        ParseErrorKind::Invalid => "The time zone description is invalid",
+        ParseErrorKind::OutOfRange => "The time zone offset is out of range",
+        ParseErrorKind::TooShort => "The format of the time zone is invalid",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}
--- a/crates/nu-cli/src/commands/date/utc.rs
+++ b/crates/nu-cli/src/commands/date/utc.rs
@ -1,50 +0,0 @@
-use crate::prelude::*;
-use chrono::{DateTime, Utc};
-use nu_errors::ShellError;
-
-use crate::commands::date::utils::date_to_value;
-use crate::commands::WholeStreamCommand;
-use nu_protocol::Signature;
-
-pub struct Date;
-
-#[async_trait]
-impl WholeStreamCommand for Date {
-    fn name(&self) -> &str {
-        "date utc"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("date utc")
-    }
-
-    fn usage(&self) -> &str {
-        "return the current date in utc."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        utc(args, registry).await
-    }
-}
-
-pub async fn utc(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
-    let tag = args.call_info.name_tag.clone();
-
-    let no_fmt = "".to_string();
-
-    let value = {
-        let local: DateTime<Utc> = Utc::now();
-        date_to_value(local, tag, no_fmt)
-    };
-
-    Ok(OutputStream::one(value))
-}
--- a/crates/nu-cli/src/commands/date/utils.rs
+++ b/crates/nu-cli/src/commands/date/utils.rs
@ -1,64 +0,0 @@
-use crate::prelude::*;
-use chrono::DateTime;
-use nu_protocol::{Dictionary, Value};
-
-use chrono::{Datelike, TimeZone, Timelike};
-use core::fmt::Display;
-use indexmap::IndexMap;
-use nu_protocol::UntaggedValue;
-
-pub fn date_to_value_raw<T: TimeZone>(dt: DateTime<T>, dt_format: String) -> String
-where
-    T::Offset: Display,
-{
-    let result = dt.format(&dt_format);
-    format!("{}", result)
-}
-
-pub fn date_to_value<T: TimeZone>(dt: DateTime<T>, tag: Tag, dt_format: String) -> Value
-where
-    T::Offset: Display,
-{
-    let mut indexmap = IndexMap::new();
-
-    if dt_format.is_empty() {
-        indexmap.insert(
-            "year".to_string(),
-            UntaggedValue::int(dt.year()).into_value(&tag),
-        );
-        indexmap.insert(
-            "month".to_string(),
-            UntaggedValue::int(dt.month()).into_value(&tag),
-        );
-        indexmap.insert(
-            "day".to_string(),
-            UntaggedValue::int(dt.day()).into_value(&tag),
-        );
-        indexmap.insert(
-            "hour".to_string(),
-            UntaggedValue::int(dt.hour()).into_value(&tag),
-        );
-        indexmap.insert(
-            "minute".to_string(),
-            UntaggedValue::int(dt.minute()).into_value(&tag),
-        );
-        indexmap.insert(
-            "second".to_string(),
-            UntaggedValue::int(dt.second()).into_value(&tag),
-        );
-
-        let tz = dt.offset();
-        indexmap.insert(
-            "timezone".to_string(),
-            UntaggedValue::string(format!("{}", tz)).into_value(&tag),
-        );
-    } else {
-        let result = dt.format(&dt_format);
-        indexmap.insert(
-            "formatted".to_string(),
-            UntaggedValue::string(format!("{}", result)).into_value(&tag),
-        );
-    }
-
-    UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag)
-}
--- a/crates/nu-cli/src/commands/debug.rs
+++ b/crates/nu-cli/src/commands/debug.rs
@ -55,11 +55,12 @@ async fn debug_value(
 #[cfg(test)]
 mod tests {
    use super::Debug;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Debug {})
+        Ok(test_examples(Debug {})?)
    }
 }
--- a/crates/nu-cli/src/commands/default.rs
+++ b/crates/nu-cli/src/commands/default.rs
@ -83,11 +83,12 @@ async fn default(
 #[cfg(test)]
 mod tests {
    use super::Default;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Default {})
+        Ok(test_examples(Default {})?)
    }
 }
--- a/crates/nu-cli/src/commands/describe.rs
+++ b/crates/nu-cli/src/commands/describe.rs
@ -4,13 +4,13 @@ use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};

-pub struct What;
+pub struct Describe;

 #[derive(Deserialize)]
-pub struct WhatArgs {}
+pub struct DescribeArgs {}

 #[async_trait]
-impl WholeStreamCommand for What {
+impl WholeStreamCommand for Describe {
    fn name(&self) -> &str {
        "describe"
    }
@ -28,11 +28,11 @@ impl WholeStreamCommand for What {
        args: CommandArgs,
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
-        what(args, registry).await
+        describe(args, registry).await
    }
 }

-pub async fn what(
+pub async fn describe(
    args: CommandArgs,
    _registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
@ -49,12 +49,13 @@ pub async fn what(

 #[cfg(test)]
 mod tests {
-    use super::What;
+    use super::Describe;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(What {})
+        Ok(test_examples(Describe {})?)
    }
 }
--- a/crates/nu-cli/src/commands/do_.rs
+++ b/crates/nu-cli/src/commands/do_.rs
@ -95,15 +95,7 @@ async fn do_(

    block.set_redirect(block_redirection);

-    let result = run_block(
-        &block,
-        &mut context,
-        input,
-        &scope.it,
-        &scope.vars,
-        &scope.env,
-    )
-    .await;
+    let result = run_block(&block, &mut context, input, scope).await;

    if ignore_errors {
        // To properly ignore errors we need to redirect stderr, consume it, and remove
@ -125,11 +117,12 @@ async fn do_(
 #[cfg(test)]
 mod tests {
    use super::Do;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Do {})
+        Ok(test_examples(Do {})?)
    }
 }
--- a/crates/nu-cli/src/commands/drop.rs
+++ b/crates/nu-cli/src/commands/drop.rs
@ -85,11 +85,12 @@ async fn drop(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStr
 #[cfg(test)]
 mod tests {
    use super::Drop;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Drop {})
+        Ok(test_examples(Drop {})?)
    }
 }
--- a/crates/nu-cli/src/commands/du.rs
+++ b/crates/nu-cli/src/commands/du.rs
@ -427,11 +427,12 @@ impl From<FileInfo> for Value {
 #[cfg(test)]
 mod tests {
    use super::Du;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Du {})
+        Ok(test_examples(Du {})?)
    }
 }
--- a/crates/nu-cli/src/commands/each/command.rs
+++ b/crates/nu-cli/src/commands/each/command.rs
@ -6,8 +6,7 @@ use crate::prelude::*;
 use futures::stream::once;
 use nu_errors::ShellError;
 use nu_protocol::{
-    hir::Block, hir::Expression, hir::SpannedExpression, hir::Synthetic, Scope, Signature,
-    SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+    hir::Block, Scope, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
 };
 use nu_source::Tagged;

@ -73,36 +72,35 @@ impl WholeStreamCommand for Each {
    }
 }

-fn is_expanded_it_usage(head: &SpannedExpression) -> bool {
-    matches!(&*head, SpannedExpression {
-        expr: Expression::Synthetic(Synthetic::String(s)),
-        ..
-    } if s == "expanded-each")
-}
-
 pub async fn process_row(
    block: Arc<Block>,
    scope: Arc<Scope>,
-    head: Arc<Box<SpannedExpression>>,
    mut context: Arc<EvaluationContext>,
    input: Value,
 ) -> Result<OutputStream, ShellError> {
    let input_clone = input.clone();
-    let input_stream = if is_expanded_it_usage(&head) {
+    // When we process a row, we need to know whether the block wants to have the contents of the row as
+    // a parameter to the block (so it gets assigned to a variable that can be used inside the block) or
+    // if it wants the contents as as an input stream
+
+    let input_stream = if !block.params.is_empty() {
        InputStream::empty()
    } else {
        once(async { Ok(input_clone) }).to_input_stream()
    };
-    Ok(run_block(
-        &block,
-        Arc::make_mut(&mut context),
-        input_stream,
-        &input,
-        &scope.vars,
-        &scope.env,
+
+    let scope = if !block.params.is_empty() {
+        // FIXME: add check for more than parameter, once that's supported
+        Scope::append_var(scope, block.params[0].clone(), input)
+    } else {
+        scope
+    };
+
+    Ok(
+        run_block(&block, Arc::make_mut(&mut context), input_stream, scope)
+            .await?
+            .to_output_stream(),
    )
-    .await?
-    .to_output_stream())
 }

 pub(crate) fn make_indexed_item(index: usize, item: Value) -> Value {
@ -118,8 +116,7 @@ async fn each(
    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
    let registry = registry.clone();
-    let head = Arc::new(raw_args.call_info.args.head.clone());
-    let scope = Arc::new(raw_args.call_info.scope.clone());
+    let scope = raw_args.call_info.scope.clone();
    let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
    let (each_args, input): (EachArgs, _) = raw_args.process(&registry).await?;
    let block = Arc::new(each_args.block);
@ -130,12 +127,11 @@ async fn each(
            .then(move |input| {
                let block = block.clone();
                let scope = scope.clone();
-                let head = head.clone();
                let context = context.clone();
                let row = make_indexed_item(input.0, input.1);

                async {
-                    match process_row(block, scope, head, context, row).await {
+                    match process_row(block, scope, context, row).await {
                        Ok(s) => s,
                        Err(e) => OutputStream::one(Err(e)),
                    }
@ -148,11 +144,10 @@ async fn each(
            .then(move |input| {
                let block = block.clone();
                let scope = scope.clone();
-                let head = head.clone();
                let context = context.clone();

                async {
-                    match process_row(block, scope, head, context, input).await {
+                    match process_row(block, scope, context, input).await {
                        Ok(s) => s,
                        Err(e) => OutputStream::one(Err(e)),
                    }
@ -166,11 +161,12 @@ async fn each(
 #[cfg(test)]
 mod tests {
    use super::Each;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Each {})
+        Ok(test_examples(Each {})?)
    }
 }
--- a/crates/nu-cli/src/commands/each/group.rs
+++ b/crates/nu-cli/src/commands/each/group.rs
@ -2,10 +2,7 @@ use crate::commands::each::process_row;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{
-    hir::Block, hir::SpannedExpression, ReturnSuccess, Scope, Signature, SyntaxShape,
-    UntaggedValue, Value,
-};
+use nu_protocol::{hir::Block, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 use serde::Deserialize;

@ -52,8 +49,7 @@ impl WholeStreamCommand for EachGroup {
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
        let registry = registry.clone();
-        let head = Arc::new(raw_args.call_info.args.head.clone());
-        let scope = Arc::new(raw_args.call_info.scope.clone());
+        let scope = raw_args.call_info.scope.clone();
        let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
        let (each_args, input): (EachGroupArgs, _) = raw_args.process(&registry).await?;
        let block = Arc::new(each_args.block);
@ -61,13 +57,7 @@ impl WholeStreamCommand for EachGroup {
        Ok(input
            .chunks(each_args.group_size.item)
            .then(move |input| {
-                run_block_on_vec(
-                    input,
-                    block.clone(),
-                    scope.clone(),
-                    head.clone(),
-                    context.clone(),
-                )
+                run_block_on_vec(input, block.clone(), scope.clone(), context.clone())
            })
            .flatten()
            .to_output_stream())
@ -78,7 +68,6 @@ pub(crate) fn run_block_on_vec(
    input: Vec<Value>,
    block: Arc<Block>,
    scope: Arc<Scope>,
-    head: Arc<Box<SpannedExpression>>,
    context: Arc<EvaluationContext>,
 ) -> impl Future<Output = OutputStream> {
    let value = Value {
@ -87,7 +76,7 @@ pub(crate) fn run_block_on_vec(
    };

    async {
-        match process_row(block, scope, head, context, value).await {
+        match process_row(block, scope, context, value).await {
            Ok(s) => {
                // We need to handle this differently depending on whether process_row
                // returned just 1 value or if it returned multiple as a stream.
@ -123,11 +112,12 @@ pub(crate) fn run_block_on_vec(
 #[cfg(test)]
 mod tests {
    use super::EachGroup;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(EachGroup {})
+        Ok(test_examples(EachGroup {})?)
    }
 }
--- a/crates/nu-cli/src/commands/each/window.rs
+++ b/crates/nu-cli/src/commands/each/window.rs
@ -56,8 +56,7 @@ impl WholeStreamCommand for EachWindow {
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
        let registry = registry.clone();
-        let head = Arc::new(raw_args.call_info.args.head.clone());
-        let scope = Arc::new(raw_args.call_info.scope.clone());
+        let scope = raw_args.call_info.scope.clone();
        let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
        let (each_args, mut input): (EachWindowArgs, _) = raw_args.process(&registry).await?;
        let block = Arc::new(each_args.block);
@ -82,13 +81,12 @@ impl WholeStreamCommand for EachWindow {

                let block = block.clone();
                let scope = scope.clone();
-                let head = head.clone();
                let context = context.clone();
                let local_window = window.clone();

                async move {
                    if i % stride == 0 {
-                        Some(run_block_on_vec(local_window, block, scope, head, context).await)
+                        Some(run_block_on_vec(local_window, block, scope, context).await)
                    } else {
                        None
                    }
@ -103,11 +101,12 @@ impl WholeStreamCommand for EachWindow {
 #[cfg(test)]
 mod tests {
    use super::EachWindow;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(EachWindow {})
+        Ok(test_examples(EachWindow {})?)
    }
 }
--- a/crates/nu-cli/src/commands/echo.rs
+++ b/crates/nu-cli/src/commands/echo.rs
@ -162,11 +162,12 @@ impl Iterator for RangeIterator {
 #[cfg(test)]
 mod tests {
    use super::Echo;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Echo {})
+        Ok(test_examples(Echo {})?)
    }
 }
--- a/crates/nu-cli/src/commands/empty.rs
+++ b/crates/nu-cli/src/commands/empty.rs
@ -0,0 +1,288 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::classified::block::run_block;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::Block, ColumnPath, Primitive, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue,
+    Value,
+};
+use nu_source::Tagged;
+use nu_value_ext::{as_string, ValueExt};
+
+use futures::stream::once;
+use indexmap::indexmap;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rest: Vec<Value>,
+}
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "empty?"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("empty?").rest(
+            SyntaxShape::Any,
+            "the names of the columns to check emptiness. Pass an optional block to replace if empty",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Check for empty values"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        is_empty(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Check if a value is empty",
+                example: "echo '' | empty?",
+                result: Some(vec![UntaggedValue::boolean(true).into()]),
+            },
+            Example {
+                description: "more than one column",
+                example: "echo [[meal size]; [arepa small] [taco '']] | empty? meal size",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(false),
+                        })
+                        .into(),
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(true),
+                        })
+                        .into(),
+                    ],
+                ),
+            },Example {
+                description: "use a block if setting the empty cell contents is wanted",
+                example: "echo [[2020/04/16 2020/07/10 2020/11/16]; ['' [27] [37]]] | empty? 2020/04/16 { = [33 37] }",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "2020/04/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(33).into(), UntaggedValue::int(37).into()]).into(),
+                                "2020/07/10".to_string() => UntaggedValue::table(&[UntaggedValue::int(27).into()]).into(),
+                                "2020/11/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(37).into()]).into(),
+                        })
+                        .into(),
+                    ],
+                ),
+            },
+        ]
+    }
+}
+
+async fn is_empty(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let name_tag = Arc::new(args.call_info.name_tag.clone());
+    let context = Arc::new(EvaluationContext::from_raw(&args, &registry));
+    let scope = args.call_info.scope.clone();
+    let (Arguments { rest }, input) = args.process(&registry).await?;
+    let (columns, default_block): (Vec<ColumnPath>, Option<Block>) = arguments(rest)?;
+    let default_block = Arc::new(default_block);
+
+    if input.is_empty() {
+        let stream = futures::stream::iter(vec![
+            UntaggedValue::Primitive(Primitive::Nothing).into_value(tag)
+        ]);
+
+        return Ok(InputStream::from_stream(stream)
+            .then(move |input| {
+                let tag = name_tag.clone();
+                let scope = scope.clone();
+                let context = context.clone();
+                let block = default_block.clone();
+                let columns = vec![];
+
+                async {
+                    match process_row(scope, context, input, block, columns, tag).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream());
+    }
+
+    Ok(input
+        .then(move |input| {
+            let tag = name_tag.clone();
+            let scope = scope.clone();
+            let context = context.clone();
+            let block = default_block.clone();
+            let columns = columns.clone();
+
+            async {
+                match process_row(scope, context, input, block, columns, tag).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+fn arguments(rest: Vec<Value>) -> Result<(Vec<ColumnPath>, Option<Block>), ShellError> {
+    let mut rest = rest;
+    let mut columns = vec![];
+    let mut default = None;
+
+    let last_argument = rest.pop();
+
+    match last_argument {
+        Some(Value {
+            value: UntaggedValue::Block(call),
+            ..
+        }) => default = Some(call),
+        Some(other) => {
+            let Tagged { item: path, .. } = other.as_column_path()?;
+
+            columns = vec![path];
+        }
+        None => {}
+    };
+
+    for argument in rest {
+        let Tagged { item: path, .. } = argument.as_column_path()?;
+
+        columns.push(path);
+    }
+
+    Ok((columns, default))
+}
+
+async fn process_row(
+    scope: Arc<Scope>,
+    mut context: Arc<EvaluationContext>,
+    input: Value,
+    default_block: Arc<Option<Block>>,
+    column_paths: Vec<ColumnPath>,
+    tag: Arc<Tag>,
+) -> Result<OutputStream, ShellError> {
+    let _tag = &*tag;
+    let mut out = Arc::new(None);
+    let results = Arc::make_mut(&mut out);
+
+    if let Some(default_block) = &*default_block {
+        let for_block = input.clone();
+        let input_stream = once(async { Ok(for_block) }).to_input_stream();
+
+        let scope = Scope::append_var(scope, "$it", input.clone());
+
+        let mut stream = run_block(
+            &default_block,
+            Arc::make_mut(&mut context),
+            input_stream,
+            scope,
+        )
+        .await?;
+
+        *results = Some({
+            let values = stream.drain_vec().await;
+
+            let errors = context.get_errors();
+
+            if let Some(error) = errors.first() {
+                return Err(error.clone());
+            }
+
+            if values.len() == 1 {
+                let value = values
+                    .get(0)
+                    .ok_or_else(|| ShellError::unexpected("No value."))?;
+
+                Value {
+                    value: value.value.clone(),
+                    tag: input.tag.clone(),
+                }
+            } else if values.is_empty() {
+                UntaggedValue::nothing().into_value(&input.tag)
+            } else {
+                UntaggedValue::table(&values).into_value(&input.tag)
+            }
+        });
+    }
+
+    match input {
+        Value {
+            value: UntaggedValue::Row(ref r),
+            ref tag,
+        } => {
+            if column_paths.is_empty() {
+                Ok(OutputStream::one(ReturnSuccess::value({
+                    let is_empty = input.is_empty();
+
+                    if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            input.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    }
+                })))
+            } else {
+                let mut obj = input.clone();
+
+                for column in column_paths.clone() {
+                    let path = UntaggedValue::Primitive(Primitive::ColumnPath(column.clone()))
+                        .into_value(tag);
+                    let data = r.get_data(&as_string(&path)?).borrow().clone();
+                    let is_empty = data.is_empty();
+
+                    let default = if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            data.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    };
+
+                    if let Ok(value) =
+                        obj.swap_data_by_column_path(&column, Box::new(move |_| Ok(default)))
+                    {
+                        obj = value;
+                    }
+                }
+
+                Ok(OutputStream::one(ReturnSuccess::value(obj)))
+            }
+        }
+        other => Ok(OutputStream::one(ReturnSuccess::value({
+            if other.is_empty() {
+                results
+                    .clone()
+                    .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(other.tag))
+            } else {
+                UntaggedValue::boolean(false).into_value(other.tag)
+            }
+        }))),
+    }
+}
--- a/crates/nu-cli/src/commands/enter.rs
+++ b/crates/nu-cli/src/commands/enter.rs
@ -191,11 +191,12 @@ async fn enter(
 #[cfg(test)]
 mod tests {
    use super::Enter;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Enter {})
+        Ok(test_examples(Enter {})?)
    }
 }
--- a/crates/nu-cli/src/commands/every.rs
+++ b/crates/nu-cli/src/commands/every.rs
@ -93,11 +93,12 @@ async fn every(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputSt
 #[cfg(test)]
 mod tests {
    use super::Every;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Every {})
+        Ok(test_examples(Every {})?)
    }
 }
--- a/crates/nu-cli/src/commands/exit.rs
+++ b/crates/nu-cli/src/commands/exit.rs
@ -63,11 +63,12 @@ pub async fn exit(
 #[cfg(test)]
 mod tests {
    use super::Exit;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Exit {})
+        Ok(test_examples(Exit {})?)
    }
 }
--- a/crates/nu-cli/src/commands/first.rs
+++ b/crates/nu-cli/src/commands/first.rs
@ -72,11 +72,12 @@ async fn first(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputSt
 #[cfg(test)]
 mod tests {
    use super::First;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(First {})
+        Ok(test_examples(First {})?)
    }
 }
--- a/crates/nu-cli/src/commands/flatten.rs
+++ b/crates/nu-cli/src/commands/flatten.rs
@ -0,0 +1,192 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    Dictionary, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "flatten"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("flatten").rest(SyntaxShape::String, "optionally flatten data by column")
+    }
+
+    fn usage(&self) -> &str {
+        "Flatten the table."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        flatten(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "flatten a table",
+                example: "echo [[N, u, s, h, e, l, l]] | flatten | first",
+                result: Some(vec![Value::from("N")]),
+            },
+            Example {
+                description: "flatten a column having a nested table",
+                example: "echo [[origin, people]; [Ecuador, $(echo [[name, meal]; ['Andres', 'arepa']])]] | flatten | get meal",
+                result: Some(vec![Value::from("arepa")]),
+            },
+            Example {
+                description: "restrict the flattening by passing column names",
+                example: "echo [[origin, crate, versions]; [World, $(echo [[name]; ['nu-cli']]), ['0.21', '0.22']]] | flatten versions | last | get versions",
+                result: Some(vec![Value::from("0.22")]),
+            }
+        ]
+    }
+}
+
+async fn flatten(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let registry = registry.clone();
+    let (Arguments { rest: columns }, input) = args.process(&registry).await?;
+
+    Ok(input
+        .map(move |item| {
+            futures::stream::iter(flat_value(&columns, &item, &tag).into_iter().flatten())
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+enum TableInside<'a> {
+    Entries(&'a str, &'a Tag, Vec<&'a Value>),
+}
+
+fn flat_value(
+    columns: &[Tagged<String>],
+    item: &Value,
+    name_tag: impl Into<Tag>,
+) -> Result<Vec<Result<ReturnSuccess, ShellError>>, ShellError> {
+    let tag = item.tag.clone();
+    let name_tag = name_tag.into();
+
+    let res = {
+        if item.is_row() {
+            let mut out = TaggedDictBuilder::new(tag);
+            let mut a_table = None;
+            let mut tables_explicitly_flattened = 0;
+
+            for (column, value) in item.row_entries() {
+                let column_requested = columns.iter().find(|c| c.item == *column);
+
+                if let Value {
+                    value: UntaggedValue::Row(Dictionary { entries: mapa }),
+                    ..
+                } = value
+                {
+                    if column_requested.is_none() && !columns.is_empty() {
+                        if out.contains_key(&column) {
+                            out.insert_value(format!("{}_{}", column, column), value.clone());
+                        } else {
+                            out.insert_value(column, value.clone());
+                        }
+                        continue;
+                    }
+
+                    for (k, v) in mapa.into_iter() {
+                        if out.contains_key(k) {
+                            out.insert_value(format!("{}_{}", column, k), v.clone());
+                        } else {
+                            out.insert_value(k, v.clone());
+                        }
+                    }
+                } else if value.is_table() {
+                    if tables_explicitly_flattened >= 1 && column_requested.is_some() {
+                        let attempted = if let Some(name) = column_requested {
+                            name.span()
+                        } else {
+                            name_tag.span
+                        };
+
+                        let already_flattened =
+                            if let Some(TableInside::Entries(_, column_tag, _)) = a_table {
+                                column_tag.span
+                            } else {
+                                name_tag.span
+                            };
+
+                        return Ok(vec![ReturnSuccess::value(
+                            UntaggedValue::Error(ShellError::labeled_error_with_secondary(
+                                "can only flatten one inner table at the same time",
+                                "tried flattening more than one column with inner tables",
+                                attempted,
+                                "...but is flattened already",
+                                already_flattened,
+                            ))
+                            .into_value(name_tag),
+                        )]);
+                    }
+
+                    if !columns.is_empty() {
+                        if let Some(requested) = column_requested {
+                            a_table = Some(TableInside::Entries(
+                                &requested.item,
+                                &requested.tag,
+                                value.table_entries().collect(),
+                            ));
+
+                            tables_explicitly_flattened += 1;
+                        } else {
+                            out.insert_value(column, value.clone());
+                        }
+                    } else if a_table.is_none() {
+                        a_table = Some(TableInside::Entries(
+                            &column,
+                            &value.tag,
+                            value.table_entries().collect(),
+                        ))
+                    } else {
+                        out.insert_value(column, value.clone());
+                    }
+                } else {
+                    out.insert_value(column, value.clone());
+                }
+            }
+
+            let mut expanded = vec![];
+
+            if let Some(TableInside::Entries(column, _, entries)) = a_table {
+                for entry in entries.into_iter() {
+                    let mut base = out.clone();
+                    base.insert_value(column, entry.clone());
+                    expanded.push(base.into_value());
+                }
+            } else {
+                expanded.push(out.into_value());
+            }
+
+            expanded
+        } else if item.is_table() {
+            item.table_entries().map(Clone::clone).collect()
+        } else {
+            vec![item.clone()]
+        }
+    };
+
+    Ok(res.into_iter().map(ReturnSuccess::value).collect())
+}
--- a/crates/nu-cli/src/commands/format/command.rs
+++ b/crates/nu-cli/src/commands/format/command.rs
@ -3,7 +3,7 @@ use crate::commands::WholeStreamCommand;
 use crate::evaluate::evaluate_baseline_expr;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_protocol::{ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue};
 use nu_source::Tagged;
 use std::borrow::Borrow;

@ -54,7 +54,7 @@ async fn format_command(
    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
    let registry = Arc::new(registry.clone());
-    let scope = Arc::new(args.call_info.scope.clone());
+    let scope = args.call_info.scope.clone();
    let (FormatArgs { pattern }, input) = args.process(&registry).await?;

    let format_pattern = format(&pattern);
@ -83,9 +83,7 @@ async fn format_command(
                            let result = evaluate_baseline_expr(
                                &full_column_path.0,
                                &registry,
-                                &value,
-                                &scope.vars,
-                                &scope.env,
+                                Scope::append_var(scope.clone(), "$it", value.clone()),
                            )
                            .await;

@ -153,11 +151,12 @@ fn format(input: &str) -> Vec<FormatCommand> {
 #[cfg(test)]
 mod tests {
    use super::Format;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Format {})
+        Ok(test_examples(Format {})?)
    }
 }
--- a/crates/nu-cli/src/commands/format/format_filesize.rs
+++ b/crates/nu-cli/src/commands/format/format_filesize.rs
@ -0,0 +1,194 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+
+use crate::commands::WholeStreamCommand;
+use nu_protocol::{
+    ColumnPath, Primitive::Filesize, ReturnSuccess, Signature, SyntaxShape, UntaggedValue,
+    UntaggedValue::Primitive, Value,
+};
+use nu_source::Tagged;
+use nu_value_ext::get_data_by_column_path;
+
+use num_format::{Locale, ToFormattedString};
+
+pub struct FileSize;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    field: ColumnPath,
+    format: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FileSize {
+    fn name(&self) -> &str {
+        "format filesize"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("format filesize")
+            .required(
+                "field",
+                SyntaxShape::ColumnPath,
+                "the name of the column to update",
+            )
+            .required(
+                "format value",
+                SyntaxShape::String,
+                "the format into which convert the filesizes",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Converts a column of filesizes to some specified format"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        filesize(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert the size row to KB",
+                example: "ls | format filesize size KB",
+                result: None,
+            },
+            Example {
+                description: "Convert the apparent row to B",
+                example: "du | format filesize apparent B",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn process_row(
+    input: Value,
+    format: Tagged<String>,
+    field: Arc<ColumnPath>,
+) -> Result<OutputStream, ShellError> {
+    Ok({
+        let replace_for = get_data_by_column_path(&input, &field, move |_, _, error| error);
+        match replace_for {
+            Ok(s) => match convert_bytes_to_string_using_format(s, format) {
+                Ok(b) => OutputStream::one(ReturnSuccess::value(
+                    input.replace_data_at_column_path(&field, b).expect("Given that the existance check was already done, this souldn't trigger never"),
+                )),
+                Err(e) => OutputStream::one(Err(e)),
+            },
+            Err(e) => OutputStream::one(Err(e)),
+        }
+    })
+}
+
+async fn filesize(
+    raw_args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let (Arguments { field, format }, input) = raw_args.process(&registry).await?;
+    let field = Arc::new(field);
+
+    Ok(input
+        .then(move |input| {
+            let format = format.clone();
+            let field = field.clone();
+
+            async {
+                match process_row(input, format, field).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+fn convert_bytes_to_string_using_format(
+    bytes: Value,
+    format: Tagged<String>,
+) -> Result<Value, ShellError> {
+    match bytes.value {
+        Primitive(Filesize(b)) => {
+            let byte = byte_unit::Byte::from_bytes(b as u128);
+            let value = match format.item().to_lowercase().as_str() {
+                "b" => Ok(UntaggedValue::string(b.to_formatted_string(&Locale::en))),
+                "kb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::KB).to_string(),
+                )),
+                "kib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::KiB).to_string(),
+                )),
+                "mb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::MB).to_string(),
+                )),
+                "mib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::MiB).to_string(),
+                )),
+                "gb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::GB).to_string(),
+                )),
+                "gib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::GiB).to_string(),
+                )),
+                "tb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::TB).to_string(),
+                )),
+                "tib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::TiB).to_string(),
+                )),
+                "pb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::PB).to_string(),
+                )),
+                "pib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::PiB).to_string(),
+                )),
+                "eb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::EB).to_string(),
+                )),
+                "eib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::EiB).to_string(),
+                )),
+                "zb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::ZB).to_string(),
+                )),
+                "zib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::ZiB).to_string(),
+                )),
+                _ => Err(ShellError::labeled_error(
+                    format!("Invalid format code: {:}", format.item()),
+                    "invalid format",
+                    format.tag(),
+                )),
+            };
+            match value {
+                Ok(b) => Ok(Value { value: b, ..bytes }),
+                Err(e) => Err(e),
+            }
+        }
+        _ => Err(ShellError::labeled_error(
+            "the data in this row is not of the type filesize",
+            "invalid row type",
+            bytes.tag(),
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FileSize;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FileSize {})?)
+    }
+}
--- a/crates/nu-cli/src/commands/format/mod.rs
+++ b/crates/nu-cli/src/commands/format/mod.rs
@ -0,0 +1,5 @@
+pub mod command;
+pub mod format_filesize;
+
+pub use command::Format;
+pub use format_filesize::FileSize;
--- a/crates/nu-cli/src/commands/from.rs
+++ b/crates/nu-cli/src/commands/from.rs
@ -35,11 +35,12 @@ impl WholeStreamCommand for From {
 #[cfg(test)]
 mod tests {
    use super::From;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(From {})
+        Ok(test_examples(From {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_csv.rs
+++ b/crates/nu-cli/src/commands/from_csv.rs
@ -109,11 +109,12 @@ async fn from_csv(
 #[cfg(test)]
 mod tests {
    use super::FromCSV;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromCSV {})
+        Ok(test_examples(FromCSV {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_delimited_data.rs
+++ b/crates/nu-cli/src/commands/from_delimited_data.rs
@ -54,6 +54,7 @@ pub async fn from_delimited_data(
 ) -> Result<OutputStream, ShellError> {
    let name_tag = name;
    let concat_string = input.collect_string(name_tag.clone()).await?;
+    let sample_lines = concat_string.item.lines().take(3).collect_vec().join("\n");

    match from_delimited_string_to_value(concat_string.item, headerless, sep, name_tag.clone()) {
        Ok(x) => match x {
@ -65,10 +66,16 @@ pub async fn from_delimited_data(
        },
        Err(err) => {
            let line_one = match pretty_csv_error(err) {
-                Some(pretty) => format!("Could not parse as {} ({})", format_name, pretty),
-                None => format!("Could not parse as {}", format_name),
+                Some(pretty) => format!(
+                    "Could not parse as {} split by '{}' ({})",
+                    format_name, sep, pretty
+                ),
+                None => format!("Could not parse as {} split by '{}'", format_name, sep),
            };
-            let line_two = format!("input cannot be parsed as {}", format_name);
+            let line_two = format!(
+                "input cannot be parsed as {} split by '{}'. Input's first lines:\n{}",
+                format_name, sep, sample_lines
+            );

            Err(ShellError::labeled_error_with_secondary(
                line_one,
--- a/crates/nu-cli/src/commands/from_eml.rs
+++ b/crates/nu-cli/src/commands/from_eml.rs
@ -130,11 +130,12 @@ async fn from_eml(
 #[cfg(test)]
 mod tests {
    use super::FromEML;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromEML {})
+        Ok(test_examples(FromEML {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_ics.rs
+++ b/crates/nu-cli/src/commands/from_ics.rs
@ -249,11 +249,12 @@ fn params_to_value(params: Vec<(String, Vec<String>)>, tag: Tag) -> Value {
 #[cfg(test)]
 mod tests {
    use super::FromIcs;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromIcs {})
+        Ok(test_examples(FromIcs {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_ini.rs
+++ b/crates/nu-cli/src/commands/from_ini.rs
@ -95,11 +95,12 @@ async fn from_ini(
 #[cfg(test)]
 mod tests {
    use super::FromINI;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromINI {})
+        Ok(test_examples(FromINI {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_json.rs
+++ b/crates/nu-cli/src/commands/from_json.rs
@ -37,26 +37,26 @@ impl WholeStreamCommand for FromJSON {
    }
 }

-fn convert_json_value_to_nu_value(v: &serde_hjson::Value, tag: impl Into<Tag>) -> Value {
+fn convert_json_value_to_nu_value(v: &nu_json::Value, tag: impl Into<Tag>) -> Value {
    let tag = tag.into();
    let span = tag.span;

    match v {
-        serde_hjson::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(&tag),
-        serde_hjson::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(&tag),
-        serde_hjson::Value::F64(n) => UntaggedValue::decimal_from_float(*n, span).into_value(&tag),
-        serde_hjson::Value::U64(n) => UntaggedValue::int(*n).into_value(&tag),
-        serde_hjson::Value::I64(n) => UntaggedValue::int(*n).into_value(&tag),
-        serde_hjson::Value::String(s) => {
+        nu_json::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(&tag),
+        nu_json::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(&tag),
+        nu_json::Value::F64(n) => UntaggedValue::decimal_from_float(*n, span).into_value(&tag),
+        nu_json::Value::U64(n) => UntaggedValue::int(*n).into_value(&tag),
+        nu_json::Value::I64(n) => UntaggedValue::int(*n).into_value(&tag),
+        nu_json::Value::String(s) => {
            UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(&tag)
        }
-        serde_hjson::Value::Array(a) => UntaggedValue::Table(
+        nu_json::Value::Array(a) => UntaggedValue::Table(
            a.iter()
                .map(|x| convert_json_value_to_nu_value(x, &tag))
                .collect(),
        )
        .into_value(tag),
-        serde_hjson::Value::Object(o) => {
+        nu_json::Value::Object(o) => {
            let mut collected = TaggedDictBuilder::new(&tag);
            for (k, v) in o.iter() {
                collected.insert_value(k.clone(), convert_json_value_to_nu_value(v, &tag));
@ -67,8 +67,8 @@ fn convert_json_value_to_nu_value(v: &serde_hjson::Value, tag: impl Into<Tag>) -
    }
 }

-pub fn from_json_string_to_value(s: String, tag: impl Into<Tag>) -> serde_hjson::Result<Value> {
-    let v: serde_hjson::Value = serde_hjson::from_str(&s)?;
+pub fn from_json_string_to_value(s: String, tag: impl Into<Tag>) -> nu_json::Result<Value> {
+    let v: nu_json::Value = nu_json::from_str(&s)?;
    Ok(convert_json_value_to_nu_value(&v, tag))
 }

@ -96,7 +96,7 @@ async fn from_json(
                    Err(e) => {
                        let mut message = "Could not parse as JSON (".to_string();
                        message.push_str(&e.to_string());
-                        message.push_str(")");
+                        message.push(')');

                        Some(Err(ShellError::labeled_error_with_secondary(
                            message,
@ -125,7 +125,7 @@ async fn from_json(
            Err(e) => {
                let mut message = "Could not parse as JSON (".to_string();
                message.push_str(&e.to_string());
-                message.push_str(")");
+                message.push(')');

                Ok(OutputStream::one(Err(
                    ShellError::labeled_error_with_secondary(
@ -144,11 +144,12 @@ async fn from_json(
 #[cfg(test)]
 mod tests {
    use super::FromJSON;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromJSON {})
+        Ok(test_examples(FromJSON {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_ods.rs
+++ b/crates/nu-cli/src/commands/from_ods.rs
@ -102,11 +102,12 @@ async fn from_ods(
 #[cfg(test)]
 mod tests {
    use super::FromODS;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromODS {})
+        Ok(test_examples(FromODS {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_ssv.rs
+++ b/crates/nu-cli/src/commands/from_ssv.rs
@ -135,7 +135,7 @@ fn parse_aligned_columns<'a>(
            .flat_map(|s| find_indices(*s))
            .collect::<Vec<usize>>();

-        indices.sort();
+        indices.sort_unstable();
        indices.dedup();

        let headers: Vec<(String, usize)> = indices
@ -302,7 +302,9 @@ async fn from_ssv(

 #[cfg(test)]
 mod tests {
+    use super::ShellError;
    use super::*;
+
    fn owned(x: &str, y: &str) -> (String, String) {
        (String::from(x), String::from(y))
    }
@ -504,10 +506,10 @@ mod tests {
    }

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use super::FromSSV;
        use crate::examples::test as test_examples;

-        test_examples(FromSSV {})
+        Ok(test_examples(FromSSV {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_toml.rs
+++ b/crates/nu-cli/src/commands/from_toml.rs
@ -101,11 +101,12 @@ pub async fn from_toml(
 #[cfg(test)]
 mod tests {
    use super::FromTOML;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromTOML {})
+        Ok(test_examples(FromTOML {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_tsv.rs
+++ b/crates/nu-cli/src/commands/from_tsv.rs
@ -52,11 +52,12 @@ async fn from_tsv(
 #[cfg(test)]
 mod tests {
    use super::FromTSV;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromTSV {})
+        Ok(test_examples(FromTSV {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_url.rs
+++ b/crates/nu-cli/src/commands/from_url.rs
@ -64,11 +64,12 @@ async fn from_url(
 #[cfg(test)]
 mod tests {
    use super::FromURL;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromURL {})
+        Ok(test_examples(FromURL {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_vcf.rs
+++ b/crates/nu-cli/src/commands/from_vcf.rs
@ -104,11 +104,12 @@ fn params_to_value(params: Vec<(String, Vec<String>)>, tag: Tag) -> Value {
 #[cfg(test)]
 mod tests {
    use super::FromVcf;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromVcf {})
+        Ok(test_examples(FromVcf {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_xlsx.rs
+++ b/crates/nu-cli/src/commands/from_xlsx.rs
@ -102,11 +102,12 @@ async fn from_xlsx(
 #[cfg(test)]
 mod tests {
    use super::FromXLSX;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromXLSX {})
+        Ok(test_examples(FromXLSX {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_xml.rs
+++ b/crates/nu-cli/src/commands/from_xml.rs
@ -135,6 +135,7 @@ async fn from_xml(

 #[cfg(test)]
 mod tests {
+    use super::ShellError;
    use crate::commands::from_xml;
    use indexmap::IndexMap;
    use nu_protocol::{UntaggedValue, Value};
@ -304,10 +305,10 @@ mod tests {
    }

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use super::FromXML;
        use crate::examples::test as test_examples;

-        test_examples(FromXML {})
+        Ok(test_examples(FromXML {})?)
    }
 }
--- a/crates/nu-cli/src/commands/from_yaml.rs
+++ b/crates/nu-cli/src/commands/from_yaml.rs
@ -68,13 +68,12 @@ fn convert_yaml_value_to_nu_value(
    Ok(match v {
        serde_yaml::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(tag),
        serde_yaml::Value::Number(n) if n.is_i64() => {
-            UntaggedValue::int(n.as_i64().ok_or_else(|| err_not_compatible_number)?).into_value(tag)
+            UntaggedValue::int(n.as_i64().ok_or(err_not_compatible_number)?).into_value(tag)
+        }
+        serde_yaml::Value::Number(n) if n.is_f64() => {
+            UntaggedValue::decimal_from_float(n.as_f64().ok_or(err_not_compatible_number)?, span)
+                .into_value(tag)
        }
-        serde_yaml::Value::Number(n) if n.is_f64() => UntaggedValue::decimal_from_float(
-            n.as_f64().ok_or_else(|| err_not_compatible_number)?,
-            span,
-        )
-        .into_value(tag),
        serde_yaml::Value::String(s) => UntaggedValue::string(s).into_value(tag),
        serde_yaml::Value::Sequence(a) => {
            let result: Result<Vec<Value>, ShellError> = a
@ -173,15 +172,16 @@ async fn from_yaml(

 #[cfg(test)]
 mod tests {
+    use super::ShellError;
    use super::*;
-    use nu_plugin::row;
-    use nu_plugin::test_helpers::value::string;
+    use nu_protocol::row;
+    use nu_test_support::value::string;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(FromYAML {})
+        Ok(test_examples(FromYAML {})?)
    }

    #[test]
--- a/crates/nu-cli/src/commands/get.rs
+++ b/crates/nu-cli/src/commands/get.rs
@ -129,10 +129,10 @@ pub fn get_column_path(path: &ColumnPath, obj: &Value) -> Result<Value, ShellErr
            _ => {}
        }

-        if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried) {
+        if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried.as_string()) {
            ShellError::labeled_error(
                "Unknown column",
-                format!("did you mean '{}'?", suggestions[0].1),
+                format!("did you mean '{}'?", suggestions[0]),
                column_path_tried.span.since(path_members_span),
            )
        } else {
@ -155,8 +155,8 @@ pub fn get_column_path_from_table_error(

            let suggestions: IndexSet<_> = rows
                .iter()
-                .filter_map(|r| did_you_mean(&r, &column_path_tried))
-                .map(|s| s[0].1.to_owned())
+                .filter_map(|r| did_you_mean(&r, column_path_tried.as_string()))
+                .map(|s| s[0].to_owned())
                .collect();
            let mut existing_columns: IndexSet<_> = IndexSet::default();
            let mut names: Vec<String> = vec![];
@ -232,14 +232,14 @@ pub fn get_column_from_row_error(
        } => {
            let primary_label = format!("There isn't a column named '{}'", &column);

-            if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried) {
+            if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried.as_string()) {
                Some(ShellError::labeled_error_with_secondary(
                    "Unknown column",
                    primary_label,
                    column_path_tried.span,
                    format!(
                        "Perhaps you meant '{}'? Columns available: {}",
-                        suggestions[0].1,
+                        suggestions[0],
                        &obj_source.data_descriptors().join(", ")
                    ),
                    column_path_tried.span.since(path_members_span),
@ -267,11 +267,12 @@ pub fn get_column_from_row_error(
 #[cfg(test)]
 mod tests {
    use super::Get;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Get {})
+        Ok(test_examples(Get {})?)
    }
 }
--- a/crates/nu-cli/src/commands/group_by.rs
+++ b/crates/nu-cli/src/commands/group_by.rs
@ -1,20 +1,21 @@
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
+use crate::utils::suggestions::suggestions;
 use indexmap::indexmap;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 use nu_value_ext::as_string;

-pub struct GroupBy;
+pub struct Command;

 #[derive(Deserialize)]
-pub struct GroupByArgs {
+pub struct Arguments {
    grouper: Option<Value>,
 }

 #[async_trait]
-impl WholeStreamCommand for GroupBy {
+impl WholeStreamCommand for Command {
    fn name(&self) -> &str {
        "group-by"
    }
@ -39,17 +40,45 @@ impl WholeStreamCommand for GroupBy {
        group_by(args, registry).await
    }

+    #[allow(clippy::unwrap_used)]
    fn examples(&self) -> Vec<Example> {
+        use nu_data::value::date_naive_from_str as date;
+
        vec![
            Example {
                description: "group items by column named \"type\"",
                example: r#"ls | group-by type"#,
-                result: None,
-            },
-            Example {
-                description: "blocks can be used for generating a grouping key (same as above)",
-                example: r#"ls | group-by { get type }"#,
-                result: None,
+                result: Some(vec![UntaggedValue::row(indexmap! {
+                    "File".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>          UntaggedValue::string("Andrés.txt").into(),
+                                "type".to_string() =>                UntaggedValue::string("File").into(),
+                            "chickens".to_string() =>                       UntaggedValue::int(10).into(),
+                            "modified".to_string() => date("2019-07-23".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>          UntaggedValue::string("Andrés.txt").into(),
+                                "type".to_string() =>                UntaggedValue::string("File").into(),
+                            "chickens".to_string() =>                       UntaggedValue::int(20).into(),
+                            "modified".to_string() => date("2019-09-24".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                    ]).into(),
+                    "Dir".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>            UntaggedValue::string("Jonathan").into(),
+                                "type".to_string() =>                 UntaggedValue::string("Dir").into(),
+                            "chickens".to_string() =>                        UntaggedValue::int(5).into(),
+                            "modified".to_string() => date("2019-07-23".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>              UntaggedValue::string("Yehuda").into(),
+                                "type".to_string() =>                 UntaggedValue::string("Dir").into(),
+                            "chickens".to_string() =>                        UntaggedValue::int(4).into(),
+                            "modified".to_string() => date("2019-09-24".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                    ]).into(),
+                })
+                .into()]),
            },
            Example {
                description: "you can also group by raw values by leaving out the argument",
@ -74,10 +103,26 @@ impl WholeStreamCommand for GroupBy {
                .into()]),
            },
            Example {
-                description: "write pipelines for a more involved grouping key",
-                example:
-                    "echo [1 3 1 3 2 1 1] | group-by { echo `({{$it}} - 1) % 3` | calc | str from }",
-                result: None,
+                description:
+                    "use the block form to generate a grouping key when each row gets processed",
+                example: "echo [1 3 1 3 2 1 1] | group-by { = ($it - 1) mod 3 }",
+                result: Some(vec![UntaggedValue::row(indexmap! {
+                    "0".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+
+                    ]).into(),
+                    "2".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(3).into(),
+                        UntaggedValue::int(3).into(),
+                    ]).into(),
+                    "1".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(2).into(),
+                    ]).into(),
+                })
+                .into()]),
            },
        ]
    }
@ -94,10 +139,9 @@ pub async fn group_by(
 ) -> Result<OutputStream, ShellError> {
    let name = args.call_info.name_tag.clone();
    let registry = registry.clone();
-    let head = Arc::new(args.call_info.args.head.clone());
-    let scope = Arc::new(args.call_info.scope.clone());
+    let scope = args.call_info.scope.clone();
    let context = Arc::new(EvaluationContext::from_raw(&args, &registry));
-    let (GroupByArgs { grouper }, input) = args.process(&registry).await?;
+    let (Arguments { grouper }, input) = args.process(&registry).await?;

    let values: Vec<Value> = input.collect().await;
    let mut keys: Vec<Result<String, ShellError>> = vec![];
@ -114,12 +158,9 @@ pub async fn group_by(
            for value in values.iter() {
                let run = block.clone();
                let scope = scope.clone();
-                let head = head.clone();
                let context = context.clone();

-                match crate::commands::each::process_row(run, scope, head, context, value.clone())
-                    .await
-                {
+                match crate::commands::each::process_row(run, scope, context, value.clone()).await {
                    Ok(mut s) => {
                        let collection: Vec<Result<ReturnSuccess, ShellError>> =
                            s.drain_vec().await;
@ -167,6 +208,14 @@ pub async fn group_by(
        ));
    }

+    let first = values[0].clone();
+
+    let name = if first.tag.anchor().is_some() {
+        first.tag
+    } else {
+        name
+    };
+
    let values = UntaggedValue::table(&values).into_value(&name);

    let group_value = match group_strategy {
@ -179,39 +228,14 @@ pub async fn group_by(
                None => as_string(row),
            });

-            nu_data::utils::group(&values, &Some(block), &name)
+            nu_data::utils::group(&values, &Some(block), name)
        }
-        Grouper::ByColumn(column_name) => group(&column_name, &values, name),
+        Grouper::ByColumn(column_name) => group(&column_name, &values, &name),
    };

    Ok(OutputStream::one(ReturnSuccess::value(group_value?)))
 }

-pub fn suggestions(tried: Tagged<&str>, for_value: &Value) -> ShellError {
-    let possibilities = for_value.data_descriptors();
-
-    let mut possible_matches: Vec<_> = possibilities
-        .iter()
-        .map(|x| (natural::distance::levenshtein_distance(x, &tried), x))
-        .collect();
-
-    possible_matches.sort();
-
-    if !possible_matches.is_empty() {
-        ShellError::labeled_error(
-            "Unknown column",
-            format!("did you mean '{}'?", possible_matches[0].1),
-            tried.tag(),
-        )
-    } else {
-        ShellError::labeled_error(
-            "Unknown column",
-            "row does not contain this column",
-            tried.tag(),
-        )
-    }
-}
-
 pub fn group(
    column_name: &Option<Tagged<String>>,
    values: &Value,
@ -250,9 +274,10 @@ pub fn group(
 #[cfg(test)]
 mod tests {
    use super::group;
-    use nu_data::utils::helpers::{committers, date, int, row, string, table};
+    use nu_data::utils::helpers::committers;
    use nu_errors::ShellError;
    use nu_source::*;
+    use nu_test_support::value::{date, int, row, string, table};

    #[test]
    fn groups_table_by_date_column() -> Result<(), ShellError> {
@ -311,12 +336,4 @@ mod tests {

        Ok(())
    }
-
-    #[test]
-    fn examples_work_as_expected() {
-        use super::GroupBy;
-        use crate::examples::test as test_examples;
-
-        test_examples(GroupBy {})
-    }
 }
--- a/crates/nu-cli/src/commands/group_by_date.rs
+++ b/crates/nu-cli/src/commands/group_by_date.rs
@ -1,5 +1,6 @@
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
+use crate::utils::suggestions::suggestions;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
@ -137,39 +138,15 @@ pub async fn group_by_date(
    }
 }

-pub fn suggestions(tried: Tagged<&str>, for_value: &Value) -> ShellError {
-    let possibilities = for_value.data_descriptors();
-
-    let mut possible_matches: Vec<_> = possibilities
-        .iter()
-        .map(|x| (natural::distance::levenshtein_distance(x, &tried), x))
-        .collect();
-
-    possible_matches.sort();
-
-    if !possible_matches.is_empty() {
-        ShellError::labeled_error(
-            "Unknown column",
-            format!("did you mean '{}'?", possible_matches[0].1),
-            tried.tag(),
-        )
-    } else {
-        ShellError::labeled_error(
-            "Unknown column",
-            "row does not contain this column",
-            tried.tag(),
-        )
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::GroupByDate;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(GroupByDate {})
+        Ok(test_examples(GroupByDate {})?)
    }
 }
--- a/crates/nu-cli/src/commands/hash_/base64_.rs
+++ b/crates/nu-cli/src/commands/hash_/base64_.rs
@ -0,0 +1,314 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::ShellTypeName;
+use nu_protocol::{
+    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::{Tag, Tagged};
+
+use base64::{decode_config, encode_config};
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    pub rest: Vec<ColumnPath>,
+    pub character_set: Option<Tagged<String>>,
+    pub encode: Tagged<bool>,
+    pub decode: Tagged<bool>,
+}
+
+#[derive(Clone)]
+pub struct Base64Config {
+    pub character_set: String,
+    pub action_type: ActionType,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum ActionType {
+    Encode,
+    Decode,
+}
+pub struct SubCommand;
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "hash base64"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("hash base64")
+            .named(
+                "character_set",
+                SyntaxShape::String,
+                "specify the character rules for encoding the input.\n\
+                        \tValid values are 'standard', 'standard-no-padding', 'url-safe', 'url-safe-no-padding',\
+                        'binhex', 'bcrypt', 'crypt'",
+                Some('c'),
+            )
+            .switch(
+                "encode", 
+                "encode the input as base64. This is the default behavior if not specified.", 
+                Some('e')
+            )
+            .switch(
+                "decode", 
+                "decode the input from base64", 
+                Some('d'))
+            .rest(
+                SyntaxShape::ColumnPath,
+                "optionally base64 encode / decode data by column paths",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "base64 encode or decode a value"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        operate(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Base64 encode a string with default settings",
+                example: "echo 'username:password' | hash base64",
+                result: Some(vec![
+                    UntaggedValue::string("dXNlcm5hbWU6cGFzc3dvcmQ=").into_untagged_value()
+                ]),
+            },
+            Example {
+                description: "Base64 encode a string with the binhex character set",
+                example: "echo 'username:password' | hash base64 --character_set binhex --encode",
+                result: Some(vec![
+                    UntaggedValue::string("F@0NEPjJD97kE'&bEhFZEP3").into_untagged_value()
+                ]),
+            },
+            Example {
+                description: "Base64 decode a value",
+                example: "echo 'dXNlcm5hbWU6cGFzc3dvcmQ=' | hash base64 --decode",
+                result: Some(vec![
+                    UntaggedValue::string("username:password").into_untagged_value()
+                ]),
+            },
+        ]
+    }
+}
+
+async fn operate(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+
+    let name_tag = &args.call_info.name_tag.clone();
+
+    let (
+        Arguments {
+            encode,
+            decode,
+            character_set,
+            rest,
+        },
+        input,
+    ) = args.process(&registry).await?;
+
+    if encode.item && decode.item {
+        return Ok(OutputStream::one(Err(ShellError::labeled_error(
+            "only one of --decode and --encode flags can be used",
+            "conflicting flags",
+            name_tag,
+        ))));
+    }
+
+    // Default the action to be encoding if no flags are specified.
+    let action_type = if *decode.item() {
+        ActionType::Decode
+    } else {
+        ActionType::Encode
+    };
+
+    // Default the character set to standard if the argument is not specified.
+    let character_set = match character_set {
+        Some(inner_tag) => inner_tag.item().to_string(),
+        None => "standard".to_string(),
+    };
+
+    let encoding_config = Base64Config {
+        character_set,
+        action_type,
+    };
+
+    let column_paths: Vec<_> = rest;
+
+    Ok(input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                ReturnSuccess::value(action(&v, &encoding_config, v.tag())?)
+            } else {
+                let mut ret = v;
+
+                for path in &column_paths {
+                    let config = encoding_config.clone();
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, &config, old.tag())),
+                    )?;
+                }
+
+                ReturnSuccess::value(ret)
+            }
+        })
+        .to_output_stream())
+}
+
+fn action(
+    input: &Value,
+    base64_config: &Base64Config,
+    tag: impl Into<Tag>,
+) -> Result<Value, ShellError> {
+    match &input.value {
+        UntaggedValue::Primitive(Primitive::Line(s))
+        | UntaggedValue::Primitive(Primitive::String(s)) => {
+            let base64_config_enum: base64::Config = if &base64_config.character_set == "standard" {
+                base64::STANDARD
+            } else if &base64_config.character_set == "standard-no-padding" {
+                base64::STANDARD_NO_PAD
+            } else if &base64_config.character_set == "url-safe" {
+                base64::URL_SAFE
+            } else if &base64_config.character_set == "url-safe-no-padding" {
+                base64::URL_SAFE_NO_PAD
+            } else if &base64_config.character_set == "binhex" {
+                base64::BINHEX
+            } else if &base64_config.character_set == "bcrypt" {
+                base64::BCRYPT
+            } else if &base64_config.character_set == "crypt" {
+                base64::CRYPT
+            } else {
+                return Err(ShellError::labeled_error(
+                    "value is not an accepted character set",
+                    format!(
+                        "{} is not a valid character-set.\nPlease use `help hash base64` to see a list of valid character sets.", 
+                        &base64_config.character_set
+                    ),
+                    tag.into().span,
+                ));
+            };
+
+            match base64_config.action_type {
+                ActionType::Encode => Ok(UntaggedValue::string(encode_config(
+                    &s,
+                    base64_config_enum,
+                ))
+                .into_value(tag)),
+                ActionType::Decode => {
+                    let decode_result = decode_config(&s, base64_config_enum);
+
+                    match decode_result {
+                        Ok(decoded_value) => Ok(UntaggedValue::string(
+                            std::string::String::from_utf8_lossy(&decoded_value),
+                        )
+                        .into_value(tag)),
+                        Err(_) => Err(ShellError::labeled_error(
+                            "value could not be base64 decoded",
+                            format!(
+                                "invalid base64 input for character set {}",
+                                &base64_config.character_set
+                            ),
+                            tag.into().span,
+                        )),
+                    }
+                }
+            }
+        }
+        other => {
+            let got = format!("got {}", other.type_name());
+            Err(ShellError::labeled_error(
+                "value is not string",
+                got,
+                tag.into().span,
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{action, ActionType, Base64Config};
+    use nu_protocol::UntaggedValue;
+    use nu_source::Tag;
+    use nu_test_support::value::string;
+
+    #[test]
+    fn base64_encode_standard() {
+        let word = string("username:password");
+        let expected = UntaggedValue::string("dXNlcm5hbWU6cGFzc3dvcmQ=").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "standard".to_string(),
+                action_type: ActionType::Encode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn base64_encode_standard_no_padding() {
+        let word = string("username:password");
+        let expected = UntaggedValue::string("dXNlcm5hbWU6cGFzc3dvcmQ").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "standard-no-padding".to_string(),
+                action_type: ActionType::Encode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn base64_encode_url_safe() {
+        let word = string("this is for url");
+        let expected = UntaggedValue::string("dGhpcyBpcyBmb3IgdXJs").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "url-safe".to_string(),
+                action_type: ActionType::Encode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn base64_decode_binhex() {
+        let word = string("A5\"KC9jRB@IIF'8bF!");
+        let expected = UntaggedValue::string("a binhex test").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "binhex".to_string(),
+                action_type: ActionType::Decode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+}
--- a/crates/nu-cli/src/commands/hash_/command.rs
+++ b/crates/nu-cli/src/commands/hash_/command.rs
@ -0,0 +1,50 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "hash"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("hash").rest(
+            SyntaxShape::ColumnPath,
+            "optionally convert by column paths",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Apply hash function."
+    }
+
+    async fn run(
+        &self,
+        _args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let registry = registry.clone();
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(crate::commands::help::get_help(&Command, &registry))
+                .into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}
--- a/crates/nu-cli/src/commands/hash_/mod.rs
+++ b/crates/nu-cli/src/commands/hash_/mod.rs
@ -0,0 +1,5 @@
+mod base64_;
+mod command;
+
+pub use base64_::SubCommand as HashBase64;
+pub use command::Command as Hash;
--- a/crates/nu-cli/src/commands/headers.rs
+++ b/crates/nu-cli/src/commands/headers.rs
@ -116,11 +116,12 @@ pub async fn headers(
 #[cfg(test)]
 mod tests {
    use super::Headers;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Headers {})
+        Ok(test_examples(Headers {})?)
    }
 }
--- a/crates/nu-cli/src/commands/help.rs
+++ b/crates/nu-cli/src/commands/help.rs
@ -6,7 +6,7 @@ use nu_data::command::signature_dict;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value};
 use nu_source::{SpannedItem, Tagged};
-use nu_value_ext::get_data_by_key;
+use nu_value_ext::ValueExt;

 pub struct Help;

@ -96,7 +96,8 @@ async fn help(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStr
                dict.insert_untagged("name", cmd_name);
                dict.insert_untagged(
                    "description",
-                    get_data_by_key(&value, "usage".spanned_unknown())
+                    value
+                        .get_data_by_key("usage".spanned_unknown())
                        .ok_or_else(|| {
                            ShellError::labeled_error(
                                "Expected a usage key",
@ -234,11 +235,12 @@ pub fn get_help(cmd: &dyn WholeStreamCommand, registry: &CommandRegistry) -> Str
 #[cfg(test)]
 mod tests {
    use super::Help;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Help {})
+        Ok(test_examples(Help {})?)
    }
 }
--- a/crates/nu-cli/src/commands/histogram.rs
+++ b/crates/nu-cli/src/commands/histogram.rs
@ -112,8 +112,9 @@ pub async fn histogram(
        nu_data::utils::Operation {
            grouper: Some(Box::new(move |_, _| Ok(String::from("frequencies")))),
            splitter: Some(splitter(column_grouper)),
-            format: None,
+            format: &None,
            eval: &evaluate_with,
+            reduction: &nu_data::utils::Reduction::Count,
        },
        &name,
    )?;
@ -123,17 +124,33 @@ pub async fn histogram(

    Ok(futures::stream::iter(
        results
-            .percentages
+            .data
            .table_entries()
-            .map(move |value| {
-                let values = value.table_entries().cloned().collect::<Vec<_>>();
-                let occurrences = values.len();
-
-                (occurrences, values[occurrences - 1].clone())
-            })
+            .cloned()
            .collect::<Vec<_>>()
            .into_iter()
-            .map(move |(occurrences, value)| {
+            .zip(
+                results
+                    .percentages
+                    .table_entries()
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .into_iter(),
+            )
+            .map(move |(counts, percentages)| {
+                let percentage = percentages
+                    .table_entries()
+                    .cloned()
+                    .last()
+                    .unwrap_or_else(|| {
+                        UntaggedValue::decimal_from_float(0.0, name.span).into_value(&name)
+                    });
+                let value = counts
+                    .table_entries()
+                    .cloned()
+                    .last()
+                    .unwrap_or_else(|| UntaggedValue::int(0).into_value(&name));
+
                let mut fact = TaggedDictBuilder::new(&name);
                let column_value = labels
                    .get(idx)
@ -147,19 +164,19 @@ pub async fn histogram(
                    .clone();

                fact.insert_value(&column.item, column_value);
-                fact.insert_untagged("occurrences", UntaggedValue::int(occurrences));
+                fact.insert_untagged("count", value);

-                let percentage = format!(
+                let fmt_percentage = format!(
                    "{}%",
                    // Some(2) < the number of digits
                    // true < group the digits
-                    crate::commands::str_::from::action(&value, &name, Some(2), true)?
+                    crate::commands::str_::from::action(&percentage, &name, Some(2), true)?
                        .as_string()?
                );
-                fact.insert_untagged("percentage", UntaggedValue::string(percentage));
+                fact.insert_untagged("percentage", UntaggedValue::string(fmt_percentage));

                let string = std::iter::repeat("*")
-                    .take(value.as_u64().map_err(|_| {
+                    .take(percentage.as_u64().map_err(|_| {
                        ShellError::labeled_error("expected a number", "expected a number", &name)
                    })? as usize)
                    .collect::<String>();
@ -210,11 +227,12 @@ fn splitter(
 #[cfg(test)]
 mod tests {
    use super::Histogram;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Histogram {})
+        Ok(test_examples(Histogram {})?)
    }
 }
--- a/crates/nu-cli/src/commands/history.rs
+++ b/crates/nu-cli/src/commands/history.rs
@ -27,6 +27,11 @@ pub fn history_path(config: &dyn Conf) -> PathBuf {
        })
 }

+#[derive(Deserialize)]
+struct Arguments {
+    clear: Option<bool>,
+}
+
 pub struct History;

 #[async_trait]
@ -36,7 +41,7 @@ impl WholeStreamCommand for History {
    }

    fn signature(&self) -> Signature {
-        Signature::build("history")
+        Signature::build("history").switch("clear", "Clears out the history entries", Some('c'))
    }

    fn usage(&self) -> &str {
@ -48,42 +53,57 @@ impl WholeStreamCommand for History {
        args: CommandArgs,
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
-        history(args, registry)
+        history(args, registry).await
    }
 }

-fn history(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+async fn history(
+    args: CommandArgs,
+    _registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
    let config: Box<dyn Conf> = Box::new(NuConfig::new());
-    let tag = args.call_info.name_tag;
-    let path = history_path(&config);
-    let file = File::open(path);
-    if let Ok(file) = file {
-        let reader = BufReader::new(file);
-        let output = reader.lines().filter_map(move |line| match line {
-            Ok(line) => Some(ReturnSuccess::value(
-                UntaggedValue::string(line).into_value(tag.clone()),
-            )),
-            Err(_) => None,
-        });
+    let tag = args.call_info.name_tag.clone();
+    let (Arguments { clear }, _) = args.process(&_registry).await?;

-        Ok(futures::stream::iter(output).to_output_stream())
-    } else {
-        Err(ShellError::labeled_error(
-            "Could not open history",
-            "history file could not be opened",
-            tag,
-        ))
+    let path = history_path(&config);
+
+    match clear {
+        Some(_) => {
+            // This is a NOOP, the logic to clear is handled in cli.rs
+            Ok(OutputStream::empty())
+        }
+        None => {
+            if let Ok(file) = File::open(path) {
+                let reader = BufReader::new(file);
+                // Skips the first line, which is a Rustyline internal
+                let output = reader.lines().skip(1).filter_map(move |line| match line {
+                    Ok(line) => Some(ReturnSuccess::value(
+                        UntaggedValue::string(line).into_value(tag.clone()),
+                    )),
+                    Err(_) => None,
+                });
+
+                Ok(futures::stream::iter(output).to_output_stream())
+            } else {
+                Err(ShellError::labeled_error(
+                    "Could not open history",
+                    "history file could not be opened",
+                    tag,
+                ))
+            }
+        }
    }
 }

 #[cfg(test)]
 mod tests {
    use super::History;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(History {})
+        Ok(test_examples(History {})?)
    }
 }
--- a/crates/nu-cli/src/commands/if_.rs
+++ b/crates/nu-cli/src/commands/if_.rs
@ -4,7 +4,9 @@ use crate::commands::WholeStreamCommand;
 use crate::evaluate::evaluate_baseline_expr;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{hir::Block, hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue};
+use nu_protocol::{
+    hir::Block, hir::ClassifiedCommand, Scope, Signature, SyntaxShape, UntaggedValue,
+};

 pub struct If;

@ -72,7 +74,7 @@ async fn if_command(
    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
    let registry = Arc::new(registry.clone());
-    let scope = Arc::new(raw_args.call_info.scope.clone());
+    let scope = raw_args.call_info.scope.clone();
    let tag = raw_args.call_info.name_tag.clone();
    let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));

@ -119,14 +121,12 @@ async fn if_command(
            let then_case = then_case.clone();
            let else_case = else_case.clone();
            let registry = registry.clone();
-            let scope = scope.clone();
+            let scope = Scope::append_var(scope.clone(), "$it", input);
            let mut context = context.clone();

            async move {
                //FIXME: should we use the scope that's brought in as well?
-                let condition =
-                    evaluate_baseline_expr(&condition, &*registry, &input, &scope.vars, &scope.env)
-                        .await;
+                let condition = evaluate_baseline_expr(&condition, &*registry, scope.clone()).await;

                match condition {
                    Ok(condition) => match condition.as_bool() {
@ -136,9 +136,7 @@ async fn if_command(
                                    &then_case,
                                    Arc::make_mut(&mut context),
                                    InputStream::empty(),
-                                    &input,
-                                    &scope.vars,
-                                    &scope.env,
+                                    scope,
                                )
                                .await
                                {
@ -151,9 +149,7 @@ async fn if_command(
                                    &else_case,
                                    Arc::make_mut(&mut context),
                                    InputStream::empty(),
-                                    &input,
-                                    &scope.vars,
-                                    &scope.env,
+                                    scope,
                                )
                                .await
                                {
@ -178,11 +174,12 @@ async fn if_command(
 #[cfg(test)]
 mod tests {
    use super::If;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(If {})
+        Ok(test_examples(If {})?)
    }
 }
--- a/crates/nu-cli/src/commands/insert.rs
+++ b/crates/nu-cli/src/commands/insert.rs
@ -9,16 +9,18 @@ use nu_protocol::{
 use nu_value_ext::ValueExt;

 use futures::stream::once;
-pub struct Insert;
+use indexmap::indexmap;
+
+pub struct Command;

 #[derive(Deserialize)]
-pub struct InsertArgs {
+pub struct Arguments {
    column: ColumnPath,
    value: Value,
 }

 #[async_trait]
-impl WholeStreamCommand for Insert {
+impl WholeStreamCommand for Command {
    fn name(&self) -> &str {
        "insert"
    }
@ -44,6 +46,28 @@ impl WholeStreamCommand for Insert {
    ) -> Result<OutputStream, ShellError> {
        insert(args, registry).await
    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Insert a column with a value",
+            example: "echo [[author, commits]; ['Andrés', 1]] | insert branches 5",
+            result: Some(vec![UntaggedValue::row(indexmap! {
+                    "author".to_string() => Value::from("Andrés"),
+                    "commits".to_string() => UntaggedValue::int(1).into(),
+                    "branches".to_string() => UntaggedValue::int(5).into(),
+            })
+            .into()]),
+        },Example {
+            description: "Use in block form for more involved insertion logic",
+            example: "echo [[author, lucky_number]; ['Yehuda', 4]] | insert success { = $it.lucky_number * 10 }",
+            result: Some(vec![UntaggedValue::row(indexmap! {
+                    "author".to_string() => Value::from("Yehuda"),
+                    "lucky_number".to_string() => UntaggedValue::int(4).into(),
+                    "success".to_string() => UntaggedValue::int(40).into(),
+            })
+            .into()]),
+        }]
+    }
 }

 async fn process_row(
@ -63,15 +87,9 @@ async fn process_row(
            let for_block = input.clone();
            let input_stream = once(async { Ok(for_block) }).to_input_stream();

-            let result = run_block(
-                &block,
-                Arc::make_mut(&mut context),
-                input_stream,
-                &input,
-                &scope.vars,
-                &scope.env,
-            )
-            .await;
+            let scope = Scope::append_var(scope, "$it", input.clone());
+
+            let result = run_block(&block, Arc::make_mut(&mut context), input_stream, scope).await;

            match result {
                Ok(mut stream) => {
@ -85,13 +103,16 @@ async fn process_row(
                    let result = if values.len() == 1 {
                        let value = values
                            .get(0)
-                            .ok_or_else(|| ShellError::unexpected("No value to insert with"))?;
+                            .ok_or_else(|| ShellError::unexpected("No value to insert with."))?;

-                        value.clone()
+                        Value {
+                            value: value.value.clone(),
+                            tag: input.tag.clone(),
+                        }
                    } else if values.is_empty() {
-                        UntaggedValue::nothing().into_untagged_value()
+                        UntaggedValue::nothing().into_value(&input.tag)
                    } else {
-                        UntaggedValue::table(&values).into_untagged_value()
+                        UntaggedValue::table(&values).into_value(&input.tag)
                    };

                    match input {
@ -118,7 +139,11 @@ async fn process_row(
            Value {
                value: UntaggedValue::Primitive(Primitive::Nothing),
                ..
-            } => match scope.it.insert_data_at_column_path(&field, value.clone()) {
+            } => match scope
+                .var("$it")
+                .unwrap_or_else(|| UntaggedValue::nothing().into_untagged_value())
+                .insert_data_at_column_path(&field, value.clone())
+            {
                Ok(v) => OutputStream::one(ReturnSuccess::value(v)),
                Err(e) => OutputStream::one(Err(e)),
            },
@ -135,9 +160,9 @@ async fn insert(
    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
    let registry = registry.clone();
-    let scope = Arc::new(raw_args.call_info.scope.clone());
+    let scope = raw_args.call_info.scope.clone();
    let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
-    let (InsertArgs { column, value }, input) = raw_args.process(&registry).await?;
+    let (Arguments { column, value }, input) = raw_args.process(&registry).await?;
    let value = Arc::new(value);
    let column = Arc::new(column);

@ -158,15 +183,3 @@ async fn insert(
        .flatten()
        .to_output_stream())
 }
-
-#[cfg(test)]
-mod tests {
-    use super::Insert;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Insert {})
-    }
-}
--- a/crates/nu-cli/src/commands/into_int.rs
+++ b/crates/nu-cli/src/commands/into_int.rs
@ -37,7 +37,7 @@ impl WholeStreamCommand for IntoInt {
    fn examples(&self) -> Vec<Example> {
        vec![Example {
            description: "Convert filesize to integer",
-            example: "echo 1kb | into-int $it | = $it / 1024",
+            example: "into-int 1kb | each { = $it / 1024 }",
            result: Some(vec![UntaggedValue::int(1).into()]),
        }]
    }
@ -78,11 +78,12 @@ async fn into_int(
 #[cfg(test)]
 mod tests {
    use super::IntoInt;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(IntoInt {})
+        Ok(test_examples(IntoInt {})?)
    }
 }
--- a/crates/nu-cli/src/commands/is_empty.rs
+++ b/crates/nu-cli/src/commands/is_empty.rs
@ -1,217 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
-use nu_value_ext::ValueExt;
-
-enum IsEmptyFor {
-    Value,
-    RowWithFieldsAndFallback(Vec<Tagged<ColumnPath>>, Value),
-    RowWithField(Tagged<ColumnPath>),
-    RowWithFieldAndFallback(Box<Tagged<ColumnPath>>, Value),
-}
-
-pub struct IsEmpty;
-
-#[derive(Deserialize)]
-pub struct IsEmptyArgs {
-    rest: Vec<Value>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for IsEmpty {
-    fn name(&self) -> &str {
-        "empty?"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("empty?").rest(
-            SyntaxShape::Any,
-            "the names of the columns to check emptiness followed by the replacement value.",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Checks emptiness. The last value is the replacement value for any empty column(s) given to check against the table."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        is_empty(args, registry).await
-    }
-}
-
-async fn is_empty(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_tag = args.call_info.name_tag.clone();
-    let registry = registry.clone();
-    let (IsEmptyArgs { rest }, input) = args.process(&registry).await?;
-
-    if input.is_empty() {
-        return Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::boolean(true).into_value(name_tag),
-        )));
-    }
-
-    Ok(input
-        .map(move |value| {
-            let value_tag = value.tag();
-
-            let action = if rest.len() <= 2 {
-                let field = rest.get(0);
-                let replacement_if_true = rest.get(1);
-
-                match (field, replacement_if_true) {
-                    (Some(field), Some(replacement_if_true)) => {
-                        IsEmptyFor::RowWithFieldAndFallback(
-                            Box::new(field.as_column_path()?),
-                            replacement_if_true.clone(),
-                        )
-                    }
-                    (Some(field), None) => IsEmptyFor::RowWithField(field.as_column_path()?),
-                    (_, _) => IsEmptyFor::Value,
-                }
-            } else {
-                let mut arguments = rest.iter().rev();
-                let replacement_if_true = match arguments.next() {
-                    Some(arg) => arg.clone(),
-                    None => UntaggedValue::boolean(value.is_empty()).into_value(&value_tag),
-                };
-
-                IsEmptyFor::RowWithFieldsAndFallback(
-                    arguments
-                        .map(|a| a.as_column_path())
-                        .filter_map(Result::ok)
-                        .collect(),
-                    replacement_if_true,
-                )
-            };
-
-            match action {
-                IsEmptyFor::Value => Ok(ReturnSuccess::Value(
-                    UntaggedValue::boolean(value.is_empty()).into_value(value_tag),
-                )),
-                IsEmptyFor::RowWithFieldsAndFallback(fields, default) => {
-                    let mut out = value;
-
-                    for field in fields.iter() {
-                        let val = crate::commands::get::get_column_path(&field, &out)?;
-
-                        let emptiness_value = match out {
-                            obj
-                            @
-                            Value {
-                                value: UntaggedValue::Row(_),
-                                ..
-                            } => {
-                                if val.is_empty() {
-                                    obj.replace_data_at_column_path(&field, default.clone())
-                                        .ok_or_else(|| {
-                                            ShellError::labeled_error(
-                                                "empty? could not find place to check emptiness",
-                                                "column name",
-                                                &field.tag,
-                                            )
-                                        })
-                                } else {
-                                    Ok(obj)
-                                }
-                            }
-                            _ => Err(ShellError::labeled_error(
-                                "Unrecognized type in stream",
-                                "original value",
-                                &value_tag,
-                            )),
-                        };
-
-                        out = emptiness_value?;
-                    }
-
-                    Ok(ReturnSuccess::Value(out))
-                }
-                IsEmptyFor::RowWithField(field) => {
-                    let val = crate::commands::get::get_column_path(&field, &value)?;
-
-                    match &value {
-                        obj
-                        @
-                        Value {
-                            value: UntaggedValue::Row(_),
-                            ..
-                        } => {
-                            if val.is_empty() {
-                                match obj.replace_data_at_column_path(
-                                    &field,
-                                    UntaggedValue::boolean(true).into_value(&value_tag),
-                                ) {
-                                    Some(v) => Ok(ReturnSuccess::Value(v)),
-                                    None => Err(ShellError::labeled_error(
-                                        "empty? could not find place to check emptiness",
-                                        "column name",
-                                        &field.tag,
-                                    )),
-                                }
-                            } else {
-                                Ok(ReturnSuccess::Value(value))
-                            }
-                        }
-                        _ => Err(ShellError::labeled_error(
-                            "Unrecognized type in stream",
-                            "original value",
-                            &value_tag,
-                        )),
-                    }
-                }
-                IsEmptyFor::RowWithFieldAndFallback(field, default) => {
-                    let val = crate::commands::get::get_column_path(&field, &value)?;
-
-                    match &value {
-                        obj
-                        @
-                        Value {
-                            value: UntaggedValue::Row(_),
-                            ..
-                        } => {
-                            if val.is_empty() {
-                                match obj.replace_data_at_column_path(&field, default) {
-                                    Some(v) => Ok(ReturnSuccess::Value(v)),
-                                    None => Err(ShellError::labeled_error(
-                                        "empty? could not find place to check emptiness",
-                                        "column name",
-                                        &field.tag,
-                                    )),
-                                }
-                            } else {
-                                Ok(ReturnSuccess::Value(value))
-                            }
-                        }
-                        _ => Err(ShellError::labeled_error(
-                            "Unrecognized type in stream",
-                            "original value",
-                            &value_tag,
-                        )),
-                    }
-                }
-            }
-        })
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::IsEmpty;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(IsEmpty {})
-    }
-}
--- a/crates/nu-cli/src/commands/keep/command.rs
+++ b/crates/nu-cli/src/commands/keep/command.rs
@ -74,11 +74,12 @@ async fn keep(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStr
 #[cfg(test)]
 mod tests {
    use super::Command;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Command {})
+        Ok(test_examples(Command {})?)
    }
 }
--- a/crates/nu-cli/src/commands/keep/until.rs
+++ b/crates/nu-cli/src/commands/keep/until.rs
@ -3,7 +3,7 @@ use crate::evaluate::evaluate_baseline_expr;
 use crate::prelude::*;
 use log::trace;
 use nu_errors::ShellError;
-use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{hir::ClassifiedCommand, Scope, Signature, SyntaxShape, UntaggedValue, Value};

 pub struct SubCommand;

@ -33,7 +33,7 @@ impl WholeStreamCommand for SubCommand {
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
        let registry = Arc::new(registry.clone());
-        let scope = Arc::new(args.call_info.scope.clone());
+        let scope = args.call_info.scope.clone();

        let call_info = args.evaluate_once(&registry).await?;

@ -85,19 +85,11 @@ impl WholeStreamCommand for SubCommand {
            .take_while(move |item| {
                let condition = condition.clone();
                let registry = registry.clone();
-                let scope = scope.clone();
-                let item = item.clone();
+                let scope = Scope::append_var(scope.clone(), "$it", item.clone());
                trace!("ITEM = {:?}", item);

                async move {
-                    let result = evaluate_baseline_expr(
-                        &*condition,
-                        &registry,
-                        &item,
-                        &scope.vars,
-                        &scope.env,
-                    )
-                    .await;
+                    let result = evaluate_baseline_expr(&*condition, &registry, scope).await;
                    trace!("RESULT = {:?}", result);

                    !matches!(result, Ok(ref v) if v.is_true())
@ -109,12 +101,13 @@ impl WholeStreamCommand for SubCommand {

 #[cfg(test)]
 mod tests {
+    use super::ShellError;
    use super::SubCommand;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(SubCommand {})
+        Ok(test_examples(SubCommand {})?)
    }
 }
--- a/crates/nu-cli/src/commands/keep/while_.rs
+++ b/crates/nu-cli/src/commands/keep/while_.rs
@ -3,7 +3,7 @@ use crate::evaluate::evaluate_baseline_expr;
 use crate::prelude::*;
 use log::trace;
 use nu_errors::ShellError;
-use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{hir::ClassifiedCommand, Scope, Signature, SyntaxShape, UntaggedValue, Value};

 pub struct SubCommand;

@ -33,7 +33,7 @@ impl WholeStreamCommand for SubCommand {
        registry: &CommandRegistry,
    ) -> Result<OutputStream, ShellError> {
        let registry = Arc::new(registry.clone());
-        let scope = Arc::new(args.call_info.scope.clone());
+        let scope = args.call_info.scope.clone();
        let call_info = args.evaluate_once(&registry).await?;

        let block = call_info.args.expect_nth(0)?.clone();
@ -84,20 +84,11 @@ impl WholeStreamCommand for SubCommand {
            .take_while(move |item| {
                let condition = condition.clone();
                let registry = registry.clone();
-                let scope = scope.clone();
-                let item = item.clone();
-
+                let scope = Scope::append_var(scope.clone(), "$it", item.clone());
                trace!("ITEM = {:?}", item);

                async move {
-                    let result = evaluate_baseline_expr(
-                        &*condition,
-                        &registry,
-                        &item,
-                        &scope.vars,
-                        &scope.env,
-                    )
-                    .await;
+                    let result = evaluate_baseline_expr(&*condition, &registry, scope).await;
                    trace!("RESULT = {:?}", result);

                    matches!(result, Ok(ref v) if v.is_true())
@ -109,12 +100,13 @@ impl WholeStreamCommand for SubCommand {

 #[cfg(test)]
 mod tests {
+    use super::ShellError;
    use super::SubCommand;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(SubCommand {})
+        Ok(test_examples(SubCommand {})?)
    }
 }
--- a/crates/nu-cli/src/commands/kill.rs
+++ b/crates/nu-cli/src/commands/kill.rs
@ -121,11 +121,12 @@ async fn kill(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStr
 #[cfg(test)]
 mod tests {
    use super::Kill;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Kill {})
+        Ok(test_examples(Kill {})?)
    }
 }
--- a/crates/nu-cli/src/commands/last.rs
+++ b/crates/nu-cli/src/commands/last.rs
@ -83,11 +83,12 @@ async fn last(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStr
 #[cfg(test)]
 mod tests {
    use super::Last;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Last {})
+        Ok(test_examples(Last {})?)
    }
 }
--- a/crates/nu-cli/src/commands/lines.rs
+++ b/crates/nu-cli/src/commands/lines.rs
@ -75,9 +75,9 @@ async fn lines(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputSt
                } => {
                    let mut leftover_string = leftover_string.lock();

-                    let st = (&*leftover_string).clone() + &st;
-
-                    let mut lines: Vec<String> = st.lines().map(|x| x.to_string()).collect();
+                    let lo_lines = (&*leftover_string).lines().map(|x| x.to_string());
+                    let st_lines = st.lines().map(|x| x.to_string());
+                    let mut lines: Vec<String> = lo_lines.chain(st_lines).collect();

                    leftover_string.clear();

@ -125,11 +125,12 @@ async fn lines(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputSt
 #[cfg(test)]
 mod tests {
    use super::Lines;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Lines {})
+        Ok(test_examples(Lines {})?)
    }
 }
--- a/crates/nu-cli/src/commands/ls.rs
+++ b/crates/nu-cli/src/commands/ls.rs
@ -89,11 +89,12 @@ impl WholeStreamCommand for Ls {
 #[cfg(test)]
 mod tests {
    use super::Ls;
+    use super::ShellError;

    #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
        use crate::examples::test as test_examples;

-        test_examples(Ls {})
+        Ok(test_examples(Ls {})?)
    }
 }
--- a/Show More
+++ b/Show More