Version bump for 0.75 release (#7902)

- [x] Are we ready for the release
- [x] Upgrade to upcoming `reedline 0.15`

.github/dependabot.yml

@@ -0,0 +1,20 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+# docs
+# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    ignore:
+      - dependency-name: "*"
+        update-types: ["version-update:semver-patch"]
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/ci.yml

@@ -11,9 +11,26 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        platform: [windows-latest, macos-latest, ubuntu-latest]
+        # Pinning to Ubuntu 20.04 because building on newer Ubuntu versions causes linux-gnu
+        # builds to link against a too-new-for-many-Linux-installs glibc version. Consider
+        # revisiting this when 20.04 is closer to EOL (April 2025)
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
+        style: [default, dataframe]
         rust:
           - stable
+        include:
+          - style: default
+            flags: ""
+          - style: dataframe
+            flags: "--features=dataframe "
+        exclude:
+          # only test dataframes on Ubuntu (the fastest platform)
+          - platform: windows-latest
+            style: dataframe
+          - platform: macos-latest
+            style: dataframe
+
+
 
     runs-on: ${{ matrix.platform }}
     env:
@@ -23,19 +40,13 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.5
 
-      - name: Rustfmt
+      - name: cargo fmt
-        uses: actions-rs/cargo@v1.0.1
+        run: cargo fmt --all -- --check
-        with:
-          command: fmt
-          args: --all -- --check
 
       - name: Clippy
-        uses: actions-rs/cargo@v1.0.1
+        run: cargo clippy --workspace ${{ matrix.flags }}--exclude nu_plugin_* -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
-        with:
-          command: clippy
-          args: --workspace --exclude nu_plugin_* -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
 
   nu-tests:
     env:
@@ -44,7 +55,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        platform: [windows-latest, macos-latest, ubuntu-latest]
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
         style: [default, dataframe]
         rust:
           - stable
@@ -66,13 +77,10 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.5
 
       - name: Tests
-        uses: actions-rs/cargo@v1.0.1
+        run: cargo test --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
-        with:
-          command: test
-          args: --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
 
   python-virtualenv:
     env:
@@ -81,7 +89,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        platform: [ubuntu-latest, macos-latest, windows-latest]
+        platform: [ubuntu-20.04, macos-latest, windows-latest]
         rust:
           - stable
         py:
@@ -93,13 +101,10 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.5
 
       - name: Install Nushell
-        uses: actions-rs/cargo@v1.0.1
+        run: cargo install --locked --path=. --profile ci --no-default-features
-        with:
-          command: install
-          args: --locked --path=. --profile ci --no-default-features
 
       - name: Setup Python
         uses: actions/setup-python@v4
@@ -108,8 +113,9 @@ jobs:
 
       - run: python -m pip install tox
 
+        # Get only the latest tagged version for stability reasons
       - name: Install virtualenv
-        run: git clone https://github.com/pypa/virtualenv.git
+        run: git clone https://github.com/pypa/virtualenv.git && cd virtualenv && git checkout $(git describe --tags | cut -d - -f 1)
         shell: bash
 
       - name: Test Nushell in virtualenv
@@ -125,7 +131,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        platform: [windows-latest, macos-latest, ubuntu-latest]
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
         rust:
           - stable
 
@@ -135,16 +141,10 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.5
 
       - name: Clippy
-        uses: actions-rs/cargo@v1.0.1
+        run: cargo clippy --package nu_plugin_* ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
-        with:
-          command: clippy
-          args: --package nu_plugin_* ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
 
       - name: Tests
-        uses: actions-rs/cargo@v1.0.1
+        run: cargo test --profile ci --package nu_plugin_*
-        with:
-          command: test
-          args: --profile ci --package nu_plugin_*

.github/workflows/release-pkg.nu

@@ -6,6 +6,32 @@
 # REF:
 #   1. https://github.com/volks73/cargo-wix
 
+# Added 2022-11-29 when Windows packaging wouldn't work
+# To run this manual for windows
+# unset CARGO_TARGET_DIR if set
+# hide-env CARGO_TARGET_DIR
+# let-env TARGET = 'x86_64-pc-windows-msvc'
+# let-env TARGET_RUSTFLAGS = ''
+# let-env GITHUB_WORKSPACE = 'C:\Users\dschroeder\source\repos\forks\nushell'
+# let-env GITHUB_OUTPUT = 'C:\Users\dschroeder\source\repos\forks\nushell\output\out.txt'
+# let-env OS = 'windows-latest'
+# You need to run this twice. The first pass makes the output folder and builds everything
+# The second pass generates the msi file
+# Pass 1 let-env _EXTRA_ = 'bin'
+# Pass 2 let-env _EXTRA_ = 'msi'
+# make sure 7z.exe is in your path https://www.7-zip.org/download.html
+# let-env Path = ($env.Path | append 'c:\apps\7-zip')
+# make sure aria2c.exe is in your path https://github.com/aria2/aria2
+# let-env Path = ($env.Path | append 'c:\path\to\aria2c')
+# make sure you have the wixtools installed https://wixtoolset.org/
+# let-env Path = ($env.Path | append 'C:\Users\dschroeder\AppData\Local\tauri\WixTools')
+# After msi is generated, if you have to update winget-pkgs repo, you'll need to patch the release
+# by deleting the existing msi and uploading this new msi. Then you'll need to update the hash
+# on the winget-pkgs PR. To generate the hash, run this command
+# open target\wix\nu-0.74.0-x86_64-pc-windows-msvc.msi | hash sha256
+# Then, just take the output and put it in the winget-pkgs PR for the hash on the msi
+
+
 # The main binary file to be released
 let bin = 'nu'
 let os = $env.OS
@@ -16,8 +42,13 @@ let flags = $env.TARGET_RUSTFLAGS
 let dist = $'($env.GITHUB_WORKSPACE)/output'
 let version = (open Cargo.toml | get package.version)
 
+$'Debugging info:'
+print { version: $version, bin: $bin, os: $os, target: $target, src: $src, flags: $flags, dist: $dist }; hr-line -b
+
 # $env
 
+let USE_UBUNTU = 'ubuntu-20.04'
+
 $'(char nl)Packaging ($bin) v($version) for ($target) in ($src)...'; hr-line -b
 if not ('Cargo.lock' | path exists) { cargo generate-lockfile }
 
@@ -26,8 +57,9 @@ $'Start building ($bin)...'; hr-line
 # ----------------------------------------------------------------------------
 # Build for Ubuntu and macOS
 # ----------------------------------------------------------------------------
-if $os in ['ubuntu-latest', 'macos-latest'] {
+if $os in [$USE_UBUNTU, 'macos-latest'] {
-    if $os == 'ubuntu-latest' {
+    if $os == $USE_UBUNTU {
+        sudo apt update
         sudo apt-get install libxcb-composite0-dev -y
     }
     if $target == 'aarch64-unknown-linux-gnu' {
@@ -38,10 +70,14 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
         sudo apt-get install pkg-config gcc-arm-linux-gnueabihf -y
         let-env CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER = 'arm-linux-gnueabihf-gcc'
         cargo-build-nu $flags
+    } else if $target == 'riscv64gc-unknown-linux-gnu' {
+        sudo apt-get install gcc-riscv64-linux-gnu -y
+        let-env CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER = 'riscv64-linux-gnu-gcc'
+        cargo-build-nu $flags
     } else {
         # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
         # Actually just for x86_64-unknown-linux-musl target
-        if $os == 'ubuntu-latest' { sudo apt install musl-tools -y }
+        if $os == $USE_UBUNTU { sudo apt install musl-tools -y }
         cargo-build-nu $flags
     }
 }
@@ -88,7 +124,7 @@ if ($ver | str trim | is-empty) {
 # Create a release archive and send it to output for the following steps
 # ----------------------------------------------------------------------------
 cd $dist; $'(char nl)Creating release archive...'; hr-line
-if $os in ['ubuntu-latest', 'macos-latest'] {
+if $os in [$USE_UBUNTU, 'macos-latest'] {
 
     let files = (ls | get name)
     let dest = $'($bin)-($version)-($target)'
@@ -101,7 +137,8 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
 
     tar -czf $archive $dest
     print $'archive: ---> ($archive)'; ls $archive
-    echo $'::set-output name=archive::($archive)'
+    # REF: https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/
+    echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT
 
 } else if $os == 'windows-latest' {
 
@@ -121,7 +158,8 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
         cp -r $'($dist)/*' target/release/
         cargo install cargo-wix --version 0.3.3
         cargo wix --no-build --nocapture --package nu --output $wixRelease
-        echo $'::set-output name=archive::($wixRelease)'
+        print $'archive: ---> ($wixRelease)';
+        echo $"archive=($wixRelease)" | save --append $env.GITHUB_OUTPUT
 
     } else {
 
@@ -131,7 +169,7 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
         print $'archive: ---> ($archive)';
         let pkg = (ls -f $archive | get name)
         if not ($pkg | is-empty) {
-            echo $'::set-output name=archive::($pkg | get 0)'
+            echo $"archive=($pkg | get 0)" | save --append $env.GITHUB_OUTPUT
         }
     }
 }

.github/workflows/release.yml

@@ -27,6 +27,7 @@ jobs:
         - x86_64-unknown-linux-musl
         - aarch64-unknown-linux-gnu
         - armv7-unknown-linux-gnueabihf
+        - riscv64gc-unknown-linux-gnu
         extra: ['bin']
         include:
         - target: aarch64-apple-darwin
@@ -44,35 +45,37 @@ jobs:
           os: windows-latest
           target_rustflags: ''
         - target: x86_64-unknown-linux-gnu
-          os: ubuntu-latest
+          os: ubuntu-20.04
           target_rustflags: ''
         - target: x86_64-unknown-linux-musl
-          os: ubuntu-latest
+          os: ubuntu-20.04
           target_rustflags: ''
         - target: aarch64-unknown-linux-gnu
-          os: ubuntu-latest
+          os: ubuntu-20.04
           target_rustflags: ''
         - target: armv7-unknown-linux-gnueabihf
-          os: ubuntu-latest
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: riscv64gc-unknown-linux-gnu
+          os: ubuntu-20.04
           target_rustflags: ''
 
     runs-on: ${{matrix.os}}
 
     steps:
-    - uses: actions/checkout@v3.0.2
+    - uses: actions/checkout@v3.1.0
 
-    - name: Install Rust Toolchain Components
+    - name: Update Rust Toolchain Target
-      uses: actions-rs/toolchain@v1.0.6
+      run: |
-      with:
+        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
-        override: true
+
-        profile: minimal
+    - name: Setup Rust toolchain and cache
-        toolchain: stable
+      uses: actions-rust-lang/setup-rust-toolchain@v1.3.5
-        target: ${{ matrix.target }}
 
     - name: Setup Nushell
-      uses: hustcer/setup-nu@v2.1
+      uses: hustcer/setup-nu@v3
       with:
-        version: 0.69.1
+        version: 0.72.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/stale.yml

@@ -12,7 +12,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v3
+      - uses: actions/stale@v6
         with:
           #debug-only: true
           ascending: true

.github/workflows/typos.yml

@@ -0,0 +1,13 @@
+name: Typos
+on: [pull_request]
+
+jobs:
+  run:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Actions Repository
+        uses: actions/checkout@v2
+
+      - name: Check spelling of book
+        uses: crate-ci/typos@master

.typos.toml

@@ -0,0 +1,12 @@
+[files]
+extend-exclude = ["crates/nu-command/tests/commands/table.rs", "*.tsv", "*.json", "*.txt"]
+
+[default.extend-words]
+# Ignore false-positives
+nd = "nd"
+fo = "fo"
+ons = "ons"
+ba = "ba"
+Plasticos = "Plasticos"
+IIF = "IIF"
+numer = "numer"

Cargo.toml

@@ -3,14 +3,14 @@ authors = ["The Nushell Project Developers"]
 default-run = "nu"
 description = "A new type of shell"
 documentation = "https://www.nushell.sh/book/"
-edition = "2018"
+edition = "2021"
 exclude = ["images"]
 homepage = "https://www.nushell.sh"
 license = "MIT"
 name = "nu"
 repository = "https://github.com/nushell/nushell"
 rust-version = "1.60"
-version = "0.72.1"
+version = "0.75.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -43,25 +43,25 @@ chrono = { version = "0.4.23", features = ["serde"] }
 crossterm = "0.24.0"
 ctrlc = "3.2.1"
 log = "0.4"
-miette = { version = "5.1.0", features = ["fancy-no-backtrace"] }
+miette = { version = "5.5.0", features = ["fancy-no-backtrace"] }
 nu-ansi-term = "0.46.0"
-nu-cli = { path="./crates/nu-cli", version = "0.72.1"  }
+nu-cli = { path = "./crates/nu-cli", version = "0.75.0" }
-nu-color-config = { path = "./crates/nu-color-config", version = "0.72.1"  }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.75.0" }
-nu-command = { path="./crates/nu-command", version = "0.72.1"  }
+nu-command = { path = "./crates/nu-command", version = "0.75.0" }
-nu-engine = { path="./crates/nu-engine", version = "0.72.1"  }
+nu-engine = { path = "./crates/nu-engine", version = "0.75.0" }
-nu-json = { path="./crates/nu-json", version = "0.72.1"  }
+nu-json = { path = "./crates/nu-json", version = "0.75.0" }
-nu-parser = { path="./crates/nu-parser", version = "0.72.1"  }
+nu-parser = { path = "./crates/nu-parser", version = "0.75.0" }
-nu-path = { path="./crates/nu-path", version = "0.72.1"  }
+nu-path = { path = "./crates/nu-path", version = "0.75.0" }
-nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.72.1"  }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.75.0" }
-nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.72.1"  }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.75.0" }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.72.1"  }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.75.0" }
-nu-system = { path = "./crates/nu-system", version = "0.72.1" }
+nu-system = { path = "./crates/nu-system", version = "0.75.0" }
-nu-table = { path = "./crates/nu-table", version = "0.72.1"  }
+nu-table = { path = "./crates/nu-table", version = "0.75.0" }
-nu-term-grid = { path = "./crates/nu-term-grid", version = "0.72.1"  }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.75.0" }
-nu-utils = { path = "./crates/nu-utils", version = "0.72.1"  }
+nu-utils = { path = "./crates/nu-utils", version = "0.75.0" }
-reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
+reedline = { version = "0.15.0", features = ["bashisms", "sqlite"] }
 
-rayon = "1.5.1"
+rayon = "1.6.1"
 is_executable = "1.0.1"
 simplelog = "0.12.0"
 time = "0.3.12"
@@ -76,21 +76,29 @@ signal-hook = { version = "0.3.14", default-features = false }
 winres = "0.1"
 
 [target.'cfg(target_family = "unix")'.dependencies]
-nix = { version = "0.25", default-features = false, features = ["signal", "process", "fs", "term"]}
+nix = { version = "0.25", default-features = false, features = ["signal", "process", "fs", "term"] }
 atty = "0.2"
 
 [dev-dependencies]
-nu-test-support = { path="./crates/nu-test-support", version = "0.72.1"  }
+nu-test-support = { path = "./crates/nu-test-support", version = "0.75.0" }
 tempfile = "3.2.0"
 assert_cmd = "2.0.2"
+criterion = "0.4"
 pretty_assertions = "1.0.0"
-serial_test = "0.8.0"
+serial_test = "1.0.0"
 hamcrest2 = "0.3.0"
-rstest = {version = "0.15.0", default-features = false}
+rstest = { version = "0.15.0", default-features = false }
 itertools = "0.10.3"
 
 [features]
-plugin = ["nu-plugin", "nu-cli/plugin", "nu-parser/plugin", "nu-command/plugin", "nu-protocol/plugin", "nu-engine/plugin"]
+plugin = [
+	"nu-plugin",
+	"nu-cli/plugin",
+	"nu-parser/plugin",
+	"nu-command/plugin",
+	"nu-protocol/plugin",
+	"nu-engine/plugin",
+]
 # extra used to be more useful but now it's the same as default. Leaving it in for backcompat with existing build scripts
 extra = ["default"]
 default = ["plugin", "which-support", "trash-support", "sqlite"]
@@ -113,7 +121,7 @@ dataframe = ["nu-command/dataframe"]
 sqlite = ["nu-command/sqlite"]
 
 [profile.release]
-opt-level = "s" # Optimize for size
+opt-level = "s"     # Optimize for size
 strip = "debuginfo"
 lto = "thin"
 
@@ -140,3 +148,10 @@ path = "src/main.rs"
 # changing versions in each sub-crate of the workspace is tedious
 [patch.crates-io]
 # reedline = { git = "https://github.com/nushell/reedline.git", branch = "main" }
+
+# Criterion benchmarking setup
+# Run all benchmarks with `cargo bench`
+# Run individual benchmarks like `cargo bench -- <regex>` e.g. `cargo bench -- parse`
+[[bench]]
+name = "benchmarks"
+harness = false

Cross.toml

@@ -0,0 +1,9 @@
+# Configuration for cross-rs: https://github.com/cross-rs/cross
+# Run cross-rs like this:
+# cross build --target aarch64-unknown-linux-musl --release
+
+[target.aarch64-unknown-linux-gnu]
+dockerfile = "./docker/cross-rs/aarch64-unknown-linux-gnu.dockerfile"
+
+[target.aarch64-unknown-linux-musl]
+dockerfile = "./docker/cross-rs/aarch64-unknown-linux-musl.dockerfile"

README.md

@@ -1,6 +1,6 @@
 # Nushell <!-- omit in toc -->
 [![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
-![Build Status](https://img.shields.io/github/workflow/status/nushell/nushell/continuous-integration)
+![Build Status](https://img.shields.io/github/actions/workflow/status/nushell/nushell/ci.yml?branch=main)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
 [![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)
@@ -47,7 +47,7 @@ brew install nushell
 winget install nushell
 ```
 
-To use `Nu` in Github Action, check [setup-nu](https://github.com/marketplace/actions/setup-nu) for more detail.
+To use `Nu` in GitHub Action, check [setup-nu](https://github.com/marketplace/actions/setup-nu) for more detail.
 
 Detailed installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). Nu is available via many package managers:
 
@@ -174,6 +174,8 @@ These binaries interact with nu via a simple JSON-RPC protocol where the command
 If the plugin is a filter, data streams to it one element at a time, and it can stream data back in return via stdin/stdout.
 If the plugin is a sink, it is given the full vector of final data and is given free reign over stdin/stdout to use as it pleases.
 
+The [awesome-nu repo](https://github.com/nushell/awesome-nu#plugins) lists a variety of nu-plugins.
+
 ## Goals
 
 Nu adheres closely to a set of goals that make up its design philosophy. As features are added, they are checked against these goals.

benches/README.md

@@ -0,0 +1,7 @@
+# Criterion benchmarks
+
+These are benchmarks using [Criterion](https://github.com/bheisler/criterion.rs), a microbenchmarking tool for Rust.
+
+Run all benchmarks with `cargo bench`
+
+Or run individual benchmarks like `cargo bench -- <regex>` e.g. `cargo bench -- parse`

benches/benchmarks.rs

@@ -0,0 +1,187 @@
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use nu_cli::eval_source;
+use nu_parser::parse;
+use nu_plugin::{EncodingType, PluginResponse};
+use nu_protocol::{PipelineData, Span, Value};
+use nu_utils::{get_default_config, get_default_env};
+
+// FIXME: All benchmarks live in this 1 file to speed up build times when benchmarking.
+// When the *_benchmarks functions were in different files, `cargo bench` would build
+// an executable for every single one - incredibly slowly. Would be nice to figure out
+// a way to split things up again.
+
+fn parser_benchmarks(c: &mut Criterion) {
+    let mut engine_state = nu_command::create_default_context();
+    // parsing config.nu breaks without PWD set
+    engine_state.add_env_var(
+        "PWD".into(),
+        Value::string("/some/dir".to_string(), Span::test_data()),
+    );
+
+    let default_env = get_default_env().as_bytes();
+    c.bench_function("parse_default_env_file", |b| {
+        b.iter_batched(
+            || nu_protocol::engine::StateWorkingSet::new(&engine_state),
+            |mut working_set| parse(&mut working_set, None, default_env, false, &[]),
+            BatchSize::SmallInput,
+        )
+    });
+
+    let default_config = get_default_config().as_bytes();
+    c.bench_function("parse_default_config_file", |b| {
+        b.iter_batched(
+            || nu_protocol::engine::StateWorkingSet::new(&engine_state),
+            |mut working_set| parse(&mut working_set, None, default_config, false, &[]),
+            BatchSize::SmallInput,
+        )
+    });
+
+    c.bench_function("eval default_env.nu", |b| {
+        b.iter(|| {
+            let mut engine_state = nu_command::create_default_context();
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_env().as_bytes(),
+                "default_env.nu",
+                PipelineData::empty(),
+            )
+        })
+    });
+
+    c.bench_function("eval default_config.nu", |b| {
+        b.iter(|| {
+            let mut engine_state = nu_command::create_default_context();
+            // parsing config.nu breaks without PWD set
+            engine_state.add_env_var(
+                "PWD".into(),
+                Value::string("/some/dir".to_string(), Span::test_data()),
+            );
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_config().as_bytes(),
+                "default_config.nu",
+                PipelineData::empty(),
+            )
+        })
+    });
+}
+
+fn eval_benchmarks(c: &mut Criterion) {
+    c.bench_function("eval default_env.nu", |b| {
+        b.iter(|| {
+            let mut engine_state = nu_command::create_default_context();
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_env().as_bytes(),
+                "default_env.nu",
+                PipelineData::empty(),
+            )
+        })
+    });
+
+    c.bench_function("eval default_config.nu", |b| {
+        b.iter(|| {
+            let mut engine_state = nu_command::create_default_context();
+            // parsing config.nu breaks without PWD set
+            engine_state.add_env_var(
+                "PWD".into(),
+                Value::string("/some/dir".to_string(), Span::test_data()),
+            );
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_config().as_bytes(),
+                "default_config.nu",
+                PipelineData::empty(),
+            )
+        })
+    });
+}
+
+// generate a new table data with `row_cnt` rows, `col_cnt` columns.
+fn encoding_test_data(row_cnt: usize, col_cnt: usize) -> Value {
+    let columns: Vec<String> = (0..col_cnt).map(|x| format!("col_{x}")).collect();
+    let vals: Vec<Value> = (0..col_cnt as i64).map(Value::test_int).collect();
+
+    Value::List {
+        vals: (0..row_cnt)
+            .map(|_| Value::test_record(columns.clone(), vals.clone()))
+            .collect(),
+        span: Span::test_data(),
+    }
+}
+
+fn encoding_benchmarks(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Encoding");
+    let test_cnt_pairs = [
+        (100, 5),
+        (100, 10),
+        (100, 15),
+        (1000, 5),
+        (1000, 10),
+        (1000, 15),
+        (10000, 5),
+        (10000, 10),
+        (10000, 15),
+    ];
+    for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
+        for fmt in ["json", "msgpack"] {
+            group.bench_function(&format!("{fmt} encode {row_cnt} * {col_cnt}"), |b| {
+                let mut res = vec![];
+                let test_data =
+                    PluginResponse::Value(Box::new(encoding_test_data(row_cnt, col_cnt)));
+                let encoder = EncodingType::try_from_bytes(fmt.as_bytes()).unwrap();
+                b.iter(|| encoder.encode_response(&test_data, &mut res))
+            });
+        }
+    }
+    group.finish();
+}
+
+fn decoding_benchmarks(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Decoding");
+    let test_cnt_pairs = [
+        (100, 5),
+        (100, 10),
+        (100, 15),
+        (1000, 5),
+        (1000, 10),
+        (1000, 15),
+        (10000, 5),
+        (10000, 10),
+        (10000, 15),
+    ];
+    for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
+        for fmt in ["json", "msgpack"] {
+            group.bench_function(&format!("{fmt} decode for {row_cnt} * {col_cnt}"), |b| {
+                let mut res = vec![];
+                let test_data =
+                    PluginResponse::Value(Box::new(encoding_test_data(row_cnt, col_cnt)));
+                let encoder = EncodingType::try_from_bytes(fmt.as_bytes()).unwrap();
+                encoder.encode_response(&test_data, &mut res).unwrap();
+                let mut binary_data = std::io::Cursor::new(res);
+                b.iter(|| {
+                    binary_data.set_position(0);
+                    encoder.decode_response(&mut binary_data)
+                })
+            });
+        }
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    parser_benchmarks,
+    eval_benchmarks,
+    encoding_benchmarks,
+    decoding_benchmarks
+);
+criterion_main!(benches);

build-all-windows.cmd

@@ -5,7 +5,7 @@
 @echo.
 
 echo Building nushell.exe
-cargo build cargo build --features=dataframe
+cargo build --features=dataframe
 @echo.
 
 @cd crates\nu_plugin_example

crates/nu-cli/Cargo.toml

@@ -5,34 +5,34 @@ repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cli"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.72.1"
+version = "0.75.0"
 
 [dev-dependencies]
-nu-test-support = { path="../nu-test-support", version = "0.72.1"  }
+nu-test-support = { path = "../nu-test-support", version = "0.75.0" }
-nu-command = { path = "../nu-command", version = "0.72.1" }
+nu-command = { path = "../nu-command", version = "0.75.0" }
-rstest = {version = "0.15.0", default-features = false}
+rstest = { version = "0.15.0", default-features = false }
 
 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.72.1"  }
+nu-engine = { path = "../nu-engine", version = "0.75.0" }
-nu-path = { path = "../nu-path", version = "0.72.1"  }
+nu-path = { path = "../nu-path", version = "0.75.0" }
-nu-parser = { path = "../nu-parser", version = "0.72.1"  }
+nu-parser = { path = "../nu-parser", version = "0.75.0" }
-nu-protocol = { path = "../nu-protocol", version = "0.72.1"  }
+nu-protocol = { path = "../nu-protocol", version = "0.75.0" }
-nu-utils = { path = "../nu-utils", version = "0.72.1"  }
+nu-utils = { path = "../nu-utils", version = "0.75.0" }
 nu-ansi-term = "0.46.0"
-nu-color-config = { path = "../nu-color-config", version = "0.72.1"  }
+nu-color-config = { path = "../nu-color-config", version = "0.75.0" }
-reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
+reedline = { version = "0.15.0", features = ["bashisms", "sqlite"] }
 
 atty = "0.2.14"
 chrono = { default-features = false, features = ["std"], version = "0.4.23" }
 crossterm = "0.24.0"
-fancy-regex = "0.10.0"
+fancy-regex = "0.11.0"
 fuzzy-matcher = "0.3.7"
 is_executable = "1.0.1"
-lazy_static = "1.4.0"
+once_cell = "1.17.0"
 log = "0.4"
-miette = { version = "5.1.0", features = ["fancy-no-backtrace"] }
+miette = { version = "5.5.0", features = ["fancy-no-backtrace"] }
 percent-encoding = "2"
-sysinfo = "0.26.2"
+sysinfo = "0.27.7"
 thiserror = "1.0.31"
 
 [features]

crates/nu-cli/src/completions/command_completions.rs

@@ -94,10 +94,7 @@ impl CommandCompletion {
                 value: String::from_utf8_lossy(&x.0).to_string(),
                 description: x.1,
                 extra: None,
-                span: reedline::Span {
+                span: reedline::Span::new(span.start - offset, span.end - offset),
-                    start: span.start - offset,
-                    end: span.end - offset,
-                },
                 append_whitespace: true,
             });
 
@@ -108,10 +105,7 @@ impl CommandCompletion {
                 value: String::from_utf8_lossy(&x).to_string(),
                 description: None,
                 extra: None,
-                span: reedline::Span {
+                span: reedline::Span::new(span.start - offset, span.end - offset),
-                    start: span.start - offset,
-                    end: span.end - offset,
-                },
                 append_whitespace: true,
             });
 
@@ -128,15 +122,15 @@ impl CommandCompletion {
                     value: x,
                     description: None,
                     extra: None,
-                    span: reedline::Span {
+                    span: reedline::Span::new(span.start - offset, span.end - offset),
-                        start: span.start - offset,
-                        end: span.end - offset,
-                    },
                     append_whitespace: true,
                 });
 
+            let results_strings: Vec<String> =
+                results.clone().into_iter().map(|x| x.value).collect();
+
             for external in results_external {
-                if results.contains(&external) {
+                if results_strings.contains(&external.value) {
                     results.push(Suggestion {
                         value: format!("^{}", external.value),
                         description: None,
@@ -170,7 +164,7 @@ impl Completer for CommandCompletion {
             .flattened
             .iter()
             .rev()
-            .skip_while(|x| x.0.end > pos)
+            .skip_while(|x| x.0.end + offset > pos)
             .take_while(|x| {
                 matches!(
                     x.1,
@@ -187,10 +181,7 @@ impl Completer for CommandCompletion {
         let subcommands = if let Some(last) = last {
             self.complete_commands(
                 working_set,
-                Span {
+                Span::new(last.0.start, pos),
-                    start: last.0.start,
-                    end: pos,
-                },
                 offset,
                 false,
                 options.match_algorithm,

crates/nu-cli/src/completions/completer.rs

@@ -77,10 +77,7 @@ impl NuCompleter {
                     Value::List {
                         vals: spans
                             .iter()
-                            .map(|it| Value::String {
+                            .map(|it| Value::string(it, Span::unknown()))
-                                val: it.to_string(),
-                                span: Span::unknown(),
-                            })
                             .collect(),
                         span: Span::unknown(),
                     },
@@ -92,7 +89,7 @@ impl NuCompleter {
             &self.engine_state,
             &mut callee_stack,
             block,
-            PipelineData::new(span),
+            PipelineData::empty(),
             true,
             true,
         );
@@ -101,30 +98,31 @@ impl NuCompleter {
             Ok(pd) => {
                 let value = pd.into_value(span);
                 if let Value::List { vals, span: _ } = value {
-                    let result = map_value_completions(
+                    let result =
-                        vals.iter(),
+                        map_value_completions(vals.iter(), Span::new(span.start, span.end), offset);
-                        Span {
-                            start: span.start,
-                            end: span.end,
-                        },
-                        offset,
-                    );
 
                     return Some(result);
                 }
             }
-            Err(err) => println!("failed to eval completer block: {}", err),
+            Err(err) => println!("failed to eval completer block: {err}"),
         }
 
         None
     }
 
     fn completion_helper(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
+        // pos: is the position of the cursor in the shell input.
+        // e.g. lets say you have an alias -> `alias ll = ls -l` and you type in the shell:
+        // > ll -a | c
+        // and your cursor is right after `c` then `pos` = 9
+
         let mut working_set = StateWorkingSet::new(&self.engine_state);
-        let offset = working_set.next_span_start();
+        let mut offset = working_set.next_span_start();
         let (mut new_line, alias_offset) = try_find_alias(line.as_bytes(), &working_set);
-        let initial_line = line.to_string();
+        // new_line: vector containing all alias "translations" so if it was `ll` now is `ls -l`.
-        let alias_total_offset: usize = alias_offset.iter().sum();
+        // alias_offset:vector the offset between the name and the alias)
+        let initial_line = line.to_string(); // Entire line in the shell input.
+        let alias_total_offset: usize = alias_offset.iter().sum(); // the sum of all alias offsets.
         new_line.insert(alias_total_offset + pos, b'a');
         let pos = offset + pos;
         let config = self.engine_state.get_config();
@@ -137,7 +135,8 @@ impl NuCompleter {
                     PipelineElement::Expression(_, expr)
                     | PipelineElement::Redirection(_, _, expr)
                     | PipelineElement::And(_, expr)
-                    | PipelineElement::Or(_, expr) => {
+                    | PipelineElement::Or(_, expr)
+                    | PipelineElement::SeparateRedirection { out: (_, expr), .. } => {
                         let flattened: Vec<_> = flatten_expression(&working_set, &expr);
                         let span_offset: usize = alias_offset.iter().sum();
                         let mut spans: Vec<String> = vec![];
@@ -164,17 +163,22 @@ impl NuCompleter {
                                     most_left_variable(flat_idx, &working_set, flattened.clone());
 
                                 // Create a new span
-                                let new_span = if flat_idx == 0 {
+                                // if flat_idx == 0
-                                    Span {
+                                let mut span_start = flat.0.start;
-                                        start: flat.0.start,
+                                let mut span_end = flat.0.end - 1 - span_offset;
-                                        end: flat.0.end - 1 - span_offset,
+
-                                    }
+                                if flat_idx != 0 {
-                                } else {
+                                    span_start = flat.0.start - span_offset;
-                                    Span {
+                                    span_end = flat.0.end - 1 - span_offset;
-                                        start: flat.0.start - span_offset,
+                                }
-                                        end: flat.0.end - 1 - span_offset,
+
-                                    }
+                                if span_end < span_start {
-                                };
+                                    span_start = flat.0.start;
+                                    span_end = flat.0.end - 1;
+                                    offset += span_offset
+                                }
+
+                                let new_span = Span::new(span_start, span_end);
 
                                 // Parses the prefix. Completion should look up to the cursor position, not after.
                                 let mut prefix = working_set.get_span_contents(flat.0).to_vec();
@@ -189,6 +193,10 @@ impl NuCompleter {
                                         most_left_var.unwrap_or((vec![], vec![])),
                                     );
 
+                                    if offset > new_span.start {
+                                        offset -= span_offset;
+                                    }
+
                                     return self.process_completion(
                                         &mut completer,
                                         &working_set,

crates/nu-cli/src/completions/custom_completions.rs

@@ -52,13 +52,13 @@ impl Completer for CustomCompletion {
                 head: span,
                 arguments: vec![
                     Argument::Positional(Expression {
-                        span: Span { start: 0, end: 0 },
+                        span: Span::unknown(),
                         ty: Type::String,
                         expr: Expr::String(self.line.clone()),
                         custom_completion: None,
                     }),
                     Argument::Positional(Expression {
-                        span: Span { start: 0, end: 0 },
+                        span: Span::unknown(),
                         ty: Type::Int,
                         expr: Expr::Int(line_pos as i64),
                         custom_completion: None,
@@ -66,15 +66,16 @@ impl Completer for CustomCompletion {
                 ],
                 redirect_stdout: true,
                 redirect_stderr: true,
+                parser_info: vec![],
             },
-            PipelineData::new(span),
+            PipelineData::empty(),
         );
 
         let mut custom_completion_options = None;
 
         // Parse result
-        let suggestions = match result {
+        let suggestions = result
-            Ok(pd) => {
+            .map(|pd| {
                 let value = pd.into_value(span);
                 match &value {
                     Value::Record { .. } => {
@@ -131,9 +132,8 @@ impl Completer for CustomCompletion {
                     Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
                     _ => vec![],
                 }
-            }
+            })
-            _ => vec![],
+            .unwrap_or_default();
-        };
 
         if let Some(custom_completion_options) = custom_completion_options {
             filter(&prefix, suggestions, &custom_completion_options)

crates/nu-cli/src/completions/directory_completions.rs

@@ -33,14 +33,7 @@ impl Completer for DirectoryCompletion {
         _: usize,
         options: &CompletionOptions,
     ) -> Vec<Suggestion> {
-        let cwd = if let Some(d) = self.engine_state.get_env_var("PWD") {
+        let cwd = self.engine_state.current_work_dir();
-            match d.as_string() {
-                Ok(s) => s,
-                Err(_) => "".to_string(),
-            }
-        } else {
-            "".to_string()
-        };
         let partial = String::from_utf8_lossy(&prefix).to_string();
 
         // Filter only the folders
@@ -126,7 +119,7 @@ pub fn directory_completion(
                             let mut file_name = entry.file_name().to_string_lossy().into_owned();
                             if matches(&partial, &file_name, options) {
                                 let mut path = if prepend_base_dir(original_input, &base_dir_name) {
-                                    format!("{}{}", base_dir_name, file_name)
+                                    format!("{base_dir_name}{file_name}")
                                 } else {
                                     file_name.to_string()
                                 };
@@ -136,9 +129,13 @@ pub fn directory_completion(
                                     file_name.push(SEP);
                                 }
 
-                                // Fix files or folders with quotes
+                                // Fix files or folders with quotes or hash
-                                if path.contains('\'') || path.contains('"') || path.contains(' ') {
+                                if path.contains('\'')
-                                    path = format!("`{}`", path);
+                                    || path.contains('"')
+                                    || path.contains(' ')
+                                    || path.contains('#')
+                                {
+                                    path = format!("`{path}`");
                                 }
 
                                 Some((span, path))

crates/nu-cli/src/completions/dotnu_completions.rs

@@ -58,7 +58,7 @@ impl Completer for DotNuCompletion {
             };
 
         // Check if the base_dir is a folder
-        if base_dir != format!(".{}", SEP) {
+        if base_dir != format!(".{SEP}") {
             // Add the base dir into the directories to be searched
             search_dirs.push(base_dir.clone());
 
@@ -70,14 +70,7 @@ impl Completer for DotNuCompletion {
             partial = base_dir_partial;
         } else {
             // Fetch the current folder
-            let current_folder = if let Some(d) = self.engine_state.get_env_var("PWD") {
+            let current_folder = self.engine_state.current_work_dir();
-                match d.as_string() {
-                    Ok(s) => s,
-                    Err(_) => "".to_string(),
-                }
-            } else {
-                "".to_string()
-            };
             is_current_folder = true;
 
             // Add the current folder and the lib dirs into the

crates/nu-cli/src/completions/file_completions.rs

@@ -30,14 +30,7 @@ impl Completer for FileCompletion {
         _: usize,
         options: &CompletionOptions,
     ) -> Vec<Suggestion> {
-        let cwd = if let Some(d) = self.engine_state.get_env_var("PWD") {
+        let cwd = self.engine_state.current_work_dir();
-            match d.as_string() {
-                Ok(s) => s,
-                Err(_) => "".to_string(),
-            }
-        } else {
-            "".to_string()
-        };
         let prefix = String::from_utf8_lossy(&prefix).to_string();
         let output: Vec<_> = file_path_completion(span, &prefix, &cwd, options)
             .into_iter()
@@ -131,7 +124,7 @@ pub fn file_path_completion(
                     let mut file_name = entry.file_name().to_string_lossy().into_owned();
                     if matches(&partial, &file_name, options) {
                         let mut path = if prepend_base_dir(original_input, &base_dir_name) {
-                            format!("{}{}", base_dir_name, file_name)
+                            format!("{base_dir_name}{file_name}")
                         } else {
                             file_name.to_string()
                         };
@@ -141,9 +134,15 @@ pub fn file_path_completion(
                             file_name.push(SEP);
                         }
 
-                        // Fix files or folders with quotes
+                        // Fix files or folders with quotes or hashes
-                        if path.contains('\'') || path.contains('"') || path.contains(' ') {
+                        if path.contains('\'')
-                            path = format!("`{}`", path);
+                            || path.contains('"')
+                            || path.contains(' ')
+                            || path.contains('#')
+                            || path.contains('(')
+                            || path.contains(')')
+                        {
+                            path = format!("`{path}`");
                         }
 
                         Some((span, path))
@@ -171,7 +170,7 @@ pub fn matches(partial: &str, from: &str, options: &CompletionOptions) -> bool {
 
 /// Returns whether the base_dir should be prepended to the file path
 pub fn prepend_base_dir(input: &str, base_dir: &str) -> bool {
-    if base_dir == format!(".{}", SEP) {
+    if base_dir == format!(".{SEP}") {
         // if the current base_dir path is the local folder we only add a "./" prefix if the user
         // input already includes a local folder prefix.
         let manually_entered = {

crates/nu-cli/src/completions/variable_completions.rs

@@ -9,6 +9,8 @@ use reedline::Suggestion;
 use std::str;
 use std::sync::Arc;
 
+use super::MatchAlgorithm;
+
 #[derive(Clone)]
 pub struct VariableCompletion {
     engine_state: Arc<EngineState>, // TODO: Is engine state necessary? It's already a part of working set in fetch()
@@ -73,10 +75,11 @@ impl Completer for VariableCompletion {
                         for suggestion in
                             nested_suggestions(val.clone(), nested_levels, current_span)
                         {
-                            if options
+                            if options.match_algorithm.matches_u8_insensitive(
-                                .match_algorithm
+                                options.case_sensitive,
-                                .matches_u8(suggestion.value.as_bytes(), &prefix)
+                                suggestion.value.as_bytes(),
-                            {
+                                &prefix,
+                            ) {
                                 output.push(suggestion);
                             }
                         }
@@ -86,10 +89,11 @@ impl Completer for VariableCompletion {
                 } else {
                     // No nesting provided, return all env vars
                     for env_var in env_vars {
-                        if options
+                        if options.match_algorithm.matches_u8_insensitive(
-                            .match_algorithm
+                            options.case_sensitive,
-                            .matches_u8(env_var.0.as_bytes(), &prefix)
+                            env_var.0.as_bytes(),
-                        {
+                            &prefix,
+                        ) {
                             output.push(Suggestion {
                                 value: env_var.0,
                                 description: None,
@@ -111,18 +115,16 @@ impl Completer for VariableCompletion {
                     &self.engine_state,
                     &self.stack,
                     nu_protocol::NU_VARIABLE_ID,
-                    nu_protocol::Span {
+                    nu_protocol::Span::new(current_span.start, current_span.end),
-                        start: current_span.start,
-                        end: current_span.end,
-                    },
                 ) {
                     for suggestion in
                         nested_suggestions(nuval, self.var_context.1.clone(), current_span)
                     {
-                        if options
+                        if options.match_algorithm.matches_u8_insensitive(
-                            .match_algorithm
+                            options.case_sensitive,
-                            .matches_u8(suggestion.value.as_bytes(), &prefix)
+                            suggestion.value.as_bytes(),
-                        {
+                            &prefix,
+                        ) {
                             output.push(suggestion);
                         }
                     }
@@ -134,23 +136,18 @@ impl Completer for VariableCompletion {
             // Completion other variable types
             if let Some(var_id) = var_id {
                 // Extract the variable value from the stack
-                let var = self.stack.get_var(
+                let var = self.stack.get_var(var_id, Span::new(span.start, span.end));
-                    var_id,
-                    Span {
-                        start: span.start,
-                        end: span.end,
-                    },
-                );
 
                 // If the value exists and it's of type Record
                 if let Ok(value) = var {
                     for suggestion in
                         nested_suggestions(value, self.var_context.1.clone(), current_span)
                     {
-                        if options
+                        if options.match_algorithm.matches_u8_insensitive(
-                            .match_algorithm
+                            options.case_sensitive,
-                            .matches_u8(suggestion.value.as_bytes(), &prefix)
+                            suggestion.value.as_bytes(),
-                        {
+                            &prefix,
+                        ) {
                             output.push(suggestion);
                         }
                     }
@@ -162,10 +159,11 @@ impl Completer for VariableCompletion {
 
         // Variable completion (e.g: $en<tab> to complete $env)
         for builtin in builtins {
-            if options
+            if options.match_algorithm.matches_u8_insensitive(
-                .match_algorithm
+                options.case_sensitive,
-                .matches_u8(builtin.as_bytes(), &prefix)
+                builtin.as_bytes(),
-            {
+                &prefix,
+            ) {
                 output.push(Suggestion {
                     value: builtin.to_string(),
                     description: None,
@@ -187,7 +185,11 @@ impl Completer for VariableCompletion {
                 .rev()
             {
                 for v in &overlay_frame.vars {
-                    if options.match_algorithm.matches_u8(v.0, &prefix) {
+                    if options.match_algorithm.matches_u8_insensitive(
+                        options.case_sensitive,
+                        v.0,
+                        &prefix,
+                    ) {
                         output.push(Suggestion {
                             value: String::from_utf8_lossy(v.0).to_string(),
                             description: None,
@@ -209,7 +211,11 @@ impl Completer for VariableCompletion {
             .rev()
         {
             for v in &overlay_frame.vars {
-                if options.match_algorithm.matches_u8(v.0, &prefix) {
+                if options.match_algorithm.matches_u8_insensitive(
+                    options.case_sensitive,
+                    v.0,
+                    &prefix,
+                ) {
                     output.push(Suggestion {
                         value: String::from_utf8_lossy(v.0).to_string(),
                         description: None,
@@ -256,6 +262,20 @@ fn nested_suggestions(
 
             output
         }
+        Value::LazyRecord { val, .. } => {
+            // Add all the columns as completion
+            for column_name in val.column_names() {
+                output.push(Suggestion {
+                    value: column_name.to_string(),
+                    description: None,
+                    extra: None,
+                    span: current_span,
+                    append_whitespace: false,
+                });
+            }
+
+            output
+        }
 
         _ => output,
     }
@@ -281,7 +301,7 @@ fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
 
                 // Current sublevel value not found
                 return Value::Nothing {
-                    span: Span { start: 0, end: 0 },
+                    span: Span::unknown(),
                 };
             }
             _ => return val,
@@ -290,3 +310,13 @@ fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
 
     val
 }
+
+impl MatchAlgorithm {
+    pub fn matches_u8_insensitive(&self, sensitive: bool, haystack: &[u8], needle: &[u8]) -> bool {
+        if sensitive {
+            self.matches_u8(haystack, needle)
+        } else {
+            self.matches_u8(&haystack.to_ascii_lowercase(), &needle.to_ascii_lowercase())
+        }
+    }
+}

crates/nu-cli/src/config_files.rs

@@ -1,14 +1,14 @@
 use crate::util::{eval_source, report_error};
 #[cfg(feature = "plugin")]
-use log::info;
-#[cfg(feature = "plugin")]
 use nu_parser::ParseError;
 #[cfg(feature = "plugin")]
 use nu_path::canonicalize_with;
 use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
 #[cfg(feature = "plugin")]
 use nu_protocol::Spanned;
-use nu_protocol::{HistoryFileFormat, PipelineData, Span};
+use nu_protocol::{HistoryFileFormat, PipelineData};
+#[cfg(feature = "plugin")]
+use nu_utils::utils::perf;
 use std::path::PathBuf;
 
 #[cfg(feature = "plugin")]
@@ -24,6 +24,8 @@ pub fn read_plugin_file(
     plugin_file: Option<Spanned<String>>,
     storage_path: &str,
 ) {
+    let start_time = std::time::Instant::now();
+    let mut plug_path = String::new();
     // Reading signatures from signature file
     // The plugin.nu file stores the parsed signature collected from each registered plugin
     add_plugin_file(engine_state, plugin_file, storage_path);
@@ -31,19 +33,25 @@ pub fn read_plugin_file(
     let plugin_path = engine_state.plugin_signatures.clone();
     if let Some(plugin_path) = plugin_path {
         let plugin_filename = plugin_path.to_string_lossy();
-
+        plug_path = plugin_filename.to_string();
         if let Ok(contents) = std::fs::read(&plugin_path) {
             eval_source(
                 engine_state,
                 stack,
                 &contents,
                 &plugin_filename,
-                PipelineData::new(Span::new(0, 0)),
+                PipelineData::empty(),
             );
         }
     }
 
-    info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    perf(
+        &format!("read_plugin_file {}", &plug_path),
+        start_time,
+        file!(),
+        line!(),
+        column!(),
+    );
 }
 
 #[cfg(feature = "plugin")]
@@ -56,12 +64,11 @@ pub fn add_plugin_file(
         let working_set = StateWorkingSet::new(engine_state);
         let cwd = working_set.get_cwd();
 
-        match canonicalize_with(&plugin_file.item, cwd) {
+        if let Ok(path) = canonicalize_with(&plugin_file.item, cwd) {
-            Ok(path) => engine_state.plugin_signatures = Some(path),
+            engine_state.plugin_signatures = Some(path)
-            Err(_) => {
+        } else {
-                let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
+            let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
-                report_error(&working_set, &e);
+            report_error(&working_set, &e);
-            }
         }
     } else if let Some(mut plugin_path) = nu_path::config_dir() {
         // Path to store plugins signatures
@@ -85,7 +92,7 @@ pub fn eval_config_contents(
                 stack,
                 &contents,
                 &config_filename,
-                PipelineData::new(Span::new(0, 0)),
+                PipelineData::empty(),
             );
 
             // Merge the environment in case env vars changed in the config

crates/nu-cli/src/eval_file.rs

@@ -2,13 +2,13 @@ use crate::util::{eval_source, report_error};
 use log::info;
 use log::trace;
 use miette::{IntoDiagnostic, Result};
-use nu_engine::convert_env_values;
+use nu_engine::{convert_env_values, current_dir};
 use nu_parser::parse;
-use nu_protocol::Type;
+use nu_path::canonicalize_with;
 use nu_protocol::{
     ast::Call,
     engine::{EngineState, Stack, StateWorkingSet},
-    Config, PipelineData, Span, Value,
+    Config, PipelineData, ShellError, Span, Type, Value,
 };
 use nu_utils::stdout_write_all_and_flush;
 
@@ -27,14 +27,75 @@ pub fn evaluate_file(
         std::process::exit(1);
     }
 
-    let file = std::fs::read(&path).into_diagnostic()?;
+    let cwd = current_dir(engine_state, stack)?;
 
-    engine_state.start_in_file(Some(&path));
+    let file_path = canonicalize_with(&path, cwd).unwrap_or_else(|e| {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::FileNotFoundCustom(
+                format!("Could not access file '{}': {:?}", path, e.to_string()),
+                Span::unknown(),
+            ),
+        );
+        std::process::exit(1);
+    });
+
+    let file_path_str = file_path.to_str().unwrap_or_else(|| {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::NonUtf8Custom(
+                format!(
+                    "Input file name '{}' is not valid UTF8",
+                    file_path.to_string_lossy()
+                ),
+                Span::unknown(),
+            ),
+        );
+        std::process::exit(1);
+    });
+
+    let file = std::fs::read(&file_path)
+        .into_diagnostic()
+        .unwrap_or_else(|e| {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(
+                &working_set,
+                &ShellError::FileNotFoundCustom(
+                    format!(
+                        "Could not read file '{}': {:?}",
+                        file_path_str,
+                        e.to_string()
+                    ),
+                    Span::unknown(),
+                ),
+            );
+            std::process::exit(1);
+        });
+
+    engine_state.start_in_file(Some(file_path_str));
+
+    let parent = file_path.parent().unwrap_or_else(|| {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::FileNotFoundCustom(
+                format!("The file path '{file_path_str}' does not have a parent"),
+                Span::unknown(),
+            ),
+        );
+        std::process::exit(1);
+    });
+
+    stack.add_env_var(
+        "FILE_PWD".to_string(),
+        Value::string(parent.to_string_lossy(), Span::unknown()),
+    );
 
     let mut working_set = StateWorkingSet::new(engine_state);
-    trace!("parsing file: {}", path);
+    trace!("parsing file: {}", file_path_str);
-
+    let _ = parse(&mut working_set, Some(file_path_str), &file, false, &[]);
-    let _ = parse(&mut working_set, Some(&path), &file, false, &[]);
 
     if working_set.find_decl(b"main", &Type::Any).is_some() {
         let args = format!("main {}", args.join(" "));
@@ -43,15 +104,15 @@ pub fn evaluate_file(
             engine_state,
             stack,
             &file,
-            &path,
+            file_path_str,
-            PipelineData::new(Span::new(0, 0)),
+            PipelineData::empty(),
         ) {
             std::process::exit(1);
         }
         if !eval_source(engine_state, stack, args.as_bytes(), "<commandline>", input) {
             std::process::exit(1);
         }
-    } else if !eval_source(engine_state, stack, &file, &path, input) {
+    } else if !eval_source(engine_state, stack, &file, file_path_str, input) {
         std::process::exit(1);
     }
 
@@ -60,7 +121,7 @@ pub fn evaluate_file(
     Ok(())
 }
 
-pub fn print_table_or_error(
+pub(crate) fn print_table_or_error(
     engine_state: &mut EngineState,
     stack: &mut Stack,
     mut pipeline_data: PipelineData,
@@ -76,43 +137,36 @@ pub fn print_table_or_error(
 
     if let PipelineData::Value(Value::Error { error }, ..) = &pipeline_data {
         let working_set = StateWorkingSet::new(engine_state);
-
         report_error(&working_set, error);
-
         std::process::exit(1);
     }
 
-    match engine_state.find_decl("table".as_bytes(), &[]) {
+    if let Some(decl_id) = engine_state.find_decl("table".as_bytes(), &[]) {
-        Some(decl_id) => {
+        let command = engine_state.get_decl(decl_id);
-            let command = engine_state.get_decl(decl_id);
+        if command.get_block_id().is_some() {
-            if command.get_block_id().is_some() {
+            print_or_exit(pipeline_data, engine_state, config);
-                print_or_exit(pipeline_data, engine_state, config);
+        } else {
-            } else {
+            let table = command.run(
-                let table = command.run(
+                engine_state,
-                    engine_state,
+                stack,
-                    stack,
+                &Call::new(Span::new(0, 0)),
-                    &Call::new(Span::new(0, 0)),
+                pipeline_data,
-                    pipeline_data,
+            );
-                );
 
-                match table {
+            match table {
-                    Ok(table) => {
+                Ok(table) => {
-                        print_or_exit(table, engine_state, config);
+                    print_or_exit(table, engine_state, config);
-                    }
+                }
-                    Err(error) => {
+                Err(error) => {
-                        let working_set = StateWorkingSet::new(engine_state);
+                    let working_set = StateWorkingSet::new(engine_state);
-
+                    report_error(&working_set, &error);
-                        report_error(&working_set, &error);
+                    std::process::exit(1);
-
-                        std::process::exit(1);
-                    }
                 }
             }
         }
-        None => {
+    } else {
-            print_or_exit(pipeline_data, engine_state, config);
+        print_or_exit(pipeline_data, engine_state, config);
-        }
+    }
-    };
 
     // Make sure everything has finished
     if let Some(exit_code) = exit_code {
@@ -138,9 +192,7 @@ fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, co
             std::process::exit(1);
         }
 
-        let mut out = item.into_string("\n", config);
+        let out = item.into_string("\n", config) + "\n";
-        out.push('\n');
+        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{err}"));
-
-        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
     }
 }

crates/nu-cli/src/menus/description_menu.rs

@@ -411,10 +411,10 @@ impl DescriptionMenu {
                             RESET
                         )
                     } else {
-                        format!("  {}\r\n", example)
+                        format!("  {example}\r\n")
                     }
                 } else {
-                    format!("  {}\r\n", example)
+                    format!("  {example}\r\n")
                 }
             })
             .collect();
@@ -429,7 +429,7 @@ impl DescriptionMenu {
                 examples,
             )
         } else {
-            format!("\r\n\r\nExamples:\r\n{}", examples,)
+            format!("\r\n\r\nExamples:\r\n{examples}",)
         }
     }
 }

crates/nu-cli/src/menus/menu_completions.rs

@@ -42,20 +42,14 @@ impl Completer for NuMenuCompleter {
 
         if let Some(buffer) = block.signature.get_positional(0) {
             if let Some(buffer_id) = &buffer.var_id {
-                let line_buffer = Value::String {
+                let line_buffer = Value::string(parsed.remainder, self.span);
-                    val: parsed.remainder.to_string(),
-                    span: self.span,
-                };
                 self.stack.add_var(*buffer_id, line_buffer);
             }
         }
 
         if let Some(position) = block.signature.get_positional(1) {
             if let Some(position_id) = &position.var_id {
-                let line_buffer = Value::Int {
+                let line_buffer = Value::int(pos as i64, self.span);
-                    val: pos as i64,
-                    span: self.span,
-                };
                 self.stack.add_var(*position_id, line_buffer);
             }
         }
@@ -87,13 +81,10 @@ fn convert_to_suggestions(
 ) -> Vec<Suggestion> {
     match value {
         Value::Record { .. } => {
-            let text = match value
+            let text = value
                 .get_data_by_key("value")
                 .and_then(|val| val.as_string().ok())
-            {
+                .unwrap_or_else(|| "No value key".to_string());
-                Some(val) => val,
-                None => "No value key".to_string(),
-            };
 
             let description = value
                 .get_data_by_key("description")
@@ -163,7 +154,7 @@ fn convert_to_suggestions(
             .flat_map(|val| convert_to_suggestions(val, line, pos, only_buffer_difference))
             .collect(),
         _ => vec![Suggestion {
-            value: format!("Not a record: {:?}", value),
+            value: format!("Not a record: {value:?}"),
             description: None,
             extra: None,
             span: reedline::Span {

crates/nu-cli/src/nu_highlight.rs

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Value};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Type, Value};
 use reedline::Highlighter;
 
 #[derive(Clone)]
@@ -12,7 +12,9 @@ impl Command for NuHighlight {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("nu-highlight").category(Category::Strings)
+        Signature::build("nu-highlight")
+            .category(Category::Strings)
+            .input_output_types(vec![(Type::String, Type::String)])
     }
 
     fn usage(&self) -> &str {
@@ -33,7 +35,7 @@ impl Command for NuHighlight {
         let head = call.head;
 
         let ctrlc = engine_state.ctrlc.clone();
-        let engine_state = engine_state.clone();
+        let engine_state = std::sync::Arc::new(engine_state.clone());
         let config = engine_state.get_config().clone();
 
         let highlighter = crate::NuHighlighter {

crates/nu-cli/src/print.rs

@@ -2,7 +2,8 @@ use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Type,
+    Value,
 };
 
 #[derive(Clone)]
@@ -15,6 +16,7 @@ impl Command for Print {
 
     fn signature(&self) -> Signature {
         Signature::build("print")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
             .rest("rest", SyntaxShape::Any, "the values to print")
             .switch(
                 "no-newline",
@@ -50,14 +52,13 @@ Since this command has no output, there is no point in piping it with other comm
         let args: Vec<Value> = call.rest(engine_state, stack, 0)?;
         let no_newline = call.has_flag("no-newline");
         let to_stderr = call.has_flag("stderr");
-        let head = call.head;
 
         for arg in args {
             arg.into_pipeline_data()
                 .print(engine_state, stack, no_newline, to_stderr)?;
         }
 
-        Ok(PipelineData::new(head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

crates/nu-cli/src/prompt.rs

@@ -91,7 +91,7 @@ impl NushellPrompt {
     }
 
     fn default_wrapped_custom_string(&self, str: String) -> String {
-        format!("({})", str)
+        format!("({str})")
     }
 }
 
@@ -105,7 +105,7 @@ impl Prompt for NushellPrompt {
         if let Some(prompt_string) = &self.left_prompt_string {
             prompt_string.replace('\n', "\r\n").into()
         } else {
-            let default = DefaultPrompt::new();
+            let default = DefaultPrompt::default();
             default
                 .render_prompt_left()
                 .to_string()
@@ -118,7 +118,7 @@ impl Prompt for NushellPrompt {
         if let Some(prompt_string) = &self.right_prompt_string {
             prompt_string.replace('\n', "\r\n").into()
         } else {
-            let default = DefaultPrompt::new();
+            let default = DefaultPrompt::default();
             default
                 .render_prompt_right()
                 .to_string()
@@ -130,32 +130,36 @@ impl Prompt for NushellPrompt {
     fn render_prompt_indicator(&self, edit_mode: PromptEditMode) -> Cow<str> {
         match edit_mode {
             PromptEditMode::Default => match &self.default_prompt_indicator {
-                Some(indicator) => indicator.as_str().into(),
+                Some(indicator) => indicator,
-                None => "〉".into(),
+                None => "〉",
-            },
+            }
+            .into(),
             PromptEditMode::Emacs => match &self.default_prompt_indicator {
-                Some(indicator) => indicator.as_str().into(),
+                Some(indicator) => indicator,
-                None => "〉".into(),
+                None => "〉",
-            },
+            }
+            .into(),
             PromptEditMode::Vi(vi_mode) => match vi_mode {
                 PromptViMode::Normal => match &self.default_vi_normal_prompt_indicator {
-                    Some(indicator) => indicator.as_str().into(),
+                    Some(indicator) => indicator,
-                    None => ": ".into(),
+                    None => ": ",
                 },
                 PromptViMode::Insert => match &self.default_vi_insert_prompt_indicator {
-                    Some(indicator) => indicator.as_str().into(),
+                    Some(indicator) => indicator,
-                    None => "〉".into(),
+                    None => "〉",
                 },
-            },
+            }
+            .into(),
             PromptEditMode::Custom(str) => self.default_wrapped_custom_string(str).into(),
         }
     }
 
     fn render_prompt_multiline_indicator(&self) -> Cow<str> {
         match &self.default_multiline_indicator {
-            Some(indicator) => indicator.as_str().into(),
+            Some(indicator) => indicator,
-            None => "::: ".into(),
+            None => "::: ",
         }
+        .into()
     }
 
     fn render_prompt_history_search_indicator(

crates/nu-cli/src/prompt_update.rs

@@ -1,10 +1,10 @@
 use crate::util::report_error;
 use crate::NushellPrompt;
-use log::info;
+use log::trace;
 use nu_engine::eval_subexpression;
 use nu_protocol::{
     engine::{EngineState, Stack, StateWorkingSet},
-    Config, PipelineData, Span, Value,
+    Config, PipelineData, Value,
 };
 use reedline::Prompt;
 
@@ -37,52 +37,39 @@ fn get_prompt_string(
                 let block = engine_state.get_block(block_id);
                 let mut stack = stack.captures_to_stack(&captures);
                 // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
-                let ret_val = eval_subexpression(
+                let ret_val =
-                    engine_state,
+                    eval_subexpression(engine_state, &mut stack, block, PipelineData::empty());
-                    &mut stack,
+                trace!(
-                    block,
-                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
-                );
-                info!(
                     "get_prompt_string (block) {}:{}:{}",
                     file!(),
                     line!(),
                     column!()
                 );
 
-                match ret_val {
+                ret_val
-                    Ok(ret_val) => Some(ret_val),
+                    .map_err(|err| {
-                    Err(err) => {
                         let working_set = StateWorkingSet::new(engine_state);
                         report_error(&working_set, &err);
-                        None
+                    })
-                    }
+                    .ok()
-                }
             }
             Value::Block { val: block_id, .. } => {
                 let block = engine_state.get_block(block_id);
                 // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
-                let ret_val = eval_subexpression(
+                let ret_val = eval_subexpression(engine_state, stack, block, PipelineData::empty());
-                    engine_state,
+                trace!(
-                    stack,
-                    block,
-                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
-                );
-                info!(
                     "get_prompt_string (block) {}:{}:{}",
                     file!(),
                     line!(),
                     column!()
                 );
 
-                match ret_val {
+                ret_val
-                    Ok(ret_val) => Some(ret_val),
+                    .map_err(|err| {
-                    Err(err) => {
                         let working_set = StateWorkingSet::new(engine_state);
                         report_error(&working_set, &err);
-                        None
+                    })
-                    }
+                    .ok()
-                }
             }
             Value::String { .. } => Some(PipelineData::Value(v.clone(), None)),
             _ => None,
@@ -90,20 +77,17 @@ fn get_prompt_string(
         .and_then(|pipeline_data| {
             let output = pipeline_data.collect_string("", config).ok();
 
-            match output {
+            output.map(|mut x| {
-                Some(mut x) => {
+                // Just remove the very last newline.
-                    // Just remove the very last newline.
+                if x.ends_with('\n') {
-                    if x.ends_with('\n') {
+                    x.pop();
-                        x.pop();
-                    }
-
-                    if x.ends_with('\r') {
-                        x.pop();
-                    }
-                    Some(x)
                 }
-                None => None,
+
-            }
+                if x.ends_with('\r') {
+                    x.pop();
+                }
+                x
+            })
         })
 }
 
@@ -120,12 +104,12 @@ pub(crate) fn update_prompt<'prompt>(
     // Now that we have the prompt string lets ansify it.
     // <133 A><prompt><133 B><command><133 C><command output>
     let left_prompt_string = if config.shell_integration {
-        match left_prompt_string {
+        if let Some(prompt_string) = left_prompt_string {
-            Some(prompt_string) => Some(format!(
+            Some(format!(
-                "{}{}{}",
+                "{PRE_PROMPT_MARKER}{prompt_string}{POST_PROMPT_MARKER}"
-                PRE_PROMPT_MARKER, prompt_string, POST_PROMPT_MARKER
+            ))
-            )),
+        } else {
-            None => left_prompt_string,
+            left_prompt_string
         }
     } else {
         left_prompt_string
@@ -157,7 +141,7 @@ pub(crate) fn update_prompt<'prompt>(
     );
 
     let ret_val = nu_prompt as &dyn Prompt;
-    info!("update_prompt {}:{}:{}", file!(), line!(), column!());
+    trace!("update_prompt {}:{}:{}", file!(), line!(), column!());
 
     ret_val
 }

crates/nu-cli/src/reedline_config.rs

@@ -1,14 +1,13 @@
 use super::DescriptionMenu;
 use crate::{menus::NuMenuCompleter, NuHelpCompleter};
 use crossterm::event::{KeyCode, KeyModifiers};
-use nu_color_config::lookup_ansi_color_style;
+use nu_color_config::{color_record_to_nustyle, lookup_ansi_color_style};
 use nu_engine::eval_block;
 use nu_parser::parse;
 use nu_protocol::{
-    color_value_string, create_menus,
+    create_menus,
     engine::{EngineState, Stack, StateWorkingSet},
-    extract_value, Config, IntoPipelineData, ParsedKeybinding, ParsedMenu, PipelineData,
+    extract_value, Config, ParsedKeybinding, ParsedMenu, PipelineData, ShellError, Span, Value,
-    ShellError, Span, Value,
 };
 use reedline::{
     default_emacs_keybindings, default_vi_insert_keybindings, default_vi_normal_keybindings,
@@ -110,7 +109,7 @@ pub(crate) fn add_menus(
             };
 
             let mut temp_stack = Stack::new();
-            let input = Value::nothing(Span::test_data()).into_pipeline_data();
+            let input = PipelineData::Empty;
             let res = eval_block(&engine_state, &mut temp_stack, &block, input, false, false)?;
 
             if let PipelineData::Value(value, None) = res {
@@ -159,14 +158,11 @@ macro_rules! add_style {
     ($name:expr, $cols: expr, $vals:expr, $span:expr, $config: expr, $menu:expr, $f:expr) => {
         $menu = match extract_value($name, $cols, $vals, $span) {
             Ok(text) => {
-                let text = match text {
+                let style = match text {
-                    Value::String { val, .. } => val.clone(),
+                    Value::String { val, .. } => lookup_ansi_color_style(&val),
-                    Value::Record { cols, vals, span } => {
+                    Value::Record { .. } => color_record_to_nustyle(&text),
-                        color_value_string(span, cols, vals, $config).into_string("", $config)
+                    _ => lookup_ansi_color_style("green"),
-                    }
-                    _ => "green".to_string(),
                 };
-                let style = lookup_ansi_color_style(&text);
                 $f($menu, style)
             }
             Err(_) => $menu,
@@ -655,14 +651,15 @@ fn add_parsed_keybinding(
             let pos1 = char_iter.next();
             let pos2 = char_iter.next();
 
-            let char = match (pos1, pos2) {
+            let char = if let (Some(char), None) = (pos1, pos2) {
-                (Some(char), None) => Ok(char),
+                char
-                _ => Err(ShellError::UnsupportedConfigValue(
+            } else {
+                return Err(ShellError::UnsupportedConfigValue(
                     "char_<CHAR: unicode codepoint>".to_string(),
                     c.to_string(),
                     keybinding.keycode.span()?,
-                )),
+                ));
-            }?;
+            };
 
             KeyCode::Char(char)
         }
@@ -683,10 +680,10 @@ fn add_parsed_keybinding(
             let fn_num: u8 = c[1..]
                 .parse()
                 .ok()
-                .filter(|num| matches!(num, 1..=12))
+                .filter(|num| matches!(num, 1..=20))
                 .ok_or(ShellError::UnsupportedConfigValue(
-                    "(f1|f2|...|f12)".to_string(),
+                    "(f1|f2|...|f20)".to_string(),
-                    format!("unknown function key: {}", c),
+                    format!("unknown function key: {c}"),
                     keybinding.keycode.span()?,
                 ))?;
             KeyCode::F(fn_num)
@@ -993,10 +990,7 @@ mod test {
     #[test]
     fn test_send_event() {
         let cols = vec!["send".to_string()];
-        let vals = vec![Value::String {
+        let vals = vec![Value::test_string("Enter")];
-            val: "Enter".to_string(),
-            span: Span::test_data(),
-        }];
 
         let span = Span::test_data();
         let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
@@ -1016,10 +1010,7 @@ mod test {
     #[test]
     fn test_edit_event() {
         let cols = vec!["edit".to_string()];
-        let vals = vec![Value::String {
+        let vals = vec![Value::test_string("Clear")];
-            val: "Clear".to_string(),
-            span: Span::test_data(),
-        }];
 
         let span = Span::test_data();
         let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
@@ -1043,14 +1034,8 @@ mod test {
     fn test_send_menu() {
         let cols = vec!["send".to_string(), "name".to_string()];
         let vals = vec![
-            Value::String {
+            Value::test_string("Menu"),
-                val: "Menu".to_string(),
+            Value::test_string("history_menu"),
-                span: Span::test_data(),
-            },
-            Value::String {
-                val: "history_menu".to_string(),
-                span: Span::test_data(),
-            },
         ];
 
         let span = Span::test_data();
@@ -1076,14 +1061,8 @@ mod test {
         // Menu event
         let cols = vec!["send".to_string(), "name".to_string()];
         let vals = vec![
-            Value::String {
+            Value::test_string("Menu"),
-                val: "Menu".to_string(),
+            Value::test_string("history_menu"),
-                span: Span::test_data(),
-            },
-            Value::String {
-                val: "history_menu".to_string(),
-                span: Span::test_data(),
-            },
         ];
 
         let menu_event = Value::Record {
@@ -1094,10 +1073,7 @@ mod test {
 
         // Enter event
         let cols = vec!["send".to_string()];
-        let vals = vec![Value::String {
+        let vals = vec![Value::test_string("Enter")];
-            val: "Enter".to_string(),
-            span: Span::test_data(),
-        }];
 
         let enter_event = Value::Record {
             cols,
@@ -1138,14 +1114,8 @@ mod test {
         // Menu event
         let cols = vec!["send".to_string(), "name".to_string()];
         let vals = vec![
-            Value::String {
+            Value::test_string("Menu"),
-                val: "Menu".to_string(),
+            Value::test_string("history_menu"),
-                span: Span::test_data(),
-            },
-            Value::String {
-                val: "history_menu".to_string(),
-                span: Span::test_data(),
-            },
         ];
 
         let menu_event = Value::Record {
@@ -1156,10 +1126,7 @@ mod test {
 
         // Enter event
         let cols = vec!["send".to_string()];
-        let vals = vec![Value::String {
+        let vals = vec![Value::test_string("Enter")];
-            val: "Enter".to_string(),
-            span: Span::test_data(),
-        }];
 
         let enter_event = Value::Record {
             cols,
@@ -1187,10 +1154,7 @@ mod test {
     #[test]
     fn test_error() {
         let cols = vec!["not_exist".to_string()];
-        let vals = vec![Value::String {
+        let vals = vec![Value::test_string("Enter")];
-            val: "Enter".to_string(),
-            span: Span::test_data(),
-        }];
 
         let span = Span::test_data();
         let b = EventType::try_from_columns(&cols, &vals, &span);

crates/nu-cli/src/repl.rs

@@ -5,20 +5,21 @@ use crate::{
     util::{eval_source, get_guaranteed_cwd, report_error, report_error_new},
     NuHighlighter, NuValidator, NushellPrompt,
 };
-use fancy_regex::Regex;
+use crossterm::cursor::CursorShape;
-use lazy_static::lazy_static;
+use log::{trace, warn};
-use log::{info, trace, warn};
 use miette::{IntoDiagnostic, Result};
-use nu_color_config::get_color_config;
+use nu_color_config::StyleComputer;
 use nu_engine::{convert_env_values, eval_block, eval_block_with_early_return};
 use nu_parser::{lex, parse, trim_quotes_str};
 use nu_protocol::{
     ast::PathMember,
+    config::NuCursorShape,
     engine::{EngineState, ReplOperation, Stack, StateWorkingSet},
     format_duration, BlockId, HistoryFileFormat, PipelineData, PositionalArg, ShellError, Span,
     Spanned, Type, Value, VarId,
 };
-use reedline::{DefaultHinter, EditCommand, Emacs, SqliteBackedHistory, Vi};
+use nu_utils::utils::perf;
+use reedline::{CursorConfig, DefaultHinter, EditCommand, Emacs, SqliteBackedHistory, Vi};
 use std::{
     io::{self, Write},
     sync::atomic::Ordering,
@@ -41,6 +42,7 @@ pub fn evaluate_repl(
     stack: &mut Stack,
     nushell_path: &str,
     prerun_command: Option<Spanned<String>>,
+    entire_start_time: Instant,
 ) -> Result<()> {
     use reedline::{FileBackedHistory, Reedline, Signal};
 
@@ -58,63 +60,47 @@ pub fn evaluate_repl(
 
     let mut nu_prompt = NushellPrompt::new();
 
-    info!(
+    let start_time = std::time::Instant::now();
-        "translate environment vars {}:{}:{}",
-        file!(),
-        line!(),
-        column!()
-    );
-
     // Translate environment variables from Strings to Values
     if let Some(e) = convert_env_values(engine_state, stack) {
         let working_set = StateWorkingSet::new(engine_state);
         report_error(&working_set, &e);
     }
+    perf(
+        "translate env vars",
+        start_time,
+        file!(),
+        line!(),
+        column!(),
+    );
 
     // seed env vars
     stack.add_env_var(
         "CMD_DURATION_MS".into(),
-        Value::String {
+        Value::string("0823", Span::unknown()),
-            val: "0823".to_string(),
-            span: Span { start: 0, end: 0 },
-        },
     );
 
-    stack.add_env_var(
+    stack.add_env_var("LAST_EXIT_CODE".into(), Value::int(0, Span::unknown()));
-        "LAST_EXIT_CODE".into(),
-        Value::Int {
-            val: 0,
-            span: Span { start: 0, end: 0 },
-        },
-    );
-
-    info!(
-        "load config initially {}:{}:{}",
-        file!(),
-        line!(),
-        column!()
-    );
-
-    info!("setup reedline {}:{}:{}", file!(), line!(), column!());
 
+    let mut start_time = std::time::Instant::now();
     let mut line_editor = Reedline::create();
 
     // Now that reedline is created, get the history session id and store it in engine_state
-    let hist_sesh = match line_editor.get_history_session_id() {
+    let hist_sesh = line_editor
-        Some(id) => i64::from(id),
+        .get_history_session_id()
-        None => 0,
+        .map(i64::from)
-    };
+        .unwrap_or(0);
     engine_state.history_session_id = hist_sesh;
+    perf("setup reedline", start_time, file!(), line!(), column!());
 
     let config = engine_state.get_config();
 
+    start_time = std::time::Instant::now();
     let history_path = crate::config_files::get_history_path(
         nushell_path,
         engine_state.config.history_file_format,
     );
     if let Some(history_path) = history_path.as_deref() {
-        info!("setup history {}:{}:{}", file!(), line!(), column!());
-
         let history: Box<dyn reedline::History> = match engine_state.config.history_file_format {
             HistoryFileFormat::PlainText => Box::new(
                 FileBackedHistory::with_file(
@@ -129,7 +115,9 @@ pub fn evaluate_repl(
         };
         line_editor = line_editor.with_history(history);
     };
+    perf("setup history", start_time, file!(), line!(), column!());
 
+    start_time = std::time::Instant::now();
     let sys = sysinfo::System::new();
 
     let show_banner = config.show_banner;
@@ -137,63 +125,89 @@ pub fn evaluate_repl(
     if show_banner {
         let banner = get_banner(engine_state, stack);
         if use_ansi {
-            println!("{}", banner);
+            println!("{banner}");
         } else {
             println!("{}", nu_utils::strip_ansi_string_likely(banner));
         }
     }
+    perf(
+        "get sysinfo/show banner",
+        start_time,
+        file!(),
+        line!(),
+        column!(),
+    );
 
     if let Some(s) = prerun_command {
         eval_source(
             engine_state,
             stack,
             s.item.as_bytes(),
-            &format!("entry #{}", entry_num),
+            &format!("entry #{entry_num}"),
-            PipelineData::new(Span::new(0, 0)),
+            PipelineData::empty(),
         );
         engine_state.merge_env(stack, get_guaranteed_cwd(engine_state, stack))?;
     }
 
     loop {
-        info!(
+        let loop_start_time = std::time::Instant::now();
-            "load config each loop {}:{}:{}",
-            file!(),
-            line!(),
-            column!()
-        );
 
         let cwd = get_guaranteed_cwd(engine_state, stack);
 
+        start_time = std::time::Instant::now();
         // Before doing anything, merge the environment from the previous REPL iteration into the
         // permanent state.
         if let Err(err) = engine_state.merge_env(stack, cwd) {
             report_error_new(engine_state, &err);
         }
+        perf("merge env", start_time, file!(), line!(), column!());
 
+        start_time = std::time::Instant::now();
         //Reset the ctrl-c handler
         if let Some(ctrlc) = &mut engine_state.ctrlc {
             ctrlc.store(false, Ordering::SeqCst);
         }
+        perf("reset ctrlc", start_time, file!(), line!(), column!());
+
+        start_time = std::time::Instant::now();
         // Reset the SIGQUIT handler
         if let Some(sig_quit) = engine_state.get_sig_quit() {
             sig_quit.store(false, Ordering::SeqCst);
         }
+        perf("reset sig_quit", start_time, file!(), line!(), column!());
 
+        start_time = std::time::Instant::now();
         let config = engine_state.get_config();
 
-        info!("setup colors {}:{}:{}", file!(), line!(), column!());
-
-        let color_hm = get_color_config(config);
-
-        info!("update reedline {}:{}:{}", file!(), line!(), column!());
         let engine_reference = std::sync::Arc::new(engine_state.clone());
+
+        // Find the configured cursor shapes for each mode
+        let cursor_config = CursorConfig {
+            vi_insert: Some(map_nucursorshape_to_cursorshape(
+                config.cursor_shape_vi_insert,
+            )),
+            vi_normal: Some(map_nucursorshape_to_cursorshape(
+                config.cursor_shape_vi_normal,
+            )),
+            emacs: Some(map_nucursorshape_to_cursorshape(config.cursor_shape_emacs)),
+        };
+        perf(
+            "get config/cursor config",
+            start_time,
+            file!(),
+            line!(),
+            column!(),
+        );
+
+        start_time = std::time::Instant::now();
+
         line_editor = line_editor
             .with_highlighter(Box::new(NuHighlighter {
-                engine_state: engine_state.clone(),
+                engine_state: engine_reference.clone(),
                 config: config.clone(),
             }))
             .with_validator(Box::new(NuValidator {
-                engine_state: engine_state.clone(),
+                engine_state: engine_reference.clone(),
             }))
             .with_completer(Box::new(NuCompleter::new(
                 engine_reference.clone(),
@@ -201,25 +215,39 @@ pub fn evaluate_repl(
             )))
             .with_quick_completions(config.quick_completions)
             .with_partial_completions(config.partial_completions)
-            .with_ansi_colors(config.use_ansi_coloring);
+            .with_ansi_colors(config.use_ansi_coloring)
+            .with_cursor_config(cursor_config);
+        perf("reedline builder", start_time, file!(), line!(), column!());
 
+        let style_computer = StyleComputer::from_config(engine_state, stack);
+
+        start_time = std::time::Instant::now();
         line_editor = if config.use_ansi_coloring {
-            line_editor.with_hinter(Box::new(
+            line_editor.with_hinter(Box::new({
-                DefaultHinter::default().with_style(color_hm["hints"]),
+                // As of Nov 2022, "hints" color_config closures only get `null` passed in.
-            ))
+                let style = style_computer.compute("hints", &Value::nothing(Span::unknown()));
+                DefaultHinter::default().with_style(style)
+            }))
         } else {
             line_editor.disable_hints()
         };
+        perf(
+            "reedline coloring/style_computer",
+            start_time,
+            file!(),
+            line!(),
+            column!(),
+        );
 
-        line_editor = match add_menus(line_editor, engine_reference, stack, config) {
+        start_time = std::time::Instant::now();
-            Ok(line_editor) => line_editor,
+        line_editor = add_menus(line_editor, engine_reference, stack, config).unwrap_or_else(|e| {
-            Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
-                let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
-                report_error(&working_set, &e);
+            Reedline::create()
-                Reedline::create()
+        });
-            }
+        perf("reedline menus", start_time, file!(), line!(), column!());
-        };
 
+        start_time = std::time::Instant::now();
         let buffer_editor = if !config.buffer_editor.is_empty() {
             Some(config.buffer_editor.clone())
         } else {
@@ -240,17 +268,23 @@ pub fn evaluate_repl(
         } else {
             line_editor
         };
+        perf(
+            "reedline buffer_editor",
+            start_time,
+            file!(),
+            line!(),
+            column!(),
+        );
 
+        start_time = std::time::Instant::now();
         if config.sync_history_on_enter {
-            info!("sync history {}:{}:{}", file!(), line!(), column!());
-
             if let Err(e) = line_editor.sync_history() {
                 warn!("Failed to sync history: {}", e);
             }
         }
+        perf("sync_history", start_time, file!(), line!(), column!());
 
-        info!("setup keybindings {}:{}:{}", file!(), line!(), column!());
+        start_time = std::time::Instant::now();
-
         // Changing the line editor based on the found keybindings
         line_editor = match create_keybindings(config) {
             Ok(keybindings) => match keybindings {
@@ -272,9 +306,9 @@ pub fn evaluate_repl(
                 line_editor
             }
         };
+        perf("keybindings", start_time, file!(), line!(), column!());
 
-        info!("prompt_update {}:{}:{}", file!(), line!(), column!());
+        start_time = std::time::Instant::now();
-
         // Right before we start our prompt and take input from the user,
         // fire the "pre_prompt" hook
         if let Some(hook) = config.hooks.pre_prompt.clone() {
@@ -282,7 +316,9 @@ pub fn evaluate_repl(
                 report_error_new(engine_state, &err);
             }
         }
+        perf("pre-prompt hook", start_time, file!(), line!(), column!());
 
+        start_time = std::time::Instant::now();
         // Next, check all the environment variables they ask for
         // fire the "env_change" hook
         let config = engine_state.get_config();
@@ -291,19 +327,23 @@ pub fn evaluate_repl(
         {
             report_error_new(engine_state, &error)
         }
+        perf("env-change hook", start_time, file!(), line!(), column!());
 
+        start_time = std::time::Instant::now();
         let config = engine_state.get_config();
         let prompt = prompt_update::update_prompt(config, engine_state, stack, &mut nu_prompt);
+        perf("update_prompt", start_time, file!(), line!(), column!());
 
         entry_num += 1;
 
-        info!(
+        if entry_num == 1 && show_banner {
-            "finished setup, starting repl {}:{}:{}",
+            println!(
-            file!(),
+                "Startup Time: {}",
-            line!(),
+                format_duration(entire_start_time.elapsed().as_nanos() as i64)
-            column!()
+            );
-        );
+        }
 
+        start_time = std::time::Instant::now();
         let input = line_editor.read_line(prompt);
         let shell_integration = config.shell_integration;
 
@@ -375,7 +415,7 @@ pub fn evaluate_repl(
                         "OLDPWD".into(),
                         Value::String {
                             val: cwd.clone(),
-                            span: Span { start: 0, end: 0 },
+                            span: Span::unknown(),
                         },
                     );
 
@@ -385,7 +425,7 @@ pub fn evaluate_repl(
                         "PWD".into(),
                         Value::String {
                             val: path.clone(),
-                            span: Span { start: 0, end: 0 },
+                            span: Span::unknown(),
                         },
                     );
                     let cwd = Value::String { val: cwd, span };
@@ -430,8 +470,8 @@ pub fn evaluate_repl(
                         engine_state,
                         stack,
                         s.as_bytes(),
-                        &format!("entry #{}", entry_num),
+                        &format!("entry #{entry_num}"),
-                        PipelineData::new(Span::new(0, 0)),
+                        PipelineData::empty(),
                     );
                 }
                 let cmd_duration = start_time.elapsed();
@@ -440,7 +480,7 @@ pub fn evaluate_repl(
                     "CMD_DURATION_MS".into(),
                     Value::String {
                         val: format!("{}", cmd_duration.as_millis()),
-                        span: Span { start: 0, end: 0 },
+                        span: Span::unknown(),
                     },
                 );
 
@@ -488,7 +528,7 @@ pub fn evaluate_repl(
                         // ESC]0;stringBEL -- Set icon name and window title to string
                         // ESC]1;stringBEL -- Set icon name to string
                         // ESC]2;stringBEL -- Set window title to string
-                        run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
+                        run_ansi_sequence(&format!("\x1b]2;{maybe_abbrev_path}\x07"))?;
                     }
                     run_ansi_sequence(RESET_APPLICATION_MODE)?;
                 }
@@ -528,7 +568,7 @@ pub fn evaluate_repl(
             Err(err) => {
                 let message = err.to_string();
                 if !message.contains("duration") {
-                    eprintln!("Error: {:?}", err);
+                    eprintln!("Error: {err:?}");
                     // TODO: Identify possible error cases where a hard failure is preferable
                     // Ignoring and reporting could hide bigger problems
                     // e.g. https://github.com/nushell/nushell/issues/6452
@@ -539,11 +579,34 @@ pub fn evaluate_repl(
                 }
             }
         }
+        perf(
+            "processing line editor input",
+            start_time,
+            file!(),
+            line!(),
+            column!(),
+        );
+
+        perf(
+            "finished repl loop",
+            loop_start_time,
+            file!(),
+            line!(),
+            column!(),
+        );
     }
 
     Ok(())
 }
 
+fn map_nucursorshape_to_cursorshape(shape: NuCursorShape) -> CursorShape {
+    match shape {
+        NuCursorShape::Block => CursorShape::Block,
+        NuCursorShape::UnderScore => CursorShape::UnderScore,
+        NuCursorShape::Line => CursorShape::Line,
+    }
+}
+
 fn get_banner(engine_state: &mut EngineState, stack: &mut Stack) -> String {
     let age = match eval_string_with_input(
         engine_state,
@@ -567,15 +630,7 @@ Our {}Documentation{} is located at {}http://nushell.sh{}
 {}Tweet{} us at {}@nu_shell{}
 
 It's been this long since {}Nushell{}'s first commit:
-{}
+{}{}
-
-{}You can disable this banner using the {}config nu{}{} command
-to modify the config.nu file and setting show_banner to false.
-
-let-env config = {{
-    show_banner: false
-    ...
-}}{}
 "#,
         "\x1b[32m",   //start line 1 green
         "\x1b[32m",   //start line 2
@@ -607,11 +662,7 @@ let-env config = {{
         "\x1b[32m",   //before Nushell
         "\x1b[0m",    //after Nushell
         age,
-        "\x1b[2;37m", //before banner disable dim white
+        "\x1b[0m", //after banner disable
-        "\x1b[2;36m", //before config nu dim cyan
-        "\x1b[0m",    //after config nu
-        "\x1b[2;37m", //after config nu dim white
-        "\x1b[0m",    //after banner disable
     );
 
     banner
@@ -637,7 +688,7 @@ pub fn eval_string_with_input(
 
     let input_as_pipeline_data = match input {
         Some(input) => PipelineData::Value(input, None),
-        None => PipelineData::new(Span::test_data()),
+        None => PipelineData::empty(),
     };
 
     eval_block(
@@ -648,7 +699,7 @@ pub fn eval_string_with_input(
         false,
         true,
     )
-    .map(|x| x.into_value(Span::test_data()))
+    .map(|x| x.into_value(Span::unknown()))
 }
 
 pub fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) -> String {
@@ -718,11 +769,18 @@ pub fn eval_hook(
 ) -> Result<PipelineData, ShellError> {
     let value_span = value.span()?;
 
+    // Hooks can optionally be a record in this form:
+    // {
+    //     condition: {|before, after| ... }  # block that evaluates to true/false
+    //     code: # block or a string
+    // }
+    // The condition block will be run to check whether the main hook (in `code`) should be run.
+    // If it returns true (the default if a condition block is not specified), the hook should be run.
     let condition_path = PathMember::String {
         val: "condition".to_string(),
         span: value_span,
     };
-    let mut output = PipelineData::new(Span::new(0, 0));
+    let mut output = PipelineData::empty();
 
     let code_path = PathMember::String {
         val: "code".to_string(),
@@ -736,57 +794,63 @@ pub fn eval_hook(
             }
         }
         Value::Record { .. } => {
-            let do_run_hook =
+            let do_run_hook = if let Ok(condition) =
-                if let Ok(condition) = value.clone().follow_cell_path(&[condition_path], false) {
+                value
-                    match condition {
+                    .clone()
-                        Value::Block {
+                    .follow_cell_path(&[condition_path], false, false)
-                            val: block_id,
+            {
-                            span: block_span,
+                match condition {
-                            ..
+                    Value::Block {
-                        }
+                        val: block_id,
-                        | Value::Closure {
+                        span: block_span,
-                            val: block_id,
+                        ..
-                            span: block_span,
+                    }
-                            ..
+                    | Value::Closure {
-                        } => {
+                        val: block_id,
-                            match run_hook_block(
+                        span: block_span,
-                                engine_state,
+                        ..
-                                stack,
+                    } => {
-                                block_id,
+                        match run_hook_block(
-                                None,
+                            engine_state,
-                                arguments.clone(),
+                            stack,
-                                block_span,
+                            block_id,
-                            ) {
+                            None,
-                                Ok(value) => match value {
+                            arguments.clone(),
-                                    Value::Bool { val, .. } => val,
+                            block_span,
-                                    other => {
+                        ) {
-                                        return Err(ShellError::UnsupportedConfigValue(
+                            Ok(pipeline_data) => {
-                                            "boolean output".to_string(),
+                                if let PipelineData::Value(Value::Bool { val, .. }, ..) =
-                                            format!("{}", other.get_type()),
+                                    pipeline_data
-                                            other.span()?,
+                                {
-                                        ));
+                                    val
-                                    }
+                                } else {
-                                },
+                                    return Err(ShellError::UnsupportedConfigValue(
-                                Err(err) => {
+                                        "boolean output".to_string(),
-                                    return Err(err);
+                                        "other PipelineData variant".to_string(),
+                                        block_span,
+                                    ));
                                 }
                             }
-                        }
+                            Err(err) => {
-                        other => {
+                                return Err(err);
-                            return Err(ShellError::UnsupportedConfigValue(
+                            }
-                                "block".to_string(),
-                                format!("{}", other.get_type()),
-                                other.span()?,
-                            ));
                         }
                     }
-                } else {
+                    other => {
-                    // always run the hook
+                        return Err(ShellError::UnsupportedConfigValue(
-                    true
+                            "block".to_string(),
-                };
+                            format!("{}", other.get_type()),
+                            other.span()?,
+                        ));
+                    }
+                }
+            } else {
+                // always run the hook
+                true
+            };
 
             if do_run_hook {
-                match value.clone().follow_cell_path(&[code_path], false)? {
+                match value.clone().follow_cell_path(&[code_path], false, false)? {
                     Value::String {
                         val,
                         span: source_span,
@@ -823,7 +887,7 @@ pub fn eval_hook(
                         };
 
                         engine_state.merge_delta(delta)?;
-                        let input = PipelineData::new(value_span);
+                        let input = PipelineData::empty();
 
                         let var_ids: Vec<VarId> = vars
                             .into_iter()
@@ -889,34 +953,28 @@ pub fn eval_hook(
             span: block_span,
             ..
         } => {
-            output = PipelineData::Value(
+            output = run_hook_block(
-                run_hook_block(
+                engine_state,
-                    engine_state,
+                stack,
-                    stack,
+                *block_id,
-                    *block_id,
+                input,
-                    input,
+                arguments,
-                    arguments,
+                *block_span,
-                    *block_span,
+            )?;
-                )?,
-                None,
-            );
         }
         Value::Closure {
             val: block_id,
             span: block_span,
             ..
         } => {
-            output = PipelineData::Value(
+            output = run_hook_block(
-                run_hook_block(
+                engine_state,
-                    engine_state,
+                stack,
-                    stack,
+                *block_id,
-                    *block_id,
+                input,
-                    input,
+                arguments,
-                    arguments,
+                *block_span,
-                    *block_span,
+            )?;
-                )?,
-                None,
-            );
         }
         other => {
             return Err(ShellError::UnsupportedConfigValue(
@@ -933,17 +991,17 @@ pub fn eval_hook(
     Ok(output)
 }
 
-pub fn run_hook_block(
+fn run_hook_block(
     engine_state: &EngineState,
     stack: &mut Stack,
     block_id: BlockId,
     optional_input: Option<PipelineData>,
     arguments: Vec<(String, Value)>,
     span: Span,
-) -> Result<Value, ShellError> {
+) -> Result<PipelineData, ShellError> {
     let block = engine_state.get_block(block_id);
 
-    let input = optional_input.unwrap_or_else(|| PipelineData::new(span));
+    let input = optional_input.unwrap_or_else(PipelineData::empty);
 
     let mut callee_stack = stack.gather_captures(&block.captures);
 
@@ -962,63 +1020,58 @@ pub fn run_hook_block(
         }
     }
 
-    match eval_block_with_early_return(engine_state, &mut callee_stack, block, input, false, false)
+    let pipeline_data =
-    {
+        eval_block_with_early_return(engine_state, &mut callee_stack, block, input, false, false)?;
-        Ok(pipeline_data) => match pipeline_data.into_value(span) {
-            Value::Error { error } => Err(error),
-            val => {
-                // If all went fine, preserve the environment of the called block
-                let caller_env_vars = stack.get_env_var_names(engine_state);
 
-                // remove env vars that are present in the caller but not in the callee
+    if let PipelineData::Value(Value::Error { error }, _) = pipeline_data {
-                // (the callee hid them)
+        return Err(error);
-                for var in caller_env_vars.iter() {
-                    if !callee_stack.has_env_var(engine_state, var) {
-                        stack.remove_env_var(engine_state, var);
-                    }
-                }
-
-                // add new env vars from callee to caller
-                for (var, value) in callee_stack.get_stack_env_vars() {
-                    stack.add_env_var(var, value);
-                }
-
-                Ok(val)
-            }
-        },
-        Err(err) => Err(err),
     }
+
+    // If all went fine, preserve the environment of the called block
+    let caller_env_vars = stack.get_env_var_names(engine_state);
+
+    // remove env vars that are present in the caller but not in the callee
+    // (the callee hid them)
+    for var in caller_env_vars.iter() {
+        if !callee_stack.has_env_var(engine_state, var) {
+            stack.remove_env_var(engine_state, var);
+        }
+    }
+
+    // add new env vars from callee to caller
+    for (var, value) in callee_stack.get_stack_env_vars() {
+        stack.add_env_var(var, value);
+    }
+    Ok(pipeline_data)
 }
 
 fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
-    match io::stdout().write_all(seq.as_bytes()) {
+    io::stdout().write_all(seq.as_bytes()).map_err(|e| {
-        Ok(it) => it,
+        ShellError::GenericError(
-        Err(err) => {
+            "Error writing ansi sequence".into(),
-            return Err(ShellError::GenericError(
+            e.to_string(),
-                "Error writing ansi sequence".into(),
+            Some(Span::unknown()),
-                err.to_string(),
+            None,
-                Some(Span { start: 0, end: 0 }),
+            Vec::new(),
-                None,
+        )
-                Vec::new(),
+    })?;
-            ));
-        }
-    };
     io::stdout().flush().map_err(|e| {
         ShellError::GenericError(
             "Error flushing stdio".into(),
             e.to_string(),
-            Some(Span { start: 0, end: 0 }),
+            Some(Span::unknown()),
             None,
             Vec::new(),
         )
     })
 }
 
-lazy_static! {
+// Absolute paths with a drive letter, like 'C:', 'D:\', 'E:\foo'
-    // Absolute paths with a drive letter, like 'C:', 'D:\', 'E:\foo'
+#[cfg(windows)]
-    static ref DRIVE_PATH_REGEX: Regex =
+static DRIVE_PATH_REGEX: once_cell::sync::Lazy<fancy_regex::Regex> =
-        Regex::new(r"^[a-zA-Z]:[/\\]?").expect("Internal error: regex creation");
+    once_cell::sync::Lazy::new(|| {
-}
+        fancy_regex::Regex::new(r"^[a-zA-Z]:[/\\]?").expect("Internal error: regex creation")
+    });
 
 // A best-effort "does this string look kinda like a path?" function to determine whether to auto-cd
 fn looks_like_path(orig: &str) -> bool {

crates/nu-cli/src/syntax_highlight.rs

@@ -6,9 +6,10 @@ use nu_protocol::ast::{Argument, Block, Expr, Expression, PipelineElement};
 use nu_protocol::engine::{EngineState, StateWorkingSet};
 use nu_protocol::{Config, Span};
 use reedline::{Highlighter, StyledText};
+use std::sync::Arc;
 
 pub struct NuHighlighter {
-    pub engine_state: EngineState,
+    pub engine_state: Arc<EngineState>,
     pub config: Config,
 }
 
@@ -149,7 +150,7 @@ fn split_span_by_highlight_positions(
     for pos in highlight_positions {
         if start <= *pos && pos < &span.end {
             if start < *pos {
-                result.push((Span { start, end: *pos }, false));
+                result.push((Span::new(start, *pos), false));
             }
             let span_str = &line[pos - global_span_offset..span.end - global_span_offset];
             let end = span_str
@@ -157,18 +158,12 @@ fn split_span_by_highlight_positions(
                 .next()
                 .map(|c| pos + get_char_length(c))
                 .unwrap_or(pos + 1);
-            result.push((Span { start: *pos, end }, true));
+            result.push((Span::new(*pos, end), true));
             start = end;
         }
     }
     if start < span.end {
-        result.push((
+        result.push((Span::new(start, span.end), false));
-            Span {
-                start,
-                end: span.end,
-            },
-            false,
-        ));
     }
     result
 }
@@ -239,7 +234,8 @@ fn find_matching_block_end_in_block(
                 PipelineElement::Expression(_, e)
                 | PipelineElement::Redirection(_, _, e)
                 | PipelineElement::And(_, e)
-                | PipelineElement::Or(_, e) => {
+                | PipelineElement::Or(_, e)
+                | PipelineElement::SeparateRedirection { out: (_, e), .. } => {
                     if e.span.contains(global_cursor_offset) {
                         if let Some(pos) = find_matching_block_end_in_expr(
                             line,
@@ -358,6 +354,7 @@ fn find_matching_block_end_in_expr(
                     let opt_expr = match arg {
                         Argument::Named((_, _, opt_expr)) => opt_expr.as_ref(),
                         Argument::Positional(inner_expr) => Some(inner_expr),
+                        Argument::Unknown(inner_expr) => Some(inner_expr),
                     };
 
                     if let Some(inner_expr) = opt_expr {

crates/nu-cli/src/util.rs

@@ -9,6 +9,7 @@ use nu_protocol::{
 };
 #[cfg(windows)]
 use nu_utils::enable_vt_processing;
+use nu_utils::utils::perf;
 use std::path::{Path, PathBuf};
 
 // This will collect environment variables from std::env and adds them to a stack.
@@ -43,7 +44,7 @@ fn gather_env_vars(
         report_error(
             &working_set,
             &ShellError::GenericError(
-                format!("Environment variable was not captured: {}", env_str),
+                format!("Environment variable was not captured: {env_str}"),
                 "".to_string(),
                 None,
                 Some(msg.into()),
@@ -79,8 +80,7 @@ fn gather_env_vars(
                     "".to_string(),
                     None,
                     Some(format!(
-                        "Retrieving current directory failed: {:?} not a valid utf-8 path",
+                        "Retrieving current directory failed: {init_cwd:?} not a valid utf-8 path"
-                        init_cwd
                     )),
                     Vec::new(),
                 ),
@@ -204,6 +204,8 @@ pub fn eval_source(
     fname: &str,
     input: PipelineData,
 ) -> bool {
+    let start_time = std::time::Instant::now();
+
     let (block, delta) = {
         let mut working_set = StateWorkingSet::new(engine_state);
         let (output, err) = parse(
@@ -250,7 +252,7 @@ pub fn eval_source(
                     }
                 }
             } else {
-                result = pipeline_data.print(engine_state, stack, false, false);
+                result = pipeline_data.print(engine_state, stack, true, false);
             }
 
             match result {
@@ -282,6 +284,13 @@ pub fn eval_source(
             return false;
         }
     }
+    perf(
+        &format!("eval_source {}", &fname),
+        start_time,
+        file!(),
+        line!(),
+        column!(),
+    );
 
     true
 }
@@ -289,10 +298,7 @@ pub fn eval_source(
 fn set_last_exit_code(stack: &mut Stack, exit_code: i64) {
     stack.add_env_var(
         "LAST_EXIT_CODE".to_string(),
-        Value::Int {
+        Value::int(exit_code, Span::unknown()),
-            val: exit_code,
-            span: Span { start: 0, end: 0 },
-        },
     );
 }
 
@@ -318,27 +324,19 @@ pub fn report_error_new(
 }
 
 pub fn get_init_cwd() -> PathBuf {
-    match std::env::current_dir() {
+    std::env::current_dir().unwrap_or_else(|_| {
-        Ok(cwd) => cwd,
+        std::env::var("PWD")
-        Err(_) => match std::env::var("PWD") {
+            .map(Into::into)
-            Ok(cwd) => PathBuf::from(cwd),
+            .unwrap_or_else(|_| nu_path::home_dir().unwrap_or_default())
-            Err(_) => match nu_path::home_dir() {
+    })
-                Some(cwd) => cwd,
-                None => PathBuf::new(),
-            },
-        },
-    }
 }
 
 pub fn get_guaranteed_cwd(engine_state: &EngineState, stack: &Stack) -> PathBuf {
-    match nu_engine::env::current_dir(engine_state, stack) {
+    nu_engine::env::current_dir(engine_state, stack).unwrap_or_else(|e| {
-        Ok(p) => p,
+        let working_set = StateWorkingSet::new(engine_state);
-        Err(e) => {
+        report_error(&working_set, &e);
-            let working_set = StateWorkingSet::new(engine_state);
+        get_init_cwd()
-            report_error(&working_set, &e);
+    })
-            get_init_cwd()
-        }
-    }
 }
 
 #[cfg(test)]

crates/nu-cli/src/validation.rs

@@ -1,9 +1,10 @@
 use nu_parser::{parse, ParseError};
 use nu_protocol::engine::{EngineState, StateWorkingSet};
 use reedline::{ValidationResult, Validator};
+use std::sync::Arc;
 
 pub struct NuValidator {
-    pub engine_state: EngineState,
+    pub engine_state: Arc<EngineState>,
 }
 
 impl Validator for NuValidator {

crates/nu-cli/tests/completions.rs

@@ -5,7 +5,7 @@ use nu_parser::parse;
 use nu_protocol::engine::StateWorkingSet;
 use reedline::{Completer, Suggestion};
 use rstest::{fixture, rstest};
-use support::{file, folder, match_suggestions, new_engine};
+use support::{completions_helpers::new_quote_engine, file, folder, match_suggestions, new_engine};
 
 #[fixture]
 fn completer() -> NuCompleter {
@@ -34,6 +34,26 @@ fn completer_strings() -> NuCompleter {
     NuCompleter::new(std::sync::Arc::new(engine), stack)
 }
 
+#[fixture]
+fn extern_completer() -> NuCompleter {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = r#"
+        def animals [] { [ "cat", "dog", "eel" ] }
+        extern spam [
+            animal: string@animals
+            --foo (-f): string@animals
+            -b: string@animals
+        ]
+    "#;
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instantiate a new completer
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
+
 #[test]
 fn variables_dollar_sign_with_varialblecompletion() {
     let (_, _, engine, stack) = new_engine();
@@ -89,7 +109,7 @@ fn dotnu_completions() {
     // Create a new engine
     let (_, _, engine, stack) = new_engine();
 
-    // Instatiate a new completer
+    // Instantiate a new completer
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test source completion
@@ -149,11 +169,11 @@ fn file_completions() {
     // Create a new engine
     let (dir, dir_str, engine, stack) = new_engine();
 
-    // Instatiate a new completer
+    // Instantiate a new completer
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for the current folder
-    let target_dir = format!("cp {}", dir_str);
+    let target_dir = format!("cp {dir_str}");
     let suggestions = completer.complete(&target_dir, target_dir.len());
 
     // Create the expected values
@@ -411,17 +431,36 @@ fn command_watch_with_filecompletion() {
     match_suggestions(expected_paths, suggestions)
 }
 
+#[test]
+fn file_completion_quoted() {
+    let (_, _, engine, stack) = new_quote_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "open ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    let expected_paths: Vec<String> = vec![
+        "`te st.txt`".to_string(),
+        "`te#st.txt`".to_string(),
+        "`te'st.txt`".to_string(),
+        "`te(st).txt`".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
 #[test]
 fn flag_completions() {
     // Create a new engine
     let (_, _, engine, stack) = new_engine();
 
-    // Instatiate a new completer
+    // Instantiate a new completer
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
     // Test completions for the 'ls' flags
     let suggestions = completer.complete("ls -", 4);
 
-    assert_eq!(14, suggestions.len());
+    assert_eq!(16, suggestions.len());
 
     let expected: Vec<String> = vec![
         "--all".into(),
@@ -430,6 +469,7 @@ fn flag_completions() {
         "--full-paths".into(),
         "--help".into(),
         "--long".into(),
+        "--mime-type".into(),
         "--short-names".into(),
         "-D".into(),
         "-a".into(),
@@ -437,6 +477,7 @@ fn flag_completions() {
         "-f".into(),
         "-h".into(),
         "-l".into(),
+        "-m".into(),
         "-s".into(),
     ];
 
@@ -449,11 +490,11 @@ fn folder_with_directorycompletions() {
     // Create a new engine
     let (dir, dir_str, engine, stack) = new_engine();
 
-    // Instatiate a new completer
+    // Instantiate a new completer
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for the current folder
-    let target_dir = format!("cd {}", dir_str);
+    let target_dir = format!("cd {dir_str}");
     let suggestions = completer.complete(&target_dir, target_dir.len());
 
     // Create the expected values
@@ -477,7 +518,7 @@ fn variables_completions() {
     let record = "let actor = { name: 'Tom Hardy', age: 44 }";
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
-    // Instatiate a new completer
+    // Instantiate a new completer
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for $nu
@@ -634,7 +675,7 @@ fn run_external_completion(block: &str, input: &str) -> Vec<Suggestion> {
     config.external_completer = Some(latest_block_id);
     engine_state.set_config(&config);
 
-    // Instatiate a new completer
+    // Instantiate a new completer
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine_state), stack);
 
     completer.complete(input, input.len())
@@ -732,3 +773,83 @@ fn filecompletions_triggers_after_cursor() {
 
     match_suggestions(expected_paths, suggestions);
 }
+
+#[rstest]
+fn extern_custom_completion_positional(mut extern_completer: NuCompleter) {
+    let suggestions = extern_completer.complete("spam ", 5);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn extern_custom_completion_long_flag_1(mut extern_completer: NuCompleter) {
+    let suggestions = extern_completer.complete("spam --foo=", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn extern_custom_completion_long_flag_2(mut extern_completer: NuCompleter) {
+    let suggestions = extern_completer.complete("spam --foo ", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn extern_custom_completion_long_flag_short(mut extern_completer: NuCompleter) {
+    let suggestions = extern_completer.complete("spam -f ", 8);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn extern_custom_completion_short_flag(mut extern_completer: NuCompleter) {
+    let suggestions = extern_completer.complete("spam -b ", 8);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn extern_complete_flags(mut extern_completer: NuCompleter) {
+    let suggestions = extern_completer.complete("spam -", 6);
+    let expected: Vec<String> = vec!["--foo".into(), "-b".into(), "-f".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn alias_offset_bug_7748() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ea = ^$env.EDITOR /tmp/test.s"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Issue #7748
+    // Nushell crashes when an alias name is shorter than the alias command
+    // and the alias command is a external command
+    // This happens because of offset is not correct.
+    // This crashes before PR #7779
+    let _suggestions = completer.complete("e", 1);
+    //println!(" --------- suggestions: {:?}", suggestions);
+}
+
+#[rstest]
+fn alias_offset_bug_7754() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ll = ls -l"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Issue #7754
+    // Nushell crashes when an alias name is shorter than the alias command
+    // and the alias command contains pipes.
+    // This crashes before PR #7756
+    let _suggestions = completer.complete("ll -a | c", 9);
+
+    //println!(" --------- suggestions: {:?}", suggestions);
+}

crates/nu-cli/tests/support/completions_helpers.rs

@@ -33,20 +33,53 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
         "PWD".to_string(),
         Value::String {
             val: dir_str.clone(),
-            span: nu_protocol::Span {
+            span: nu_protocol::Span::new(0, dir_str.len()),
-                start: 0,
-                end: dir_str.len(),
-            },
         },
     );
     stack.add_env_var(
         "TEST".to_string(),
         Value::String {
             val: "NUSHELL".to_string(),
-            span: nu_protocol::Span {
+            span: nu_protocol::Span::new(0, dir_str.len()),
-                start: 0,
+        },
-                end: dir_str.len(),
+    );
-            },
+
+    // Merge environment into the permanent state
+    let merge_result = engine_state.merge_env(&mut stack, &dir);
+    assert!(merge_result.is_ok());
+
+    (dir, dir_str, engine_state, stack)
+}
+
+pub fn new_quote_engine() -> (PathBuf, String, EngineState, Stack) {
+    // Target folder inside assets
+    let dir = fs::fixtures().join("quoted_completions");
+    let mut dir_str = dir
+        .clone()
+        .into_os_string()
+        .into_string()
+        .unwrap_or_default();
+    dir_str.push(SEP);
+
+    // Create a new engine with default context
+    let mut engine_state = create_default_context();
+
+    // New stack
+    let mut stack = Stack::new();
+
+    // Add pwd as env var
+    stack.add_env_var(
+        "PWD".to_string(),
+        Value::String {
+            val: dir_str.clone(),
+            span: nu_protocol::Span::new(0, dir_str.len()),
+        },
+    );
+    stack.add_env_var(
+        "TEST".to_string(),
+        Value::String {
+            val: "NUSHELL".to_string(),
+            span: nu_protocol::Span::new(0, dir_str.len()),
         },
     );
 
@@ -112,7 +145,7 @@ pub fn merge_input(
         &block,
         PipelineData::Value(
             Value::Nothing {
-                span: Span { start: 0, end: 0 },
+                span: Span::unknown(),
             },
             None
         ),

crates/nu-color-config/Cargo.toml

@@ -5,11 +5,18 @@ repository = "https://github.com/nushell/nushell/tree/main/crates/nu-color-confi
 edition = "2021"
 license = "MIT"
 name = "nu-color-config"
-version = "0.72.1"
+version = "0.75.0"
 
 [dependencies]
-nu-protocol = { path = "../nu-protocol", version = "0.72.1"  }
-nu-ansi-term = "0.46.0"
-nu-json = { path = "../nu-json", version = "0.72.1"  }
-nu-table = { path = "../nu-table", version = "0.72.1"  }
 serde = { version="1.0.123", features=["derive"] }
+# used only for text_style Alignments
+tabled = { version = "0.10.0", features = ["color"], default-features = false }
+
+nu-protocol = { path = "../nu-protocol", version = "0.75.0"  }
+nu-ansi-term = "0.46.0"
+nu-utils = { path = "../nu-utils", version = "0.75.0" }
+nu-engine = { path = "../nu-engine", version = "0.75.0" }
+nu-json = { path="../nu-json", version = "0.75.0"  }
+
+[dev-dependencies]
+nu-test-support = { path="../nu-test-support", version = "0.75.0"  }

crates/nu-color-config/src/color_config.rs

@@ -1,413 +1,89 @@
-use crate::nu_style::{color_from_hex, color_string_to_nustyle};
+use crate::{
-use nu_ansi_term::{Color, Style};
+    nu_style::{color_from_hex, lookup_style},
-use nu_protocol::Config;
+    parse_nustyle, NuStyle,
-use nu_table::{Alignment, TextStyle};
+};
+use nu_ansi_term::Style;
+use nu_protocol::Value;
 use std::collections::HashMap;
 
 pub fn lookup_ansi_color_style(s: &str) -> Style {
     if s.starts_with('#') {
-        match color_from_hex(s) {
+        color_from_hex(s)
-            Ok(c) => match c {
+            .ok()
-                Some(c) => c.normal(),
+            .and_then(|c| c.map(|c| c.normal()))
-                None => Style::default(),
+            .unwrap_or_default()
-            },
-            Err(_) => Style::default(),
-        }
     } else if s.starts_with('{') {
         color_string_to_nustyle(s.to_string())
     } else {
-        match s {
+        lookup_style(s)
-            "g" | "green" => Color::Green.normal(),
-            "gb" | "green_bold" => Color::Green.bold(),
-            "gu" | "green_underline" => Color::Green.underline(),
-            "gi" | "green_italic" => Color::Green.italic(),
-            "gd" | "green_dimmed" => Color::Green.dimmed(),
-            "gr" | "green_reverse" => Color::Green.reverse(),
-            "gbl" | "green_blink" => Color::Green.blink(),
-            "gst" | "green_strike" => Color::Green.strikethrough(),
-
-            "lg" | "light_green" => Color::LightGreen.normal(),
-            "lgb" | "light_green_bold" => Color::LightGreen.bold(),
-            "lgu" | "light_green_underline" => Color::LightGreen.underline(),
-            "lgi" | "light_green_italic" => Color::LightGreen.italic(),
-            "lgd" | "light_green_dimmed" => Color::LightGreen.dimmed(),
-            "lgr" | "light_green_reverse" => Color::LightGreen.reverse(),
-            "lgbl" | "light_green_blink" => Color::LightGreen.blink(),
-            "lgst" | "light_green_strike" => Color::LightGreen.strikethrough(),
-
-            "r" | "red" => Color::Red.normal(),
-            "rb" | "red_bold" => Color::Red.bold(),
-            "ru" | "red_underline" => Color::Red.underline(),
-            "ri" | "red_italic" => Color::Red.italic(),
-            "rd" | "red_dimmed" => Color::Red.dimmed(),
-            "rr" | "red_reverse" => Color::Red.reverse(),
-            "rbl" | "red_blink" => Color::Red.blink(),
-            "rst" | "red_strike" => Color::Red.strikethrough(),
-
-            "lr" | "light_red" => Color::LightRed.normal(),
-            "lrb" | "light_red_bold" => Color::LightRed.bold(),
-            "lru" | "light_red_underline" => Color::LightRed.underline(),
-            "lri" | "light_red_italic" => Color::LightRed.italic(),
-            "lrd" | "light_red_dimmed" => Color::LightRed.dimmed(),
-            "lrr" | "light_red_reverse" => Color::LightRed.reverse(),
-            "lrbl" | "light_red_blink" => Color::LightRed.blink(),
-            "lrst" | "light_red_strike" => Color::LightRed.strikethrough(),
-
-            "u" | "blue" => Color::Blue.normal(),
-            "ub" | "blue_bold" => Color::Blue.bold(),
-            "uu" | "blue_underline" => Color::Blue.underline(),
-            "ui" | "blue_italic" => Color::Blue.italic(),
-            "ud" | "blue_dimmed" => Color::Blue.dimmed(),
-            "ur" | "blue_reverse" => Color::Blue.reverse(),
-            "ubl" | "blue_blink" => Color::Blue.blink(),
-            "ust" | "blue_strike" => Color::Blue.strikethrough(),
-
-            "lu" | "light_blue" => Color::LightBlue.normal(),
-            "lub" | "light_blue_bold" => Color::LightBlue.bold(),
-            "luu" | "light_blue_underline" => Color::LightBlue.underline(),
-            "lui" | "light_blue_italic" => Color::LightBlue.italic(),
-            "lud" | "light_blue_dimmed" => Color::LightBlue.dimmed(),
-            "lur" | "light_blue_reverse" => Color::LightBlue.reverse(),
-            "lubl" | "light_blue_blink" => Color::LightBlue.blink(),
-            "lust" | "light_blue_strike" => Color::LightBlue.strikethrough(),
-
-            "b" | "black" => Color::Black.normal(),
-            "bb" | "black_bold" => Color::Black.bold(),
-            "bu" | "black_underline" => Color::Black.underline(),
-            "bi" | "black_italic" => Color::Black.italic(),
-            "bd" | "black_dimmed" => Color::Black.dimmed(),
-            "br" | "black_reverse" => Color::Black.reverse(),
-            "bbl" | "black_blink" => Color::Black.blink(),
-            "bst" | "black_strike" => Color::Black.strikethrough(),
-
-            "ligr" | "light_gray" => Color::LightGray.normal(),
-            "ligrb" | "light_gray_bold" => Color::LightGray.bold(),
-            "ligru" | "light_gray_underline" => Color::LightGray.underline(),
-            "ligri" | "light_gray_italic" => Color::LightGray.italic(),
-            "ligrd" | "light_gray_dimmed" => Color::LightGray.dimmed(),
-            "ligrr" | "light_gray_reverse" => Color::LightGray.reverse(),
-            "ligrbl" | "light_gray_blink" => Color::LightGray.blink(),
-            "ligrst" | "light_gray_strike" => Color::LightGray.strikethrough(),
-
-            "y" | "yellow" => Color::Yellow.normal(),
-            "yb" | "yellow_bold" => Color::Yellow.bold(),
-            "yu" | "yellow_underline" => Color::Yellow.underline(),
-            "yi" | "yellow_italic" => Color::Yellow.italic(),
-            "yd" | "yellow_dimmed" => Color::Yellow.dimmed(),
-            "yr" | "yellow_reverse" => Color::Yellow.reverse(),
-            "ybl" | "yellow_blink" => Color::Yellow.blink(),
-            "yst" | "yellow_strike" => Color::Yellow.strikethrough(),
-
-            "ly" | "light_yellow" => Color::LightYellow.normal(),
-            "lyb" | "light_yellow_bold" => Color::LightYellow.bold(),
-            "lyu" | "light_yellow_underline" => Color::LightYellow.underline(),
-            "lyi" | "light_yellow_italic" => Color::LightYellow.italic(),
-            "lyd" | "light_yellow_dimmed" => Color::LightYellow.dimmed(),
-            "lyr" | "light_yellow_reverse" => Color::LightYellow.reverse(),
-            "lybl" | "light_yellow_blink" => Color::LightYellow.blink(),
-            "lyst" | "light_yellow_strike" => Color::LightYellow.strikethrough(),
-
-            "p" | "purple" => Color::Purple.normal(),
-            "pb" | "purple_bold" => Color::Purple.bold(),
-            "pu" | "purple_underline" => Color::Purple.underline(),
-            "pi" | "purple_italic" => Color::Purple.italic(),
-            "pd" | "purple_dimmed" => Color::Purple.dimmed(),
-            "pr" | "purple_reverse" => Color::Purple.reverse(),
-            "pbl" | "purple_blink" => Color::Purple.blink(),
-            "pst" | "purple_strike" => Color::Purple.strikethrough(),
-
-            "lp" | "light_purple" => Color::LightPurple.normal(),
-            "lpb" | "light_purple_bold" => Color::LightPurple.bold(),
-            "lpu" | "light_purple_underline" => Color::LightPurple.underline(),
-            "lpi" | "light_purple_italic" => Color::LightPurple.italic(),
-            "lpd" | "light_purple_dimmed" => Color::LightPurple.dimmed(),
-            "lpr" | "light_purple_reverse" => Color::LightPurple.reverse(),
-            "lpbl" | "light_purple_blink" => Color::LightPurple.blink(),
-            "lpst" | "light_purple_strike" => Color::LightPurple.strikethrough(),
-
-            "c" | "cyan" => Color::Cyan.normal(),
-            "cb" | "cyan_bold" => Color::Cyan.bold(),
-            "cu" | "cyan_underline" => Color::Cyan.underline(),
-            "ci" | "cyan_italic" => Color::Cyan.italic(),
-            "cd" | "cyan_dimmed" => Color::Cyan.dimmed(),
-            "cr" | "cyan_reverse" => Color::Cyan.reverse(),
-            "cbl" | "cyan_blink" => Color::Cyan.blink(),
-            "cst" | "cyan_strike" => Color::Cyan.strikethrough(),
-
-            "lc" | "light_cyan" => Color::LightCyan.normal(),
-            "lcb" | "light_cyan_bold" => Color::LightCyan.bold(),
-            "lcu" | "light_cyan_underline" => Color::LightCyan.underline(),
-            "lci" | "light_cyan_italic" => Color::LightCyan.italic(),
-            "lcd" | "light_cyan_dimmed" => Color::LightCyan.dimmed(),
-            "lcr" | "light_cyan_reverse" => Color::LightCyan.reverse(),
-            "lcbl" | "light_cyan_blink" => Color::LightCyan.blink(),
-            "lcst" | "light_cyan_strike" => Color::LightCyan.strikethrough(),
-
-            "w" | "white" => Color::White.normal(),
-            "wb" | "white_bold" => Color::White.bold(),
-            "wu" | "white_underline" => Color::White.underline(),
-            "wi" | "white_italic" => Color::White.italic(),
-            "wd" | "white_dimmed" => Color::White.dimmed(),
-            "wr" | "white_reverse" => Color::White.reverse(),
-            "wbl" | "white_blink" => Color::White.blink(),
-            "wst" | "white_strike" => Color::White.strikethrough(),
-
-            "dgr" | "dark_gray" => Color::DarkGray.normal(),
-            "dgrb" | "dark_gray_bold" => Color::DarkGray.bold(),
-            "dgru" | "dark_gray_underline" => Color::DarkGray.underline(),
-            "dgri" | "dark_gray_italic" => Color::DarkGray.italic(),
-            "dgrd" | "dark_gray_dimmed" => Color::DarkGray.dimmed(),
-            "dgrr" | "dark_gray_reverse" => Color::DarkGray.reverse(),
-            "dgrbl" | "dark_gray_blink" => Color::DarkGray.blink(),
-            "dgrst" | "dark_gray_strike" => Color::DarkGray.strikethrough(),
-
-            "def" | "default" => Color::Default.normal(),
-            "defb" | "default_bold" => Color::Default.bold(),
-            "defu" | "default_underline" => Color::Default.underline(),
-            "defi" | "default_italic" => Color::Default.italic(),
-            "defd" | "default_dimmed" => Color::Default.dimmed(),
-            "defr" | "default_reverse" => Color::Default.reverse(),
-
-            _ => Color::White.normal(),
-        }
     }
 }
 
-fn update_hashmap(key: &str, val: &str, hm: &mut HashMap<String, Style>) {
+pub fn get_color_map(colors: &HashMap<String, Value>) -> HashMap<String, Style> {
-    // eprintln!("key: {}, val: {}", &key, &val);
-    let color = lookup_ansi_color_style(val);
-    if let Some(v) = hm.get_mut(key) {
-        *v = color;
-    } else {
-        hm.insert(key.to_string(), color);
-    }
-}
-
-pub fn get_color_config(config: &Config) -> HashMap<String, Style> {
-    let config = config;
-
-    // create the hashmap
     let mut hm: HashMap<String, Style> = HashMap::new();
-    // set some defaults
-    // hm.insert("primitive_line".to_string(), Color::White.normal());
-    // hm.insert("primitive_pattern".to_string(), Color::White.normal());
-    // hm.insert("primitive_path".to_string(), Color::White.normal());
-    hm.insert("separator".to_string(), Color::White.normal());
-    hm.insert(
-        "leading_trailing_space_bg".to_string(),
-        Style::default().on(Color::Rgb(128, 128, 128)),
-    );
-    hm.insert("header".to_string(), Color::Green.bold());
-    hm.insert("empty".to_string(), Color::Blue.normal());
-    hm.insert("bool".to_string(), Color::White.normal());
-    hm.insert("int".to_string(), Color::White.normal());
-    hm.insert("filesize".to_string(), Color::White.normal());
-    hm.insert("duration".to_string(), Color::White.normal());
-    hm.insert("date".to_string(), Color::White.normal());
-    hm.insert("range".to_string(), Color::White.normal());
-    hm.insert("float".to_string(), Color::White.normal());
-    hm.insert("string".to_string(), Color::White.normal());
-    hm.insert("nothing".to_string(), Color::White.normal());
-    hm.insert("binary".to_string(), Color::White.normal());
-    hm.insert("cellpath".to_string(), Color::White.normal());
-    hm.insert("row_index".to_string(), Color::Green.bold());
-    hm.insert("record".to_string(), Color::White.normal());
-    hm.insert("list".to_string(), Color::White.normal());
-    hm.insert("block".to_string(), Color::White.normal());
-    hm.insert("hints".to_string(), Color::DarkGray.normal());
 
-    for (key, value) in &config.color_config {
+    for (key, value) in colors {
-        match value.as_string() {
+        parse_map_entry(&mut hm, key, value);
-            Ok(value) => update_hashmap(key, &value, &mut hm),
-            Err(_) => continue,
-        }
     }
 
     hm
 }
 
-// This function will assign a text style to a primitive, or really any string that's
+fn parse_map_entry(hm: &mut HashMap<String, Style>, key: &str, value: &Value) {
-// in the hashmap. The hashmap actually contains the style to be applied.
+    let value = match value {
-pub fn style_primitive(primitive: &str, color_hm: &HashMap<String, Style>) -> TextStyle {
+        Value::String { val, .. } => Some(lookup_ansi_color_style(val)),
-    match primitive {
+        Value::Record { cols, vals, .. } => get_style_from_value(cols, vals).map(parse_nustyle),
-        "bool" => {
+        _ => None,
-            let style = color_hm.get(primitive);
+    };
-            match style {
+    if let Some(value) = value {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        hm.entry(key.to_owned()).or_insert(value);
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        "int" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Right, *s),
-                None => TextStyle::basic_right(),
-            }
-        }
-
-        "filesize" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Right, *s),
-                None => TextStyle::basic_right(),
-            }
-        }
-
-        "duration" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        "date" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        "range" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        "float" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Right, *s),
-                None => TextStyle::basic_right(),
-            }
-        }
-
-        "string" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        "nothing" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        // not sure what to do with error
-        // "error" => {}
-        "binary" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        "cellpath" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        "row_index" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Right, *s),
-                None => TextStyle::new()
-                    .alignment(Alignment::Right)
-                    .fg(Color::Green)
-                    .bold(Some(true)),
-            }
-        }
-
-        "record" | "list" | "block" => {
-            let style = color_hm.get(primitive);
-            match style {
-                Some(s) => TextStyle::with_style(Alignment::Left, *s),
-                None => TextStyle::basic_left(),
-            }
-        }
-
-        // types in nushell but not in engine-q
-        // "Line" => {
-        //     let style = color_hm.get("Primitive::Line");
-        //     match style {
-        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
-        //         None => TextStyle::basic_left(),
-        //     }
-        // }
-        // "GlobPattern" => {
-        //     let style = color_hm.get("Primitive::GlobPattern");
-        //     match style {
-        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
-        //         None => TextStyle::basic_left(),
-        //     }
-        // }
-        // "FilePath" => {
-        //     let style = color_hm.get("Primitive::FilePath");
-        //     match style {
-        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
-        //         None => TextStyle::basic_left(),
-        //     }
-        // }
-        // "BeginningOfStream" => {
-        //     let style = color_hm.get("Primitive::BeginningOfStream");
-        //     match style {
-        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
-        //         None => TextStyle::basic_left(),
-        //     }
-        // }
-        // "EndOfStream" => {
-        //     let style = color_hm.get("Primitive::EndOfStream");
-        //     match style {
-        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
-        //         None => TextStyle::basic_left(),
-        //     }
-        // }
-        _ => TextStyle::basic_left(),
     }
 }
 
-#[test]
+fn get_style_from_value(cols: &[String], vals: &[Value]) -> Option<NuStyle> {
-fn test_hm() {
+    let mut was_set = false;
-    use nu_ansi_term::{Color, Style};
+    let mut style = NuStyle::from(Style::default());
+    for (col, val) in cols.iter().zip(vals) {
+        match col.as_str() {
+            "bg" => {
+                if let Value::String { val, .. } = val {
+                    style.bg = Some(val.clone());
+                    was_set = true;
+                }
+            }
+            "fg" => {
+                if let Value::String { val, .. } = val {
+                    style.fg = Some(val.clone());
+                    was_set = true;
+                }
+            }
+            "attr" => {
+                if let Value::String { val, .. } = val {
+                    style.attr = Some(val.clone());
+                    was_set = true;
+                }
+            }
+            _ => (),
+        }
+    }
 
-    let mut hm: HashMap<String, Style> = HashMap::new();
+    if was_set {
-    hm.insert("primitive_int".to_string(), Color::White.normal());
+        Some(style)
-    hm.insert("primitive_decimal".to_string(), Color::White.normal());
+    } else {
-    hm.insert("primitive_filesize".to_string(), Color::White.normal());
+        None
-    hm.insert("primitive_string".to_string(), Color::White.normal());
+    }
-    hm.insert("primitive_line".to_string(), Color::White.normal());
+}
-    hm.insert("primitive_columnpath".to_string(), Color::White.normal());
+
-    hm.insert("primitive_pattern".to_string(), Color::White.normal());
+fn color_string_to_nustyle(color_string: String) -> Style {
-    hm.insert("primitive_boolean".to_string(), Color::White.normal());
+    // eprintln!("color_string: {}", &color_string);
-    hm.insert("primitive_date".to_string(), Color::White.normal());
+    if color_string.is_empty() {
-    hm.insert("primitive_duration".to_string(), Color::White.normal());
+        return Style::default();
-    hm.insert("primitive_range".to_string(), Color::White.normal());
+    }
-    hm.insert("primitive_path".to_string(), Color::White.normal());
+
-    hm.insert("primitive_binary".to_string(), Color::White.normal());
+    let nu_style = match nu_json::from_str::<NuStyle>(&color_string) {
-    hm.insert("separator".to_string(), Color::White.normal());
+        Ok(s) => s,
-    hm.insert("header_align".to_string(), Color::Green.bold());
+        Err(_) => return Style::default(),
-    hm.insert("header".to_string(), Color::Green.bold());
+    };
-    hm.insert("header_style".to_string(), Style::default());
+
-    hm.insert("row_index".to_string(), Color::Green.bold());
+    parse_nustyle(nu_style)
-    hm.insert(
-        "leading_trailing_space_bg".to_string(),
-        Style::default().on(Color::Rgb(128, 128, 128)),
-    );
-
-    update_hashmap("primitive_int", "green", &mut hm);
-
-    assert_eq!(hm["primitive_int"], Color::Green.normal());
 }

crates/nu-color-config/src/lib.rs

@@ -2,8 +2,12 @@ mod color_config;
 mod matching_brackets_style;
 mod nu_style;
 mod shape_color;
+mod style_computer;
+mod text_style;
 
 pub use color_config::*;
 pub use matching_brackets_style::*;
 pub use nu_style::*;
 pub use shape_color::*;
+pub use style_computer::*;
+pub use text_style::*;

crates/nu-color-config/src/nu_style.rs

@@ -1,88 +1,113 @@
 use nu_ansi_term::{Color, Style};
-use serde::Deserialize;
+use nu_protocol::Value;
+use serde::{Deserialize, Serialize};
 
-#[derive(Deserialize, PartialEq, Eq, Debug)]
+#[derive(Deserialize, Serialize, PartialEq, Eq, Debug)]
 pub struct NuStyle {
     pub fg: Option<String>,
     pub bg: Option<String>,
     pub attr: Option<String>,
 }
 
-pub fn parse_nustyle(nu_style: NuStyle) -> Style {
+impl From<Style> for NuStyle {
-    // get the nu_ansi_term::Color foreground color
+    fn from(s: Style) -> Self {
-    let fg_color = match nu_style.fg {
+        Self {
-        Some(fg) => color_from_hex(&fg).unwrap_or_default(),
+            bg: s.background.and_then(color_to_string),
-        _ => None,
+            fg: s.foreground.and_then(color_to_string),
-    };
+            attr: style_get_attr(s),
-    // get the nu_ansi_term::Color background color
-    let bg_color = match nu_style.bg {
-        Some(bg) => color_from_hex(&bg).unwrap_or_default(),
-        _ => None,
-    };
-    // get the attributes
-    let color_attr = match nu_style.attr {
-        Some(attr) => attr,
-        _ => "".to_string(),
-    };
-
-    // setup the attributes available in nu_ansi_term::Style
-    let mut bold = false;
-    let mut dimmed = false;
-    let mut italic = false;
-    let mut underline = false;
-    let mut blink = false;
-    let mut reverse = false;
-    let mut hidden = false;
-    let mut strikethrough = false;
-
-    // since we can combine styles like bold-italic, iterate through the chars
-    // and set the bools for later use in the nu_ansi_term::Style application
-    for ch in color_attr.to_lowercase().chars() {
-        match ch {
-            'l' => blink = true,
-            'b' => bold = true,
-            'd' => dimmed = true,
-            'h' => hidden = true,
-            'i' => italic = true,
-            'r' => reverse = true,
-            's' => strikethrough = true,
-            'u' => underline = true,
-            'n' => (),
-            _ => (),
         }
     }
-
-    // here's where we build the nu_ansi_term::Style
-    Style {
-        foreground: fg_color,
-        background: bg_color,
-        is_blink: blink,
-        is_bold: bold,
-        is_dimmed: dimmed,
-        is_hidden: hidden,
-        is_italic: italic,
-        is_reverse: reverse,
-        is_strikethrough: strikethrough,
-        is_underline: underline,
-    }
 }
 
-pub fn color_string_to_nustyle(color_string: String) -> Style {
+fn style_get_attr(s: Style) -> Option<String> {
-    // eprintln!("color_string: {}", &color_string);
+    macro_rules! check {
-    if color_string.chars().count() < 1 {
+        ($attrs:expr, $b:expr, $c:expr) => {
-        Style::default()
+            if $b {
-    } else {
+                $attrs.push($c);
-        let nu_style = match nu_json::from_str::<NuStyle>(&color_string) {
+            }
-            Ok(s) => s,
-            Err(_) => NuStyle {
-                fg: None,
-                bg: None,
-                attr: None,
-            },
         };
-
-        parse_nustyle(nu_style)
     }
+
+    let mut attrs = String::new();
+
+    check!(attrs, s.is_blink, 'l');
+    check!(attrs, s.is_bold, 'b');
+    check!(attrs, s.is_dimmed, 'd');
+    check!(attrs, s.is_reverse, 'r');
+    check!(attrs, s.is_strikethrough, 's');
+    check!(attrs, s.is_underline, 'u');
+
+    if attrs.is_empty() {
+        None
+    } else {
+        Some(attrs)
+    }
+}
+
+fn color_to_string(color: Color) -> Option<String> {
+    match color {
+        Color::Black => Some(String::from("black")),
+        Color::DarkGray => Some(String::from("dark_gray")),
+        Color::Red => Some(String::from("red")),
+        Color::LightRed => Some(String::from("light_red")),
+        Color::Green => Some(String::from("green")),
+        Color::LightGreen => Some(String::from("light_green")),
+        Color::Yellow => Some(String::from("yellow")),
+        Color::LightYellow => Some(String::from("light_yellow")),
+        Color::Blue => Some(String::from("blue")),
+        Color::LightBlue => Some(String::from("light_blue")),
+        Color::Purple => Some(String::from("purple")),
+        Color::LightPurple => Some(String::from("light_purple")),
+        Color::Magenta => Some(String::from("magenta")),
+        Color::LightMagenta => Some(String::from("light_magenta")),
+        Color::Cyan => Some(String::from("cyan")),
+        Color::LightCyan => Some(String::from("light_cyan")),
+        Color::White => Some(String::from("white")),
+        Color::LightGray => Some(String::from("light_gray")),
+        Color::Default => Some(String::from("default")),
+        Color::Rgb(r, g, b) => Some(format!("#{r:X}{g:X}{b:X}")),
+        Color::Fixed(_) => None,
+    }
+}
+
+pub fn parse_nustyle(nu_style: NuStyle) -> Style {
+    let mut style = Style {
+        foreground: nu_style.fg.and_then(|fg| lookup_color_str(&fg)),
+        background: nu_style.bg.and_then(|bg| lookup_color_str(&bg)),
+        ..Default::default()
+    };
+
+    if let Some(attrs) = nu_style.attr {
+        fill_modifiers(&attrs, &mut style)
+    }
+
+    style
+}
+
+// Converts the color_config records, { fg, bg, attr }, into a Style.
+pub fn color_record_to_nustyle(value: &Value) -> Style {
+    let mut fg = None;
+    let mut bg = None;
+    let mut attr = None;
+    let v = value.as_record();
+    if let Ok((cols, inner_vals)) = v {
+        for (k, v) in cols.iter().zip(inner_vals) {
+            // Because config already type-checked the color_config records, this doesn't bother giving errors
+            // if there are unrecognised keys or bad values.
+            if let Ok(v) = v.as_string() {
+                match k.as_str() {
+                    "fg" => fg = Some(v),
+
+                    "bg" => bg = Some(v),
+
+                    "attr" => attr = Some(v),
+                    _ => (),
+                }
+            }
+        }
+    }
+
+    parse_nustyle(NuStyle { fg, bg, attr })
 }
 
 pub fn color_from_hex(
@@ -101,3 +126,471 @@ pub fn color_from_hex(
         )))
     }
 }
+
+pub fn lookup_style(s: &str) -> Style {
+    match s {
+        "g" | "green" => Color::Green.normal(),
+        "gb" | "green_bold" => Color::Green.bold(),
+        "gu" | "green_underline" => Color::Green.underline(),
+        "gi" | "green_italic" => Color::Green.italic(),
+        "gd" | "green_dimmed" => Color::Green.dimmed(),
+        "gr" | "green_reverse" => Color::Green.reverse(),
+        "gbl" | "green_blink" => Color::Green.blink(),
+        "gst" | "green_strike" => Color::Green.strikethrough(),
+
+        "lg" | "light_green" => Color::LightGreen.normal(),
+        "lgb" | "light_green_bold" => Color::LightGreen.bold(),
+        "lgu" | "light_green_underline" => Color::LightGreen.underline(),
+        "lgi" | "light_green_italic" => Color::LightGreen.italic(),
+        "lgd" | "light_green_dimmed" => Color::LightGreen.dimmed(),
+        "lgr" | "light_green_reverse" => Color::LightGreen.reverse(),
+        "lgbl" | "light_green_blink" => Color::LightGreen.blink(),
+        "lgst" | "light_green_strike" => Color::LightGreen.strikethrough(),
+
+        "r" | "red" => Color::Red.normal(),
+        "rb" | "red_bold" => Color::Red.bold(),
+        "ru" | "red_underline" => Color::Red.underline(),
+        "ri" | "red_italic" => Color::Red.italic(),
+        "rd" | "red_dimmed" => Color::Red.dimmed(),
+        "rr" | "red_reverse" => Color::Red.reverse(),
+        "rbl" | "red_blink" => Color::Red.blink(),
+        "rst" | "red_strike" => Color::Red.strikethrough(),
+
+        "lr" | "light_red" => Color::LightRed.normal(),
+        "lrb" | "light_red_bold" => Color::LightRed.bold(),
+        "lru" | "light_red_underline" => Color::LightRed.underline(),
+        "lri" | "light_red_italic" => Color::LightRed.italic(),
+        "lrd" | "light_red_dimmed" => Color::LightRed.dimmed(),
+        "lrr" | "light_red_reverse" => Color::LightRed.reverse(),
+        "lrbl" | "light_red_blink" => Color::LightRed.blink(),
+        "lrst" | "light_red_strike" => Color::LightRed.strikethrough(),
+
+        "u" | "blue" => Color::Blue.normal(),
+        "ub" | "blue_bold" => Color::Blue.bold(),
+        "uu" | "blue_underline" => Color::Blue.underline(),
+        "ui" | "blue_italic" => Color::Blue.italic(),
+        "ud" | "blue_dimmed" => Color::Blue.dimmed(),
+        "ur" | "blue_reverse" => Color::Blue.reverse(),
+        "ubl" | "blue_blink" => Color::Blue.blink(),
+        "ust" | "blue_strike" => Color::Blue.strikethrough(),
+
+        "lu" | "light_blue" => Color::LightBlue.normal(),
+        "lub" | "light_blue_bold" => Color::LightBlue.bold(),
+        "luu" | "light_blue_underline" => Color::LightBlue.underline(),
+        "lui" | "light_blue_italic" => Color::LightBlue.italic(),
+        "lud" | "light_blue_dimmed" => Color::LightBlue.dimmed(),
+        "lur" | "light_blue_reverse" => Color::LightBlue.reverse(),
+        "lubl" | "light_blue_blink" => Color::LightBlue.blink(),
+        "lust" | "light_blue_strike" => Color::LightBlue.strikethrough(),
+
+        "b" | "black" => Color::Black.normal(),
+        "bb" | "black_bold" => Color::Black.bold(),
+        "bu" | "black_underline" => Color::Black.underline(),
+        "bi" | "black_italic" => Color::Black.italic(),
+        "bd" | "black_dimmed" => Color::Black.dimmed(),
+        "br" | "black_reverse" => Color::Black.reverse(),
+        "bbl" | "black_blink" => Color::Black.blink(),
+        "bst" | "black_strike" => Color::Black.strikethrough(),
+
+        "ligr" | "light_gray" => Color::LightGray.normal(),
+        "ligrb" | "light_gray_bold" => Color::LightGray.bold(),
+        "ligru" | "light_gray_underline" => Color::LightGray.underline(),
+        "ligri" | "light_gray_italic" => Color::LightGray.italic(),
+        "ligrd" | "light_gray_dimmed" => Color::LightGray.dimmed(),
+        "ligrr" | "light_gray_reverse" => Color::LightGray.reverse(),
+        "ligrbl" | "light_gray_blink" => Color::LightGray.blink(),
+        "ligrst" | "light_gray_strike" => Color::LightGray.strikethrough(),
+
+        "y" | "yellow" => Color::Yellow.normal(),
+        "yb" | "yellow_bold" => Color::Yellow.bold(),
+        "yu" | "yellow_underline" => Color::Yellow.underline(),
+        "yi" | "yellow_italic" => Color::Yellow.italic(),
+        "yd" | "yellow_dimmed" => Color::Yellow.dimmed(),
+        "yr" | "yellow_reverse" => Color::Yellow.reverse(),
+        "ybl" | "yellow_blink" => Color::Yellow.blink(),
+        "yst" | "yellow_strike" => Color::Yellow.strikethrough(),
+
+        "ly" | "light_yellow" => Color::LightYellow.normal(),
+        "lyb" | "light_yellow_bold" => Color::LightYellow.bold(),
+        "lyu" | "light_yellow_underline" => Color::LightYellow.underline(),
+        "lyi" | "light_yellow_italic" => Color::LightYellow.italic(),
+        "lyd" | "light_yellow_dimmed" => Color::LightYellow.dimmed(),
+        "lyr" | "light_yellow_reverse" => Color::LightYellow.reverse(),
+        "lybl" | "light_yellow_blink" => Color::LightYellow.blink(),
+        "lyst" | "light_yellow_strike" => Color::LightYellow.strikethrough(),
+
+        "p" | "purple" => Color::Purple.normal(),
+        "pb" | "purple_bold" => Color::Purple.bold(),
+        "pu" | "purple_underline" => Color::Purple.underline(),
+        "pi" | "purple_italic" => Color::Purple.italic(),
+        "pd" | "purple_dimmed" => Color::Purple.dimmed(),
+        "pr" | "purple_reverse" => Color::Purple.reverse(),
+        "pbl" | "purple_blink" => Color::Purple.blink(),
+        "pst" | "purple_strike" => Color::Purple.strikethrough(),
+
+        "lp" | "light_purple" => Color::LightPurple.normal(),
+        "lpb" | "light_purple_bold" => Color::LightPurple.bold(),
+        "lpu" | "light_purple_underline" => Color::LightPurple.underline(),
+        "lpi" | "light_purple_italic" => Color::LightPurple.italic(),
+        "lpd" | "light_purple_dimmed" => Color::LightPurple.dimmed(),
+        "lpr" | "light_purple_reverse" => Color::LightPurple.reverse(),
+        "lpbl" | "light_purple_blink" => Color::LightPurple.blink(),
+        "lpst" | "light_purple_strike" => Color::LightPurple.strikethrough(),
+
+        "c" | "cyan" => Color::Cyan.normal(),
+        "cb" | "cyan_bold" => Color::Cyan.bold(),
+        "cu" | "cyan_underline" => Color::Cyan.underline(),
+        "ci" | "cyan_italic" => Color::Cyan.italic(),
+        "cd" | "cyan_dimmed" => Color::Cyan.dimmed(),
+        "cr" | "cyan_reverse" => Color::Cyan.reverse(),
+        "cbl" | "cyan_blink" => Color::Cyan.blink(),
+        "cst" | "cyan_strike" => Color::Cyan.strikethrough(),
+
+        "lc" | "light_cyan" => Color::LightCyan.normal(),
+        "lcb" | "light_cyan_bold" => Color::LightCyan.bold(),
+        "lcu" | "light_cyan_underline" => Color::LightCyan.underline(),
+        "lci" | "light_cyan_italic" => Color::LightCyan.italic(),
+        "lcd" | "light_cyan_dimmed" => Color::LightCyan.dimmed(),
+        "lcr" | "light_cyan_reverse" => Color::LightCyan.reverse(),
+        "lcbl" | "light_cyan_blink" => Color::LightCyan.blink(),
+        "lcst" | "light_cyan_strike" => Color::LightCyan.strikethrough(),
+
+        "w" | "white" => Color::White.normal(),
+        "wb" | "white_bold" => Color::White.bold(),
+        "wu" | "white_underline" => Color::White.underline(),
+        "wi" | "white_italic" => Color::White.italic(),
+        "wd" | "white_dimmed" => Color::White.dimmed(),
+        "wr" | "white_reverse" => Color::White.reverse(),
+        "wbl" | "white_blink" => Color::White.blink(),
+        "wst" | "white_strike" => Color::White.strikethrough(),
+
+        "dgr" | "dark_gray" => Color::DarkGray.normal(),
+        "dgrb" | "dark_gray_bold" => Color::DarkGray.bold(),
+        "dgru" | "dark_gray_underline" => Color::DarkGray.underline(),
+        "dgri" | "dark_gray_italic" => Color::DarkGray.italic(),
+        "dgrd" | "dark_gray_dimmed" => Color::DarkGray.dimmed(),
+        "dgrr" | "dark_gray_reverse" => Color::DarkGray.reverse(),
+        "dgrbl" | "dark_gray_blink" => Color::DarkGray.blink(),
+        "dgrst" | "dark_gray_strike" => Color::DarkGray.strikethrough(),
+
+        "def" | "default" => Color::Default.normal(),
+        "defb" | "default_bold" => Color::Default.bold(),
+        "defu" | "default_underline" => Color::Default.underline(),
+        "defi" | "default_italic" => Color::Default.italic(),
+        "defd" | "default_dimmed" => Color::Default.dimmed(),
+        "defr" | "default_reverse" => Color::Default.reverse(),
+
+        // Add xterm 256 colors adding an x prefix where the name conflicts
+        "xblack" | "xterm_black" => Color::Fixed(0).normal(),
+        "maroon" | "xterm_maroon" => Color::Fixed(1).normal(),
+        "xgreen" | "xterm_green" => Color::Fixed(2).normal(),
+        "olive" | "xterm_olive" => Color::Fixed(3).normal(),
+        "navy" | "xterm_navy" => Color::Fixed(4).normal(),
+        "xpurplea" | "xterm_purplea" => Color::Fixed(5).normal(),
+        "teal" | "xterm_teal" => Color::Fixed(6).normal(),
+        "silver" | "xterm_silver" => Color::Fixed(7).normal(),
+        "grey" | "xterm_grey" => Color::Fixed(8).normal(),
+        "xred" | "xterm_red" => Color::Fixed(9).normal(),
+        "lime" | "xterm_lime" => Color::Fixed(10).normal(),
+        "xyellow" | "xterm_yellow" => Color::Fixed(11).normal(),
+        "xblue" | "xterm_blue" => Color::Fixed(12).normal(),
+        "fuchsia" | "xterm_fuchsia" => Color::Fixed(13).normal(),
+        "aqua" | "xterm_aqua" => Color::Fixed(14).normal(),
+        "xwhite" | "xterm_white" => Color::Fixed(15).normal(),
+        "grey0" | "xterm_grey0" => Color::Fixed(16).normal(),
+        "navyblue" | "xterm_navyblue" => Color::Fixed(17).normal(),
+        "darkblue" | "xterm_darkblue" => Color::Fixed(18).normal(),
+        "blue3a" | "xterm_blue3a" => Color::Fixed(19).normal(),
+        "blue3b" | "xterm_blue3b" => Color::Fixed(20).normal(),
+        "blue1" | "xterm_blue1" => Color::Fixed(21).normal(),
+        "darkgreen" | "xterm_darkgreen" => Color::Fixed(22).normal(),
+        "deepskyblue4a" | "xterm_deepskyblue4a" => Color::Fixed(23).normal(),
+        "deepskyblue4b" | "xterm_deepskyblue4b" => Color::Fixed(24).normal(),
+        "deepskyblue4c" | "xterm_deepskyblue4c" => Color::Fixed(25).normal(),
+        "dodgerblue3" | "xterm_dodgerblue3" => Color::Fixed(26).normal(),
+        "dodgerblue2" | "xterm_dodgerblue2" => Color::Fixed(27).normal(),
+        "green4" | "xterm_green4" => Color::Fixed(28).normal(),
+        "springgreen4" | "xterm_springgreen4" => Color::Fixed(29).normal(),
+        "turquoise4" | "xterm_turquoise4" => Color::Fixed(30).normal(),
+        "deepskyblue3a" | "xterm_deepskyblue3a" => Color::Fixed(31).normal(),
+        "deepskyblue3b" | "xterm_deepskyblue3b" => Color::Fixed(32).normal(),
+        "dodgerblue1" | "xterm_dodgerblue1" => Color::Fixed(33).normal(),
+        "green3a" | "xterm_green3a" => Color::Fixed(34).normal(),
+        "springgreen3a" | "xterm_springgreen3a" => Color::Fixed(35).normal(),
+        "darkcyan" | "xterm_darkcyan" => Color::Fixed(36).normal(),
+        "lightseagreen" | "xterm_lightseagreen" => Color::Fixed(37).normal(),
+        "deepskyblue2" | "xterm_deepskyblue2" => Color::Fixed(38).normal(),
+        "deepskyblue1" | "xterm_deepskyblue1" => Color::Fixed(39).normal(),
+        "green3b" | "xterm_green3b" => Color::Fixed(40).normal(),
+        "springgreen3b" | "xterm_springgreen3b" => Color::Fixed(41).normal(),
+        "springgreen2a" | "xterm_springgreen2a" => Color::Fixed(42).normal(),
+        "cyan3" | "xterm_cyan3" => Color::Fixed(43).normal(),
+        "darkturquoise" | "xterm_darkturquoise" => Color::Fixed(44).normal(),
+        "turquoise2" | "xterm_turquoise2" => Color::Fixed(45).normal(),
+        "green1" | "xterm_green1" => Color::Fixed(46).normal(),
+        "springgreen2b" | "xterm_springgreen2b" => Color::Fixed(47).normal(),
+        "springgreen1" | "xterm_springgreen1" => Color::Fixed(48).normal(),
+        "mediumspringgreen" | "xterm_mediumspringgreen" => Color::Fixed(49).normal(),
+        "cyan2" | "xterm_cyan2" => Color::Fixed(50).normal(),
+        "cyan1" | "xterm_cyan1" => Color::Fixed(51).normal(),
+        "darkreda" | "xterm_darkreda" => Color::Fixed(52).normal(),
+        "deeppink4a" | "xterm_deeppink4a" => Color::Fixed(53).normal(),
+        "purple4a" | "xterm_purple4a" => Color::Fixed(54).normal(),
+        "purple4b" | "xterm_purple4b" => Color::Fixed(55).normal(),
+        "purple3" | "xterm_purple3" => Color::Fixed(56).normal(),
+        "blueviolet" | "xterm_blueviolet" => Color::Fixed(57).normal(),
+        "orange4a" | "xterm_orange4a" => Color::Fixed(58).normal(),
+        "grey37" | "xterm_grey37" => Color::Fixed(59).normal(),
+        "mediumpurple4" | "xterm_mediumpurple4" => Color::Fixed(60).normal(),
+        "slateblue3a" | "xterm_slateblue3a" => Color::Fixed(61).normal(),
+        "slateblue3b" | "xterm_slateblue3b" => Color::Fixed(62).normal(),
+        "royalblue1" | "xterm_royalblue1" => Color::Fixed(63).normal(),
+        "chartreuse4" | "xterm_chartreuse4" => Color::Fixed(64).normal(),
+        "darkseagreen4a" | "xterm_darkseagreen4a" => Color::Fixed(65).normal(),
+        "paleturquoise4" | "xterm_paleturquoise4" => Color::Fixed(66).normal(),
+        "steelblue" | "xterm_steelblue" => Color::Fixed(67).normal(),
+        "steelblue3" | "xterm_steelblue3" => Color::Fixed(68).normal(),
+        "cornflowerblue" | "xterm_cornflowerblue" => Color::Fixed(69).normal(),
+        "chartreuse3a" | "xterm_chartreuse3a" => Color::Fixed(70).normal(),
+        "darkseagreen4b" | "xterm_darkseagreen4b" => Color::Fixed(71).normal(),
+        "cadetbluea" | "xterm_cadetbluea" => Color::Fixed(72).normal(),
+        "cadetblueb" | "xterm_cadetblueb" => Color::Fixed(73).normal(),
+        "skyblue3" | "xterm_skyblue3" => Color::Fixed(74).normal(),
+        "steelblue1a" | "xterm_steelblue1a" => Color::Fixed(75).normal(),
+        "chartreuse3b" | "xterm_chartreuse3b" => Color::Fixed(76).normal(),
+        "palegreen3a" | "xterm_palegreen3a" => Color::Fixed(77).normal(),
+        "seagreen3" | "xterm_seagreen3" => Color::Fixed(78).normal(),
+        "aquamarine3" | "xterm_aquamarine3" => Color::Fixed(79).normal(),
+        "mediumturquoise" | "xterm_mediumturquoise" => Color::Fixed(80).normal(),
+        "steelblue1b" | "xterm_steelblue1b" => Color::Fixed(81).normal(),
+        "chartreuse2a" | "xterm_chartreuse2a" => Color::Fixed(82).normal(),
+        "seagreen2" | "xterm_seagreen2" => Color::Fixed(83).normal(),
+        "seagreen1a" | "xterm_seagreen1a" => Color::Fixed(84).normal(),
+        "seagreen1b" | "xterm_seagreen1b" => Color::Fixed(85).normal(),
+        "aquamarine1a" | "xterm_aquamarine1a" => Color::Fixed(86).normal(),
+        "darkslategray2" | "xterm_darkslategray2" => Color::Fixed(87).normal(),
+        "darkredb" | "xterm_darkredb" => Color::Fixed(88).normal(),
+        "deeppink4b" | "xterm_deeppink4b" => Color::Fixed(89).normal(),
+        "darkmagentaa" | "xterm_darkmagentaa" => Color::Fixed(90).normal(),
+        "darkmagentab" | "xterm_darkmagentab" => Color::Fixed(91).normal(),
+        "darkvioleta" | "xterm_darkvioleta" => Color::Fixed(92).normal(),
+        "xpurpleb" | "xterm_purpleb" => Color::Fixed(93).normal(),
+        "orange4b" | "xterm_orange4b" => Color::Fixed(94).normal(),
+        "lightpink4" | "xterm_lightpink4" => Color::Fixed(95).normal(),
+        "plum4" | "xterm_plum4" => Color::Fixed(96).normal(),
+        "mediumpurple3a" | "xterm_mediumpurple3a" => Color::Fixed(97).normal(),
+        "mediumpurple3b" | "xterm_mediumpurple3b" => Color::Fixed(98).normal(),
+        "slateblue1" | "xterm_slateblue1" => Color::Fixed(99).normal(),
+        "yellow4a" | "xterm_yellow4a" => Color::Fixed(100).normal(),
+        "wheat4" | "xterm_wheat4" => Color::Fixed(101).normal(),
+        "grey53" | "xterm_grey53" => Color::Fixed(102).normal(),
+        "lightslategrey" | "xterm_lightslategrey" => Color::Fixed(103).normal(),
+        "mediumpurple" | "xterm_mediumpurple" => Color::Fixed(104).normal(),
+        "lightslateblue" | "xterm_lightslateblue" => Color::Fixed(105).normal(),
+        "yellow4b" | "xterm_yellow4b" => Color::Fixed(106).normal(),
+        "darkolivegreen3a" | "xterm_darkolivegreen3a" => Color::Fixed(107).normal(),
+        "darkseagreen" | "xterm_darkseagreen" => Color::Fixed(108).normal(),
+        "lightskyblue3a" | "xterm_lightskyblue3a" => Color::Fixed(109).normal(),
+        "lightskyblue3b" | "xterm_lightskyblue3b" => Color::Fixed(110).normal(),
+        "skyblue2" | "xterm_skyblue2" => Color::Fixed(111).normal(),
+        "chartreuse2b" | "xterm_chartreuse2b" => Color::Fixed(112).normal(),
+        "darkolivegreen3b" | "xterm_darkolivegreen3b" => Color::Fixed(113).normal(),
+        "palegreen3b" | "xterm_palegreen3b" => Color::Fixed(114).normal(),
+        "darkseagreen3a" | "xterm_darkseagreen3a" => Color::Fixed(115).normal(),
+        "darkslategray3" | "xterm_darkslategray3" => Color::Fixed(116).normal(),
+        "skyblue1" | "xterm_skyblue1" => Color::Fixed(117).normal(),
+        "chartreuse1" | "xterm_chartreuse1" => Color::Fixed(118).normal(),
+        "lightgreena" | "xterm_lightgreena" => Color::Fixed(119).normal(),
+        "lightgreenb" | "xterm_lightgreenb" => Color::Fixed(120).normal(),
+        "palegreen1a" | "xterm_palegreen1a" => Color::Fixed(121).normal(),
+        "aquamarine1b" | "xterm_aquamarine1b" => Color::Fixed(122).normal(),
+        "darkslategray1" | "xterm_darkslategray1" => Color::Fixed(123).normal(),
+        "red3a" | "xterm_red3a" => Color::Fixed(124).normal(),
+        "deeppink4c" | "xterm_deeppink4c" => Color::Fixed(125).normal(),
+        "mediumvioletred" | "xterm_mediumvioletred" => Color::Fixed(126).normal(),
+        "magenta3" | "xterm_magenta3" => Color::Fixed(127).normal(),
+        "darkvioletb" | "xterm_darkvioletb" => Color::Fixed(128).normal(),
+        "purplec" | "xterm_purplec" => Color::Fixed(129).normal(),
+        "darkorange3a" | "xterm_darkorange3a" => Color::Fixed(130).normal(),
+        "indianreda" | "xterm_indianreda" => Color::Fixed(131).normal(),
+        "hotpink3a" | "xterm_hotpink3a" => Color::Fixed(132).normal(),
+        "mediumorchid3" | "xterm_mediumorchid3" => Color::Fixed(133).normal(),
+        "mediumorchid" | "xterm_mediumorchid" => Color::Fixed(134).normal(),
+        "mediumpurple2a" | "xterm_mediumpurple2a" => Color::Fixed(135).normal(),
+        "darkgoldenrod" | "xterm_darkgoldenrod" => Color::Fixed(136).normal(),
+        "lightsalmon3a" | "xterm_lightsalmon3a" => Color::Fixed(137).normal(),
+        "rosybrown" | "xterm_rosybrown" => Color::Fixed(138).normal(),
+        "grey63" | "xterm_grey63" => Color::Fixed(139).normal(),
+        "mediumpurple2b" | "xterm_mediumpurple2b" => Color::Fixed(140).normal(),
+        "mediumpurple1" | "xterm_mediumpurple1" => Color::Fixed(141).normal(),
+        "gold3a" | "xterm_gold3a" => Color::Fixed(142).normal(),
+        "darkkhaki" | "xterm_darkkhaki" => Color::Fixed(143).normal(),
+        "navajowhite3" | "xterm_navajowhite3" => Color::Fixed(144).normal(),
+        "grey69" | "xterm_grey69" => Color::Fixed(145).normal(),
+        "lightsteelblue3" | "xterm_lightsteelblue3" => Color::Fixed(146).normal(),
+        "lightsteelblue" | "xterm_lightsteelblue" => Color::Fixed(147).normal(),
+        "yellow3a" | "xterm_yellow3a" => Color::Fixed(148).normal(),
+        "darkolivegreen3c" | "xterm_darkolivegreen3c" => Color::Fixed(149).normal(),
+        "darkseagreen3b" | "xterm_darkseagreen3b" => Color::Fixed(150).normal(),
+        "darkseagreen2a" | "xterm_darkseagreen2a" => Color::Fixed(151).normal(),
+        "lightcyan3" | "xterm_lightcyan3" => Color::Fixed(152).normal(),
+        "lightskyblue1" | "xterm_lightskyblue1" => Color::Fixed(153).normal(),
+        "greenyellow" | "xterm_greenyellow" => Color::Fixed(154).normal(),
+        "darkolivegreen2" | "xterm_darkolivegreen2" => Color::Fixed(155).normal(),
+        "palegreen1b" | "xterm_palegreen1b" => Color::Fixed(156).normal(),
+        "darkseagreen2b" | "xterm_darkseagreen2b" => Color::Fixed(157).normal(),
+        "darkseagreen1a" | "xterm_darkseagreen1a" => Color::Fixed(158).normal(),
+        "paleturquoise1" | "xterm_paleturquoise1" => Color::Fixed(159).normal(),
+        "red3b" | "xterm_red3b" => Color::Fixed(160).normal(),
+        "deeppink3a" | "xterm_deeppink3a" => Color::Fixed(161).normal(),
+        "deeppink3b" | "xterm_deeppink3b" => Color::Fixed(162).normal(),
+        "magenta3a" | "xterm_magenta3a" => Color::Fixed(163).normal(),
+        "magenta3b" | "xterm_magenta3b" => Color::Fixed(164).normal(),
+        "magenta2a" | "xterm_magenta2a" => Color::Fixed(165).normal(),
+        "darkorange3b" | "xterm_darkorange3b" => Color::Fixed(166).normal(),
+        "indianredb" | "xterm_indianredb" => Color::Fixed(167).normal(),
+        "hotpink3b" | "xterm_hotpink3b" => Color::Fixed(168).normal(),
+        "hotpink2" | "xterm_hotpink2" => Color::Fixed(169).normal(),
+        "orchid" | "xterm_orchid" => Color::Fixed(170).normal(),
+        "mediumorchid1a" | "xterm_mediumorchid1a" => Color::Fixed(171).normal(),
+        "orange3" | "xterm_orange3" => Color::Fixed(172).normal(),
+        "lightsalmon3b" | "xterm_lightsalmon3b" => Color::Fixed(173).normal(),
+        "lightpink3" | "xterm_lightpink3" => Color::Fixed(174).normal(),
+        "pink3" | "xterm_pink3" => Color::Fixed(175).normal(),
+        "plum3" | "xterm_plum3" => Color::Fixed(176).normal(),
+        "violet" | "xterm_violet" => Color::Fixed(177).normal(),
+        "gold3b" | "xterm_gold3b" => Color::Fixed(178).normal(),
+        "lightgoldenrod3" | "xterm_lightgoldenrod3" => Color::Fixed(179).normal(),
+        "tan" | "xterm_tan" => Color::Fixed(180).normal(),
+        "mistyrose3" | "xterm_mistyrose3" => Color::Fixed(181).normal(),
+        "thistle3" | "xterm_thistle3" => Color::Fixed(182).normal(),
+        "plum2" | "xterm_plum2" => Color::Fixed(183).normal(),
+        "yellow3b" | "xterm_yellow3b" => Color::Fixed(184).normal(),
+        "khaki3" | "xterm_khaki3" => Color::Fixed(185).normal(),
+        "lightgoldenrod2" | "xterm_lightgoldenrod2" => Color::Fixed(186).normal(),
+        "lightyellow3" | "xterm_lightyellow3" => Color::Fixed(187).normal(),
+        "grey84" | "xterm_grey84" => Color::Fixed(188).normal(),
+        "lightsteelblue1" | "xterm_lightsteelblue1" => Color::Fixed(189).normal(),
+        "yellow2" | "xterm_yellow2" => Color::Fixed(190).normal(),
+        "darkolivegreen1a" | "xterm_darkolivegreen1a" => Color::Fixed(191).normal(),
+        "darkolivegreen1b" | "xterm_darkolivegreen1b" => Color::Fixed(192).normal(),
+        "darkseagreen1b" | "xterm_darkseagreen1b" => Color::Fixed(193).normal(),
+        "honeydew2" | "xterm_honeydew2" => Color::Fixed(194).normal(),
+        "lightcyan1" | "xterm_lightcyan1" => Color::Fixed(195).normal(),
+        "red1" | "xterm_red1" => Color::Fixed(196).normal(),
+        "deeppink2" | "xterm_deeppink2" => Color::Fixed(197).normal(),
+        "deeppink1a" | "xterm_deeppink1a" => Color::Fixed(198).normal(),
+        "deeppink1b" | "xterm_deeppink1b" => Color::Fixed(199).normal(),
+        "magenta2b" | "xterm_magenta2b" => Color::Fixed(200).normal(),
+        "magenta1" | "xterm_magenta1" => Color::Fixed(201).normal(),
+        "orangered1" | "xterm_orangered1" => Color::Fixed(202).normal(),
+        "indianred1a" | "xterm_indianred1a" => Color::Fixed(203).normal(),
+        "indianred1b" | "xterm_indianred1b" => Color::Fixed(204).normal(),
+        "hotpinka" | "xterm_hotpinka" => Color::Fixed(205).normal(),
+        "hotpinkb" | "xterm_hotpinkb" => Color::Fixed(206).normal(),
+        "mediumorchid1b" | "xterm_mediumorchid1b" => Color::Fixed(207).normal(),
+        "darkorange" | "xterm_darkorange" => Color::Fixed(208).normal(),
+        "salmon1" | "xterm_salmon1" => Color::Fixed(209).normal(),
+        "lightcoral" | "xterm_lightcoral" => Color::Fixed(210).normal(),
+        "palevioletred1" | "xterm_palevioletred1" => Color::Fixed(211).normal(),
+        "orchid2" | "xterm_orchid2" => Color::Fixed(212).normal(),
+        "orchid1" | "xterm_orchid1" => Color::Fixed(213).normal(),
+        "orange1" | "xterm_orange1" => Color::Fixed(214).normal(),
+        "sandybrown" | "xterm_sandybrown" => Color::Fixed(215).normal(),
+        "lightsalmon1" | "xterm_lightsalmon1" => Color::Fixed(216).normal(),
+        "lightpink1" | "xterm_lightpink1" => Color::Fixed(217).normal(),
+        "pink1" | "xterm_pink1" => Color::Fixed(218).normal(),
+        "plum1" | "xterm_plum1" => Color::Fixed(219).normal(),
+        "gold1" | "xterm_gold1" => Color::Fixed(220).normal(),
+        "lightgoldenrod2a" | "xterm_lightgoldenrod2a" => Color::Fixed(221).normal(),
+        "lightgoldenrod2b" | "xterm_lightgoldenrod2b" => Color::Fixed(222).normal(),
+        "navajowhite1" | "xterm_navajowhite1" => Color::Fixed(223).normal(),
+        "mistyrose1" | "xterm_mistyrose1" => Color::Fixed(224).normal(),
+        "thistle1" | "xterm_thistle1" => Color::Fixed(225).normal(),
+        "yellow1" | "xterm_yellow1" => Color::Fixed(226).normal(),
+        "lightgoldenrod1" | "xterm_lightgoldenrod1" => Color::Fixed(227).normal(),
+        "khaki1" | "xterm_khaki1" => Color::Fixed(228).normal(),
+        "wheat1" | "xterm_wheat1" => Color::Fixed(229).normal(),
+        "cornsilk1" | "xterm_cornsilk1" => Color::Fixed(230).normal(),
+        "grey100" | "xterm_grey100" => Color::Fixed(231).normal(),
+        "grey3" | "xterm_grey3" => Color::Fixed(232).normal(),
+        "grey7" | "xterm_grey7" => Color::Fixed(233).normal(),
+        "grey11" | "xterm_grey11" => Color::Fixed(234).normal(),
+        "grey15" | "xterm_grey15" => Color::Fixed(235).normal(),
+        "grey19" | "xterm_grey19" => Color::Fixed(236).normal(),
+        "grey23" | "xterm_grey23" => Color::Fixed(237).normal(),
+        "grey27" | "xterm_grey27" => Color::Fixed(238).normal(),
+        "grey30" | "xterm_grey30" => Color::Fixed(239).normal(),
+        "grey35" | "xterm_grey35" => Color::Fixed(240).normal(),
+        "grey39" | "xterm_grey39" => Color::Fixed(241).normal(),
+        "grey42" | "xterm_grey42" => Color::Fixed(242).normal(),
+        "grey46" | "xterm_grey46" => Color::Fixed(243).normal(),
+        "grey50" | "xterm_grey50" => Color::Fixed(244).normal(),
+        "grey54" | "xterm_grey54" => Color::Fixed(245).normal(),
+        "grey58" | "xterm_grey58" => Color::Fixed(246).normal(),
+        "grey62" | "xterm_grey62" => Color::Fixed(247).normal(),
+        "grey66" | "xterm_grey66" => Color::Fixed(248).normal(),
+        "grey70" | "xterm_grey70" => Color::Fixed(249).normal(),
+        "grey74" | "xterm_grey74" => Color::Fixed(250).normal(),
+        "grey78" | "xterm_grey78" => Color::Fixed(251).normal(),
+        "grey82" | "xterm_grey82" => Color::Fixed(252).normal(),
+        "grey85" | "xterm_grey85" => Color::Fixed(253).normal(),
+        "grey89" | "xterm_grey89" => Color::Fixed(254).normal(),
+        "grey93" | "xterm_grey93" => Color::Fixed(255).normal(),
+        _ => Color::White.normal(),
+    }
+}
+
+pub fn lookup_color(s: &str) -> Option<Color> {
+    let color = match s {
+        "g" | "green" => Color::Green,
+        "lg" | "light_green" => Color::LightGreen,
+        "r" | "red" => Color::Red,
+        "lr" | "light_red" => Color::LightRed,
+        "u" | "blue" => Color::Blue,
+        "lu" | "light_blue" => Color::LightBlue,
+        "b" | "black" => Color::Black,
+        "ligr" | "light_gray" => Color::LightGray,
+        "y" | "yellow" => Color::Yellow,
+        "ly" | "light_yellow" => Color::LightYellow,
+        "p" | "purple" => Color::Purple,
+        "lp" | "light_purple" => Color::LightPurple,
+        "c" | "cyan" => Color::Cyan,
+        "lc" | "light_cyan" => Color::LightCyan,
+        "w" | "white" => Color::White,
+        "dgr" | "dark_gray" => Color::DarkGray,
+        "def" | "default" => Color::Default,
+        _ => return None,
+    };
+
+    Some(color)
+}
+
+fn fill_modifiers(attrs: &str, style: &mut Style) {
+    // setup the attributes available in nu_ansi_term::Style
+    //
+    // since we can combine styles like bold-italic, iterate through the chars
+    // and set the bools for later use in the nu_ansi_term::Style application
+    for ch in attrs.to_lowercase().chars() {
+        match ch {
+            'l' => style.is_blink = true,
+            'b' => style.is_bold = true,
+            'd' => style.is_dimmed = true,
+            'h' => style.is_hidden = true,
+            'i' => style.is_italic = true,
+            'r' => style.is_reverse = true,
+            's' => style.is_strikethrough = true,
+            'u' => style.is_underline = true,
+            'n' => (),
+            _ => (),
+        }
+    }
+}
+
+fn lookup_color_str(s: &str) -> Option<Color> {
+    if s.starts_with('#') {
+        color_from_hex(s).ok().and_then(|c| c)
+    } else {
+        lookup_color(s)
+    }
+}

crates/nu-color-config/src/shape_color.rs

@@ -1,45 +1,56 @@
-use crate::color_config::lookup_ansi_color_style;
+use crate::{color_config::lookup_ansi_color_style, color_record_to_nustyle};
 use nu_ansi_term::{Color, Style};
-use nu_protocol::Config;
+use nu_protocol::{Config, Value};
+
+// The default colors for shapes, used when there is no config for them.
+pub fn default_shape_color(shape: String) -> Style {
+    match shape.as_ref() {
+        "shape_and" => Style::new().fg(Color::Purple).bold(),
+        "shape_binary" => Style::new().fg(Color::Purple).bold(),
+        "shape_block" => Style::new().fg(Color::Blue).bold(),
+        "shape_bool" => Style::new().fg(Color::LightCyan),
+        "shape_custom" => Style::new().fg(Color::Green),
+        "shape_datetime" => Style::new().fg(Color::Cyan).bold(),
+        "shape_directory" => Style::new().fg(Color::Cyan),
+        "shape_external" => Style::new().fg(Color::Cyan),
+        "shape_externalarg" => Style::new().fg(Color::Green).bold(),
+        "shape_filepath" => Style::new().fg(Color::Cyan),
+        "shape_flag" => Style::new().fg(Color::Blue).bold(),
+        "shape_float" => Style::new().fg(Color::Purple).bold(),
+        "shape_garbage" => Style::new().fg(Color::White).on(Color::Red).bold(),
+        "shape_globpattern" => Style::new().fg(Color::Cyan).bold(),
+        "shape_int" => Style::new().fg(Color::Purple).bold(),
+        "shape_internalcall" => Style::new().fg(Color::Cyan).bold(),
+        "shape_list" => Style::new().fg(Color::Cyan).bold(),
+        "shape_literal" => Style::new().fg(Color::Blue),
+        "shape_nothing" => Style::new().fg(Color::LightCyan),
+        "shape_operator" => Style::new().fg(Color::Yellow),
+        "shape_or" => Style::new().fg(Color::Purple).bold(),
+        "shape_pipe" => Style::new().fg(Color::Purple).bold(),
+        "shape_range" => Style::new().fg(Color::Yellow).bold(),
+        "shape_record" => Style::new().fg(Color::Cyan).bold(),
+        "shape_redirection" => Style::new().fg(Color::Purple).bold(),
+        "shape_signature" => Style::new().fg(Color::Green).bold(),
+        "shape_string" => Style::new().fg(Color::Green),
+        "shape_string_interpolation" => Style::new().fg(Color::Cyan).bold(),
+        "shape_table" => Style::new().fg(Color::Blue).bold(),
+        "shape_variable" => Style::new().fg(Color::Purple),
+        _ => Style::default(),
+    }
+}
 
 pub fn get_shape_color(shape: String, conf: &Config) -> Style {
     match conf.color_config.get(shape.as_str()) {
-        Some(int_color) => match int_color.as_string() {
+        Some(int_color) => {
-            Ok(int_color) => lookup_ansi_color_style(&int_color),
+            // Shapes do not use color_config closures, currently.
-            Err(_) => Style::default(),
+            match int_color {
-        },
+                Value::Record { .. } => color_record_to_nustyle(int_color),
-        None => match shape.as_ref() {
+                Value::String { val, .. } => lookup_ansi_color_style(val),
-            "shape_garbage" => Style::new().fg(Color::White).on(Color::Red).bold(),
+                // Defer to the default in the event of incorrect types being given
-            "shape_binary" => Style::new().fg(Color::Purple).bold(),
+                // (i.e. treat null, etc. as the value being unset)
-            "shape_bool" => Style::new().fg(Color::LightCyan),
+                _ => default_shape_color(shape),
-            "shape_int" => Style::new().fg(Color::Purple).bold(),
+            }
-            "shape_float" => Style::new().fg(Color::Purple).bold(),
+        }
-            "shape_range" => Style::new().fg(Color::Yellow).bold(),
+        None => default_shape_color(shape),
-            "shape_internalcall" => Style::new().fg(Color::Cyan).bold(),
-            "shape_external" => Style::new().fg(Color::Cyan),
-            "shape_externalarg" => Style::new().fg(Color::Green).bold(),
-            "shape_literal" => Style::new().fg(Color::Blue),
-            "shape_operator" => Style::new().fg(Color::Yellow),
-            "shape_signature" => Style::new().fg(Color::Green).bold(),
-            "shape_string" => Style::new().fg(Color::Green),
-            "shape_string_interpolation" => Style::new().fg(Color::Cyan).bold(),
-            "shape_datetime" => Style::new().fg(Color::Cyan).bold(),
-            "shape_list" => Style::new().fg(Color::Cyan).bold(),
-            "shape_table" => Style::new().fg(Color::Blue).bold(),
-            "shape_record" => Style::new().fg(Color::Cyan).bold(),
-            "shape_block" => Style::new().fg(Color::Blue).bold(),
-            "shape_filepath" => Style::new().fg(Color::Cyan),
-            "shape_directory" => Style::new().fg(Color::Cyan),
-            "shape_globpattern" => Style::new().fg(Color::Cyan).bold(),
-            "shape_variable" => Style::new().fg(Color::Purple),
-            "shape_flag" => Style::new().fg(Color::Blue).bold(),
-            "shape_custom" => Style::new().fg(Color::Green),
-            "shape_pipe" => Style::new().fg(Color::Purple).bold(),
-            "shape_redirection" => Style::new().fg(Color::Purple).bold(),
-            "shape_and" => Style::new().fg(Color::Purple).bold(),
-            "shape_or" => Style::new().fg(Color::Purple).bold(),
-            "shape_nothing" => Style::new().fg(Color::LightCyan),
-            _ => Style::default(),
-        },
     }
 }

crates/nu-color-config/src/style_computer.rs

@@ -0,0 +1,285 @@
+use crate::{color_record_to_nustyle, lookup_ansi_color_style, TextStyle};
+use nu_ansi_term::{Color, Style};
+use nu_engine::eval_block;
+use nu_protocol::{
+    engine::{EngineState, Stack, StateWorkingSet},
+    CliError, IntoPipelineData, Value,
+};
+use tabled::alignment::AlignmentHorizontal;
+
+use std::{
+    collections::HashMap,
+    fmt::{Debug, Formatter, Result},
+};
+
+// ComputableStyle represents the valid user style types: a single color value, or a closure which
+// takes an input value and produces a color value. The latter represents a value which
+// is computed at use-time.
+#[derive(Debug, Clone)]
+pub enum ComputableStyle {
+    Static(Style),
+    Closure(Value),
+}
+
+// macro used for adding initial values to the style hashmap
+macro_rules! initial {
+    ($a:expr, $b:expr) => {
+        ($a.to_string(), ComputableStyle::Static($b))
+    };
+}
+
+// An alias for the mapping used internally by StyleComputer.
+pub type StyleMapping = HashMap<String, ComputableStyle>;
+//
+// A StyleComputer is an all-in-one way to compute styles. A nu command can
+// simply create it with from_config(), and then use it with compute().
+// It stores the engine state and stack needed to run closures that
+// may be defined as a user style.
+//
+pub struct StyleComputer<'a> {
+    engine_state: &'a EngineState,
+    stack: &'a Stack,
+    map: StyleMapping,
+}
+
+impl<'a> StyleComputer<'a> {
+    // This is NOT meant to be used in most cases - please use from_config() instead.
+    // This only exists for testing purposes.
+    pub fn new(
+        engine_state: &'a EngineState,
+        stack: &'a Stack,
+        map: StyleMapping,
+    ) -> StyleComputer<'a> {
+        StyleComputer {
+            engine_state,
+            stack,
+            map,
+        }
+    }
+    // The main method. Takes a string name which maps to a color_config style name,
+    // and a Nu value to pipe into any closures that may have been defined there.
+    pub fn compute(&self, style_name: &str, value: &Value) -> Style {
+        match self.map.get(style_name) {
+            // Static values require no computation.
+            Some(ComputableStyle::Static(s)) => *s,
+            // Closures are run here.
+            Some(ComputableStyle::Closure(Value::Closure {
+                val: block_id,
+                captures,
+                span,
+            })) => {
+                let block = self.engine_state.get_block(*block_id).clone();
+                // Because captures_to_stack() clones, we don't need to use with_env() here
+                // (contrast with_env() usage in `each` or `do`).
+                let mut stack = self.stack.captures_to_stack(captures);
+
+                // Support 1-argument blocks as well as 0-argument blocks.
+                if let Some(var) = block.signature.get_positional(0) {
+                    if let Some(var_id) = &var.var_id {
+                        stack.add_var(*var_id, value.clone());
+                    }
+                }
+
+                // Run the block.
+                match eval_block(
+                    self.engine_state,
+                    &mut stack,
+                    &block,
+                    value.clone().into_pipeline_data(),
+                    false,
+                    false,
+                ) {
+                    Ok(v) => {
+                        let value = v.into_value(*span);
+                        // These should be the same color data forms supported by color_config.
+                        match value {
+                            Value::Record { .. } => color_record_to_nustyle(&value),
+                            Value::String { val, .. } => lookup_ansi_color_style(&val),
+                            _ => Style::default(),
+                        }
+                    }
+                    // This is basically a copy of nu_cli::report_error(), but that isn't usable due to
+                    // dependencies. While crudely spitting out a bunch of errors like this is not ideal,
+                    // currently hook closure errors behave roughly the same.
+                    Err(e) => {
+                        eprintln!(
+                            "Error: {:?}",
+                            CliError(&e, &StateWorkingSet::new(self.engine_state))
+                        );
+                        Style::default()
+                    }
+                }
+            }
+            // There should be no other kinds of values (due to create_map() in config.rs filtering them out)
+            // so this is just a fallback.
+            _ => Style::default(),
+        }
+    }
+
+    // Used only by the `table` command.
+    pub fn style_primitive(&self, value: &Value) -> TextStyle {
+        let s = self.compute(&value.get_type().to_string(), value);
+        match *value {
+            Value::Bool { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
+
+            Value::Int { .. } => TextStyle::with_style(AlignmentHorizontal::Right, s),
+
+            Value::Filesize { .. } => TextStyle::with_style(AlignmentHorizontal::Right, s),
+
+            Value::Duration { .. } => TextStyle::with_style(AlignmentHorizontal::Right, s),
+
+            Value::Date { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
+
+            Value::Range { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
+
+            Value::Float { .. } => TextStyle::with_style(AlignmentHorizontal::Right, s),
+
+            Value::String { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
+
+            Value::Nothing { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
+
+            Value::Binary { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
+
+            Value::CellPath { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
+
+            Value::Record { .. } | Value::List { .. } | Value::Block { .. } => {
+                TextStyle::with_style(AlignmentHorizontal::Left, s)
+            }
+            _ => TextStyle::basic_left(),
+        }
+    }
+
+    // The main constructor.
+    pub fn from_config(engine_state: &'a EngineState, stack: &'a Stack) -> StyleComputer<'a> {
+        let config = engine_state.get_config();
+
+        // Create the hashmap
+        let mut map: StyleMapping = HashMap::from([
+            initial!("separator", Color::White.normal()),
+            initial!(
+                "leading_trailing_space_bg",
+                Style::default().on(Color::Rgb(128, 128, 128))
+            ),
+            initial!("header", Color::White.normal()),
+            initial!("empty", Color::White.normal()),
+            initial!("bool", Color::White.normal()),
+            initial!("int", Color::White.normal()),
+            initial!("filesize", Color::White.normal()),
+            initial!("duration", Color::White.normal()),
+            initial!("date", Color::White.normal()),
+            initial!("range", Color::White.normal()),
+            initial!("float", Color::White.normal()),
+            initial!("string", Color::White.normal()),
+            initial!("nothing", Color::White.normal()),
+            initial!("binary", Color::White.normal()),
+            initial!("cellpath", Color::White.normal()),
+            initial!("row_index", Color::Green.bold()),
+            initial!("record", Color::White.normal()),
+            initial!("list", Color::White.normal()),
+            initial!("block", Color::White.normal()),
+            initial!("hints", Color::DarkGray.normal()),
+        ]);
+
+        for (key, value) in &config.color_config {
+            match value {
+                Value::Closure { .. } => {
+                    map.insert(key.to_string(), ComputableStyle::Closure(value.clone()));
+                }
+                Value::Record { .. } => {
+                    map.insert(
+                        key.to_string(),
+                        ComputableStyle::Static(color_record_to_nustyle(value)),
+                    );
+                }
+                Value::String { val, .. } => {
+                    // update the stylemap with the found key
+                    let color = lookup_ansi_color_style(val.as_str());
+                    if let Some(v) = map.get_mut(key) {
+                        *v = ComputableStyle::Static(color);
+                    } else {
+                        map.insert(key.to_string(), ComputableStyle::Static(color));
+                    }
+                }
+                // This should never occur.
+                _ => (),
+            }
+        }
+        StyleComputer::new(engine_state, stack, map)
+    }
+}
+
+// Because EngineState doesn't have Debug (Dec 2022),
+// this incomplete representation must be used.
+impl<'a> Debug for StyleComputer<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        f.debug_struct("StyleComputer")
+            .field("map", &self.map)
+            .finish()
+    }
+}
+
+#[test]
+fn test_computable_style_static() {
+    use nu_protocol::Span;
+
+    let style1 = Style::default().italic();
+    let style2 = Style::default().underline();
+    // Create a "dummy" style_computer for this test.
+    let dummy_engine_state = EngineState::new();
+    let dummy_stack = Stack::new();
+    let style_computer = StyleComputer::new(
+        &dummy_engine_state,
+        &dummy_stack,
+        HashMap::from([
+            ("string".into(), ComputableStyle::Static(style1)),
+            ("row_index".into(), ComputableStyle::Static(style2)),
+        ]),
+    );
+    assert_eq!(
+        style_computer.compute("string", &Value::nothing(Span::unknown())),
+        style1
+    );
+    assert_eq!(
+        style_computer.compute("row_index", &Value::nothing(Span::unknown())),
+        style2
+    );
+}
+
+// Because each closure currently runs in a separate environment, checks that the closures have run
+// must use the filesystem.
+#[test]
+fn test_computable_style_closure_basic() {
+    use nu_test_support::{nu, nu_repl_code, playground::Playground};
+    Playground::setup("computable_style_closure_basic", |dirs, _| {
+        let inp = [
+            r#"let-env config = {
+                color_config: {
+                    string: {|e| touch ($e + '.obj'); 'red' }
+                }
+            };"#,
+            "[bell book candle] | table | ignore",
+            "ls | get name | to nuon",
+        ];
+        let actual_repl = nu!(cwd: dirs.test(), nu_repl_code(&inp));
+        assert_eq!(actual_repl.err, "");
+        assert_eq!(actual_repl.out, "[bell.obj, book.obj, candle.obj]");
+    });
+}
+
+#[test]
+fn test_computable_style_closure_errors() {
+    use nu_test_support::{nu, nu_repl_code};
+    let inp = [
+        r#"let-env config = {
+            color_config: {
+                string: {|e| $e + 2 }
+            }
+        };"#,
+        "[bell] | table",
+    ];
+    let actual_repl = nu!(cwd: ".", nu_repl_code(&inp));
+    // Check that the error was printed
+    assert!(actual_repl.err.contains("type mismatch for operator"));
+    // Check that the value was printed
+    assert!(actual_repl.out.contains("bell"));
+}

crates/nu-color-config/src/text_style.rs

@@ -1,4 +1,5 @@
 use nu_ansi_term::{Color, Style};
+use std::fmt::Display;
 
 pub type Alignment = tabled::alignment::AlignmentHorizontal;
 
@@ -239,3 +240,23 @@ impl Default for TextStyle {
         Self::new()
     }
 }
+
+impl tabled::papergrid::Color for TextStyle {
+    fn fmt_prefix(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(color) = &self.color_style {
+            color.prefix().fmt(f)?;
+        }
+
+        Ok(())
+    }
+
+    fn fmt_suffix(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(color) = &self.color_style {
+            if !color.is_plain() {
+                f.write_str("\u{1b}[0m")?;
+            }
+        }
+
+        Ok(())
+    }
+}

crates/nu-command/Cargo.toml

@@ -5,92 +5,97 @@ repository = "https://github.com/nushell/nushell/tree/main/crates/nu-command"
 edition = "2021"
 license = "MIT"
 name = "nu-command"
-version = "0.72.1"
+version = "0.75.0"
 build = "build.rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-color-config = { path = "../nu-color-config", version = "0.72.1"  }
+nu-color-config = { path = "../nu-color-config", version = "0.75.0" }
-nu-engine = { path = "../nu-engine", version = "0.72.1"  }
+nu-engine = { path = "../nu-engine", version = "0.75.0" }
-nu-glob = { path = "../nu-glob", version = "0.72.1" }
+nu-glob = { path = "../nu-glob", version = "0.75.0" }
-nu-json = { path = "../nu-json", version = "0.72.1"  }
+nu-json = { path = "../nu-json", version = "0.75.0" }
-nu-parser = { path = "../nu-parser", version = "0.72.1"  }
+nu-parser = { path = "../nu-parser", version = "0.75.0" }
-nu-path = { path = "../nu-path", version = "0.72.1"  }
+nu-path = { path = "../nu-path", version = "0.75.0" }
-nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.72.1"  }
+nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.75.0" }
-nu-protocol = { path = "../nu-protocol", version = "0.72.1"  }
+nu-protocol = { path = "../nu-protocol", version = "0.75.0" }
-nu-system = { path = "../nu-system", version = "0.72.1"  }
+nu-system = { path = "../nu-system", version = "0.75.0" }
-nu-table = { path = "../nu-table", version = "0.72.1"  }
+nu-table = { path = "../nu-table", version = "0.75.0" }
-nu-term-grid = { path = "../nu-term-grid", version = "0.72.1"  }
+nu-term-grid = { path = "../nu-term-grid", version = "0.75.0" }
-nu-utils = { path = "../nu-utils", version = "0.72.1" }
+nu-utils = { path = "../nu-utils", version = "0.75.0" }
+nu-explore = { path = "../nu-explore", version = "0.75.0" }
 nu-ansi-term = "0.46.0"
 num-format = { version = "0.4.3" }
 
 # Potential dependencies for extras
 alphanumeric-sort = "1.4.4"
-base64 = "0.13.0"
+atty = "0.2.14"
+base64 = "0.21.0"
 byteorder = "1.4.3"
 bytesize = "1.1.0"
-calamine = "0.18.0"
+calamine = "0.19.1"
 chrono = { version = "0.4.23", features = ["unstable-locales", "std"], default-features = false }
 chrono-humanize = "0.2.1"
-chrono-tz = "0.6.3"
+chrono-tz = "0.8.1"
 crossterm = "0.24.0"
 csv = "1.1.6"
-dialoguer = { default-features = false, version = "0.9.0" }
+dialoguer = { default-features = false, version = "0.10.3" }
 digest = { default-features = false, version = "0.10.0" }
 dtparse = "1.2.0"
 eml-parser = "0.1.0"
 encoding_rs = "0.8.30"
-fancy-regex = "0.10.0"
+fancy-regex = "0.11.0"
 filesize = "0.2.0"
 filetime = "0.2.15"
 fs_extra = "1.2.0"
 htmlescape = "0.3.1"
 ical = "0.7.0"
-indexmap = { version="1.7", features=["serde-1"] }
+indexmap = { version = "1.7", features = ["serde-1"] }
+indicatif = "0.17.2"
 Inflector = "0.11"
 is-root = "0.1.2"
 itertools = "0.10.0"
-lazy_static = "1.4.0"
 log = "0.4.14"
 lscolors = { version = "0.12.0", features = ["crossterm"], default-features = false }
 md5 = { package = "md-5", version = "0.10.0" }
-meval = "0.2.0"
 mime = "0.3.16"
+mime_guess = "2.0.4"
 notify = "4.0.17"
 num = { version = "0.4.0", optional = true }
 num-traits = "0.2.14"
-once_cell = "1.0"
+once_cell = "1.17"
+open = "3.2.0"
 pathdiff = "0.2.1"
-powierza-coefficient = "1.0.1"
+powierza-coefficient = "1.0.2"
-quick-xml = "0.23.0"
+quick-xml = "0.27"
 rand = "0.8"
-rayon = "1.5.1"
+rayon = "1.6.1"
-reqwest = {version = "0.11", features = ["blocking", "json"] }
+regex = "1.7.1"
-roxmltree = "0.14.0"
+reqwest = { version = "0.11", features = ["blocking", "json"] }
+roxmltree = "0.17.0"
 rust-embed = "6.3.0"
 same-file = "1.0.6"
-serde = { version="1.0.123", features=["derive"] }
+serde = { version = "1.0.123", features = ["derive"] }
 serde_ini = "0.2.0"
 serde_urlencoded = "0.7.0"
 serde_yaml = "0.9.4"
 sha2 = "0.10.0"
 # Disable default features b/c the default features build Git (very slow to compile)
-shadow-rs = { version = "0.16.1", default-features = false }
+shadow-rs = { version = "0.20.0", default-features = false }
-sysinfo = "0.26.2"
+sysinfo = "0.27.7"
 terminal_size = "0.2.1"
 thiserror = "1.0.31"
 titlecase = "2.0.0"
 toml = "0.5.8"
 unicode-segmentation = "1.8.0"
 url = "2.2.1"
-uuid = { version = "1.1.2", features = ["v4"] }
+percent-encoding = "2.2.0"
+uuid = { version = "1.2.2", features = ["v4"] }
 which = { version = "4.3.0", optional = true }
-reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
+reedline = { version = "0.15.0", features = ["bashisms", "sqlite"] }
-wax = { version =  "0.5.0" }
+wax = { version = "0.5.0" }
 rusqlite = { version = "0.28.0", features = ["bundled"], optional = true }
-sqlparser = { version = "0.23.0", features = ["serde"], optional = true }
+sqlparser = { version = "0.30.0", features = ["serde"], optional = true }
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.10.1"
@@ -101,11 +106,11 @@ users = "0.11.0"
 libc = "0.2"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies.trash]
-version = "3.0.0"
+version = "3.0.1"
 optional = true
 
 [dependencies.polars]
-version = "0.25.0"
+version = "0.26.1"
 optional = true
 features = [
 	"arg_where",
@@ -136,29 +141,25 @@ features = [
 ]
 
 [target.'cfg(windows)'.dependencies.windows]
-version = "0.43.0"
+version = "0.44.0"
-features = [
+features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_SystemServices"]
-    "Win32_Foundation",
-    "Win32_Storage_FileSystem",
-	"Win32_System_SystemServices",
-]
 
 [features]
 trash-support = ["trash"]
 which-support = ["which"]
 plugin = ["nu-parser/plugin"]
 dataframe = ["polars", "num", "sqlparser"]
-sqlite = ["rusqlite"] # TODO: given that rusqlite is included in reedline, should we just always include it?
+sqlite = ["rusqlite"]                      # TODO: given that rusqlite is included in reedline, should we just always include it?
 
 [build-dependencies]
-shadow-rs = { version = "0.16.1", default-features = false }
+shadow-rs = { version = "0.20.0", default-features = false }
 
 [dev-dependencies]
-nu-test-support = { path = "../nu-test-support", version = "0.72.1"  }
+nu-test-support = { path = "../nu-test-support", version = "0.75.0" }
 
 hamcrest2 = "0.3.0"
 dirs-next = "2.0.0"
 proptest = "1.0.0"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
-rstest = {version = "0.15.0", default-features = false}
+rstest = { version = "0.15.0", default-features = false }

crates/nu-command/build.rs

@@ -4,7 +4,7 @@ fn main() -> shadow_rs::SdResult<()> {
     // Look up the current Git commit ourselves instead of relying on shadow_rs,
     // because shadow_rs does it in a really slow-to-compile way (it builds libgit2)
     let hash = get_git_hash().unwrap_or_default();
-    println!("cargo:rustc-env=NU_COMMIT_HASH={}", hash);
+    println!("cargo:rustc-env=NU_COMMIT_HASH={hash}");
 
     shadow_rs::new()
 }

crates/nu-command/src/bits/and.rs

@@ -43,6 +43,10 @@ impl Command for SubCommand {
         let head = call.head;
         let target: i64 = call.req(engine_state, stack, 0)?;
 
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, target, head),
             engine_state.ctrlc.clone(),
@@ -54,10 +58,7 @@ impl Command for SubCommand {
             Example {
                 description: "Apply bits and to two numbers",
                 example: "2 | bits and 2",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(2)),
-                    val: 2,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Apply logical and to a list of numbers",
@@ -77,13 +78,15 @@ fn operate(value: Value, target: i64, head: Span) -> Value {
             val: val & target,
             span,
         },
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => value,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Only integer values are supported, input type: {:?}",
+                other.get_type().to_string(),
-                    other.get_type()
+                head,
-                ),
+                // This line requires the Value::Error match above.
-                other.span().unwrap_or(head),
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bits/bits_.rs

@@ -2,7 +2,7 @@ use nu_engine::get_full_help;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, IntoPipelineData, PipelineData, Signature, Value,
+    Category, IntoPipelineData, PipelineData, Signature, Type, Value,
 };
 
 #[derive(Clone)]
@@ -14,13 +14,19 @@ impl Command for Bits {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("bits").category(Category::Bits)
+        Signature::build("bits")
+            .category(Category::Bits)
+            .input_output_types(vec![(Type::Nothing, Type::String)])
     }
 
     fn usage(&self) -> &str {
         "Various commands for working with bits"
     }
 
+    fn extra_usage(&self) -> &str {
+        "You must use one of the following subcommands. Using this command as-is will only produce this help message."
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -41,15 +47,3 @@ impl Command for Bits {
         .into_pipeline_data())
     }
 }
-
-#[cfg(test)]
-mod test {
-    use crate::Bits;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(Bits {})
-    }
-}

crates/nu-command/src/bits/not.rs

@@ -56,11 +56,17 @@ impl Command for SubCommand {
             if let Some(val) = number_bytes {
                 return Err(ShellError::UnsupportedInput(
                     "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    "value originates from here".to_string(),
+                    head,
                     val.span,
                 ));
             }
         }
 
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, head, signed, bytes_len),
             engine_state.ctrlc.clone(),
@@ -140,14 +146,17 @@ fn operate(value: Value, head: Span, signed: bool, number_size: NumberBytes) ->
                 Value::Int { val: out_val, span }
             }
         }
-        other => Value::Error {
+        other => match other {
-            error: ShellError::UnsupportedInput(
+            // Propagate errors inside the value
-                format!(
+            Value::Error { .. } => other,
-                    "Only numerical values are supported, input type: {:?}",
+            _ => Value::Error {
-                    other.get_type()
+                error: ShellError::OnlySupportsThisInputType(
+                    "numeric".into(),
+                    other.get_type().to_string(),
+                    head,
+                    other.expect_span(),
                 ),
-                other.span().unwrap_or(head),
+            },
-            ),
         },
     }
 }

crates/nu-command/src/bits/or.rs

@@ -43,6 +43,10 @@ impl Command for SubCommand {
         let head = call.head;
         let target: i64 = call.req(engine_state, stack, 0)?;
 
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, target, head),
             engine_state.ctrlc.clone(),
@@ -54,10 +58,7 @@ impl Command for SubCommand {
             Example {
                 description: "Apply bits or to two numbers",
                 example: "2 | bits or 6",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(6)),
-                    val: 6,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Apply logical or to a list of numbers",
@@ -77,13 +78,15 @@ fn operate(value: Value, target: i64, head: Span) -> Value {
             val: val | target,
             span,
         },
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => value,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Only integer values are supported, input type: {:?}",
+                other.get_type().to_string(),
-                    other.get_type()
+                head,
-                ),
+                // This line requires the Value::Error match above.
-                other.span().unwrap_or(head),
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bits/rotate_left.rs

@@ -60,11 +60,16 @@ impl Command for SubCommand {
             if let Some(val) = number_bytes {
                 return Err(ShellError::UnsupportedInput(
                     "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    "value originates from here".to_string(),
+                    head,
                     val.span,
                 ));
             }
         }
-
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, bits, head, signed, bytes_len),
             engine_state.ctrlc.clone(),
@@ -76,10 +81,7 @@ impl Command for SubCommand {
             Example {
                 description: "Rotate left a number with 2 bits",
                 example: "17 | bits rol 2",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(68)),
-                    val: 68,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Rotate left a list of numbers with 2 bits",
@@ -104,8 +106,7 @@ where
             error: ShellError::GenericError(
                 "Rotate left result beyond the range of 64 bit signed number".to_string(),
                 format!(
-                    "{} of the specified number of bytes rotate left {} bits exceed limit",
+                    "{val} of the specified number of bytes rotate left {bits} bits exceed limit"
-                    val, bits
                 ),
                 Some(span),
                 None,
@@ -130,16 +131,18 @@ fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: Num
                 SignedOne => get_rotate_left(val as i8, bits, span),
                 SignedTwo => get_rotate_left(val as i16, bits, span),
                 SignedFour => get_rotate_left(val as i32, bits, span),
-                SignedEight => get_rotate_left(val as i64, bits, span),
+                SignedEight => get_rotate_left(val, bits, span),
             }
         }
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => value,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Only integer values are supported, input type: {:?}",
+                other.get_type().to_string(),
-                    other.get_type()
+                head,
-                ),
+                // This line requires the Value::Error match above.
-                other.span().unwrap_or(head),
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bits/rotate_right.rs

@@ -60,11 +60,16 @@ impl Command for SubCommand {
             if let Some(val) = number_bytes {
                 return Err(ShellError::UnsupportedInput(
                     "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    "value originates from here".to_string(),
+                    head,
                     val.span,
                 ));
             }
         }
-
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, bits, head, signed, bytes_len),
             engine_state.ctrlc.clone(),
@@ -76,10 +81,7 @@ impl Command for SubCommand {
             Example {
                 description: "Rotate right a number with 60 bits",
                 example: "17 | bits ror 60",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(272)),
-                    val: 272,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Rotate right a list of numbers of one byte",
@@ -108,8 +110,7 @@ where
             error: ShellError::GenericError(
                 "Rotate right result beyond the range of 64 bit signed number".to_string(),
                 format!(
-                    "{} of the specified number of bytes rotate right {} bits exceed limit",
+                    "{val} of the specified number of bytes rotate right {bits} bits exceed limit"
-                    val, bits
                 ),
                 Some(span),
                 None,
@@ -134,16 +135,18 @@ fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: Num
                 SignedOne => get_rotate_right(val as i8, bits, span),
                 SignedTwo => get_rotate_right(val as i16, bits, span),
                 SignedFour => get_rotate_right(val as i32, bits, span),
-                SignedEight => get_rotate_right(val as i64, bits, span),
+                SignedEight => get_rotate_right(val, bits, span),
             }
         }
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => value,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Only integer values are supported, input type: {:?}",
+                other.get_type().to_string(),
-                    other.get_type()
+                head,
-                ),
+                // This line requires the Value::Error match above.
-                other.span().unwrap_or(head),
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bits/shift_left.rs

@@ -60,11 +60,16 @@ impl Command for SubCommand {
             if let Some(val) = number_bytes {
                 return Err(ShellError::UnsupportedInput(
                     "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    "value originates from here".to_string(),
+                    head,
                     val.span,
                 ));
             }
         }
-
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, bits, head, signed, bytes_len),
             engine_state.ctrlc.clone(),
@@ -76,26 +81,17 @@ impl Command for SubCommand {
             Example {
                 description: "Shift left a number by 7 bits",
                 example: "2 | bits shl 7",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(256)),
-                    val: 256,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Shift left a number with 1 byte by 7 bits",
                 example: "2 | bits shl 7 -n 1",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(0)),
-                    val: 0,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Shift left a signed number by 1 bit",
                 example: "0x7F | bits shl 1 -s",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(254)),
-                    val: 254,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Shift left a list of numbers",
@@ -122,8 +118,7 @@ where
                     error: ShellError::GenericError(
                         "Shift left result beyond the range of 64 bit signed number".to_string(),
                         format!(
-                            "{} of the specified number of bytes shift left {} bits exceed limit",
+                            "{val} of the specified number of bytes shift left {bits} bits exceed limit"
-                            val, bits
                         ),
                         Some(span),
                         None,
@@ -135,10 +130,7 @@ where
         None => Value::Error {
             error: ShellError::GenericError(
                 "Shift left failed".to_string(),
-                format!(
+                format!("{val} shift left {bits} bits failed, you may shift too many bits"),
-                    "{} shift left {} bits failed, you may shift too many bits",
-                    val, bits
-                ),
                 Some(span),
                 None,
                 Vec::new(),
@@ -162,16 +154,18 @@ fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: Num
                 SignedOne => get_shift_left(val as i8, bits, span),
                 SignedTwo => get_shift_left(val as i16, bits, span),
                 SignedFour => get_shift_left(val as i32, bits, span),
-                SignedEight => get_shift_left(val as i64, bits, span),
+                SignedEight => get_shift_left(val, bits, span),
             }
         }
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => value,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Only integer values are supported, input type: {:?}",
+                other.get_type().to_string(),
-                    other.get_type()
+                head,
-                ),
+                // This line requires the Value::Error match above.
-                other.span().unwrap_or(head),
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bits/shift_right.rs

@@ -60,11 +60,16 @@ impl Command for SubCommand {
             if let Some(val) = number_bytes {
                 return Err(ShellError::UnsupportedInput(
                     "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    "value originates from here".to_string(),
+                    head,
                     val.span,
                 ));
             }
         }
-
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, bits, head, signed, bytes_len),
             engine_state.ctrlc.clone(),
@@ -76,10 +81,7 @@ impl Command for SubCommand {
             Example {
                 description: "Shift right a number with 2 bits",
                 example: "8 | bits shr 2",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(2)),
-                    val: 2,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Shift right a list of numbers",
@@ -106,8 +108,7 @@ where
                     error: ShellError::GenericError(
                         "Shift right result beyond the range of 64 bit signed number".to_string(),
                         format!(
-                            "{} of the specified number of bytes shift right {} bits exceed limit",
+                            "{val} of the specified number of bytes shift right {bits} bits exceed limit"
-                            val, bits
                         ),
                         Some(span),
                         None,
@@ -119,10 +120,7 @@ where
         None => Value::Error {
             error: ShellError::GenericError(
                 "Shift right failed".to_string(),
-                format!(
+                format!("{val} shift right {bits} bits failed, you may shift too many bits"),
-                    "{} shift right {} bits failed, you may shift too many bits",
-                    val, bits
-                ),
                 Some(span),
                 None,
                 Vec::new(),
@@ -146,16 +144,18 @@ fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: Num
                 SignedOne => get_shift_right(val as i8, bits, span),
                 SignedTwo => get_shift_right(val as i16, bits, span),
                 SignedFour => get_shift_right(val as i32, bits, span),
-                SignedEight => get_shift_right(val as i64, bits, span),
+                SignedEight => get_shift_right(val, bits, span),
             }
         }
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => value,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Only integer values are supported, input type: {:?}",
+                other.get_type().to_string(),
-                    other.get_type()
+                head,
-                ),
+                // This line requires the Value::Error match above.
-                other.span().unwrap_or(head),
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bits/xor.rs

@@ -42,7 +42,10 @@ impl Command for SubCommand {
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         let head = call.head;
         let target: i64 = call.req(engine_state, stack, 0)?;
-
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty(head));
+        }
         input.map(
             move |value| operate(value, target, head),
             engine_state.ctrlc.clone(),
@@ -54,10 +57,7 @@ impl Command for SubCommand {
             Example {
                 description: "Apply bits xor to two numbers",
                 example: "2 | bits xor 2",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(0)),
-                    val: 0,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Apply logical xor to a list of numbers",
@@ -77,13 +77,15 @@ fn operate(value: Value, target: i64, head: Span) -> Value {
             val: val ^ target,
             span,
         },
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => value,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Only integer values are supported, input type: {:?}",
+                other.get_type().to_string(),
-                    other.get_type()
+                head,
-                ),
+                // This line requires the Value::Error match above.
-                other.span().unwrap_or(head),
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bytes/add.rs

@@ -122,13 +122,15 @@ fn add(val: &Value, args: &Arguments, span: Span) -> Value {
             val,
             span: val_span,
         } => add_impl(val, args, *val_span),
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => val.clone(),
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bytes/at.rs

@@ -30,7 +30,9 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
         Value::List { mut vals, span } => {
             if vals.len() != 2 {
                 return Err(ShellError::UnsupportedInput(
-                    "More than two indices given".to_string(),
+                    "More than two indices in range".to_string(),
+                    "value originates from here".to_string(),
+                    head,
                     span,
                 ));
             } else {
@@ -38,10 +40,14 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
                 let end = match end {
                     Value::Int { val, .. } => val.to_string(),
                     Value::String { val, .. } => val,
+                    // Explicitly propagate errors instead of dropping them.
+                    Value::Error { error } => return Err(error),
                     other => {
                         return Err(ShellError::UnsupportedInput(
-                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            "Only string or list<int> ranges are supported".into(),
-                            other.span().unwrap_or(head),
+                            format!("input type: {:?}", other.get_type()),
+                            head,
+                            other.expect_span(),
                         ))
                     }
                 };
@@ -49,10 +55,14 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
                 let start = match start {
                     Value::Int { val, .. } => val.to_string(),
                     Value::String { val, .. } => val,
+                    // Explicitly propagate errors instead of dropping them.
+                    Value::Error { error } => return Err(error),
                     other => {
                         return Err(ShellError::UnsupportedInput(
-                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            "Only string or list<int> ranges are supported".into(),
-                            other.span().unwrap_or(head),
+                            format!("input type: {:?}", other.get_type()),
+                            head,
+                            other.expect_span(),
                         ))
                     }
                 };
@@ -60,21 +70,27 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
             }
         }
         Value::String { val, span } => {
-            let splitted_result = val.split_once(',');
+            let split_result = val.split_once(',');
-            match splitted_result {
+            match split_result {
                 Some((start, end)) => (start.to_string(), end.to_string(), span),
                 None => {
                     return Err(ShellError::UnsupportedInput(
                         "could not perform subbytes".to_string(),
+                        "with this range".to_string(),
+                        head,
                         span,
                     ))
                 }
             }
         }
+        // Explicitly propagate errors instead of dropping them.
+        Value::Error { error } => return Err(error),
         other => {
             return Err(ShellError::UnsupportedInput(
                 "could not perform subbytes".to_string(),
-                other.span().unwrap_or(head),
+                "with this range".to_string(),
+                head,
+                other.expect_span(),
             ))
         }
     };
@@ -82,28 +98,26 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
     let start: isize = if start.is_empty() || start == "_" {
         0
     } else {
-        match start.trim().parse() {
+        start.trim().parse().map_err(|_| {
-            Ok(s) => s,
+            ShellError::UnsupportedInput(
-            Err(_) => {
+                "could not perform subbytes".to_string(),
-                return Err(ShellError::UnsupportedInput(
+                "with this range".to_string(),
-                    "could not perform subbytes".to_string(),
+                head,
-                    span,
+                span,
-                ))
+            )
-            }
+        })?
-        }
     };
     let end: isize = if end.is_empty() || end == "_" {
         isize::max_value()
     } else {
-        match end.trim().parse() {
+        end.trim().parse().map_err(|_| {
-            Ok(s) => s,
+            ShellError::UnsupportedInput(
-            Err(_) => {
+                "could not perform subbytes".to_string(),
-                return Err(ShellError::UnsupportedInput(
+                "with this range".to_string(),
-                    "could not perform subbytes".to_string(),
+                head,
-                    span,
+                span,
-                ))
+            )
-            }
+        })?
-        }
     };
     Ok((start, end, span))
 }
@@ -232,13 +246,15 @@ fn at(val: &Value, args: &Arguments, span: Span) -> Value {
             val,
             span: val_span,
         } => at_impl(val, args, *val_span),
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => val.clone(),
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "integer".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }
@@ -262,7 +278,7 @@ fn at_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
         match start.cmp(&end) {
             Ordering::Equal => Value::Binary { val: vec![], span },
             Ordering::Greater => Value::Error {
-                error: ShellError::UnsupportedInput(
+                error: ShellError::TypeMismatch(
                     "End must be greater than or equal to Start".to_string(),
                     arg.arg_span,
                 ),

crates/nu-command/src/bytes/build_.rs

@@ -52,10 +52,12 @@ impl Command for BytesBuild {
             let val = eval_expression(engine_state, stack, expr)?;
             match val {
                 Value::Binary { mut val, .. } => output.append(&mut val),
+                // Explicitly propagate errors instead of dropping them.
+                Value::Error { error } => return Err(error),
                 other => {
-                    return Err(ShellError::UnsupportedInput(
+                    return Err(ShellError::TypeMismatch(
-                        "only support expression which yields to binary data".to_string(),
+                        "only binary data arguments are supported".to_string(),
-                        other.span().unwrap_or(call.head),
+                        other.expect_span(),
                     ))
                 }
             }

crates/nu-command/src/bytes/bytes_.rs

@@ -2,7 +2,7 @@ use nu_engine::get_full_help;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, IntoPipelineData, PipelineData, Signature, Value,
+    Category, IntoPipelineData, PipelineData, Signature, Type, Value,
 };
 
 #[derive(Clone)]
@@ -14,13 +14,19 @@ impl Command for Bytes {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("bytes").category(Category::Bytes)
+        Signature::build("bytes")
+            .category(Category::Bytes)
+            .input_output_types(vec![(Type::Nothing, Type::String)])
     }
 
     fn usage(&self) -> &str {
         "Various commands for working with byte data"
     }
 
+    fn extra_usage(&self) -> &str {
+        "You must use one of the following subcommands. Using this command as-is will only produce this help message."
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -41,15 +47,3 @@ impl Command for Bytes {
         .into_pipeline_data())
     }
 }
-
-#[cfg(test)]
-mod test {
-    use crate::Bytes;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(Bytes {})
-    }
-}

crates/nu-command/src/bytes/collect.rs

@@ -54,14 +54,16 @@ impl Command for BytesCollect {
                         output_binary.append(&mut work_sep)
                     }
                 }
+                // Explicitly propagate errors instead of dropping them.
+                Value::Error { error } => return Err(error),
                 other => {
-                    return Err(ShellError::UnsupportedInput(
+                    return Err(ShellError::OnlySupportsThisInputType(
-                        format!(
+                        "integer".into(),
-                            "The element type is {}, this command only works with bytes.",
+                        other.get_type().to_string(),
-                            other.get_type()
+                        call.head,
-                        ),
+                        // This line requires the Value::Error match above.
-                        other.span().unwrap_or(call.head),
+                        other.expect_span(),
-                    ))
+                    ));
                 }
             }
         }

crates/nu-command/src/bytes/ends_with.rs

@@ -68,26 +68,17 @@ impl Command for BytesEndsWith {
             Example {
                 description: "Checks if binary ends with `0x[AA]`",
                 example: "0x[1F FF AA AA] | bytes ends-with 0x[AA]",
-                result: Some(Value::Bool {
+                result: Some(Value::test_bool(true)),
-                    val: true,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Checks if binary ends with `0x[FF AA AA]`",
                 example: "0x[1F FF AA AA] | bytes ends-with 0x[FF AA AA]",
-                result: Some(Value::Bool {
+                result: Some(Value::test_bool(true)),
-                    val: true,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Checks if binary ends with `0x[11]`",
                 example: "0x[1F FF AA AA] | bytes ends-with 0x[11]",
-                result: Some(Value::Bool {
+                result: Some(Value::test_bool(false)),
-                    val: false,
-                    span: Span::test_data(),
-                }),
             },
         ]
     }
@@ -98,17 +89,16 @@ fn ends_with(val: &Value, args: &Arguments, span: Span) -> Value {
         Value::Binary {
             val,
             span: val_span,
-        } => Value::Bool {
+        } => Value::boolean(val.ends_with(&args.pattern), *val_span),
-            val: val.ends_with(&args.pattern),
+        // Propagate errors by explicitly matching them before the final case.
-            span: *val_span,
+        Value::Error { .. } => val.clone(),
-        },
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "binary".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bytes/index_of.rs

@@ -132,13 +132,15 @@ fn index_of(val: &Value, args: &Arguments, span: Span) -> Value {
             val,
             span: val_span,
         } => index_of_impl(val, args, *val_span),
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => val.clone(),
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "binary".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bytes/length.rs

@@ -70,17 +70,16 @@ fn length(val: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
         Value::Binary {
             val,
             span: val_span,
-        } => Value::Int {
+        } => Value::int(val.len() as i64, *val_span),
-            val: val.len() as i64,
+        // Propagate errors by explicitly matching them before the final case.
-            span: *val_span,
+        Value::Error { .. } => val.clone(),
-        },
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "binary".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bytes/remove.rs

@@ -61,7 +61,7 @@ impl Command for BytesRemove {
         let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
         let pattern_to_remove = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
         if pattern_to_remove.item.is_empty() {
-            return Err(ShellError::UnsupportedInput(
+            return Err(ShellError::TypeMismatch(
                 "the pattern to remove cannot be empty".to_string(),
                 pattern_to_remove.span,
             ));
@@ -139,13 +139,15 @@ fn remove(val: &Value, args: &Arguments, span: Span) -> Value {
             val,
             span: val_span,
         } => remove_impl(val, args, *val_span),
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => val.clone(),
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "binary".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }
@@ -159,7 +161,7 @@ fn remove_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
 
     // Note:
     // remove_all from start and end will generate the same result.
-    // so we'll put `remove_all` relative logic into else clouse.
+    // so we'll put `remove_all` relative logic into else clause.
     if arg.end && !remove_all {
         let (mut left, mut right) = (
             input.len() as isize - arg.pattern.len() as isize,
@@ -170,7 +172,7 @@ fn remove_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
             left -= 1;
             right -= 1;
         }
-        // append the remaining thing to result, this can be happeneed when
+        // append the remaining thing to result, this can be happening when
         // we have something to remove and remove_all is False.
         let mut remain = input[..left as usize].iter().copied().rev().collect();
         result.append(&mut remain);
@@ -191,7 +193,7 @@ fn remove_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
                 right += 1;
             }
         }
-        // append the remaing thing to result, this can happened when
+        // append the remaining thing to result, this can happened when
         // we have something to remove and remove_all is False.
         let mut remain = input[left..].to_vec();
         result.append(&mut remain);

crates/nu-command/src/bytes/replace.rs

@@ -61,7 +61,7 @@ impl Command for BytesReplace {
         let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
         let find = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
         if find.item.is_empty() {
-            return Err(ShellError::UnsupportedInput(
+            return Err(ShellError::TypeMismatch(
                 "the pattern to find cannot be empty".to_string(),
                 find.span,
             ));
@@ -130,13 +130,15 @@ fn replace(val: &Value, args: &Arguments, span: Span) -> Value {
             val,
             span: val_span,
         } => replace_impl(val, args, *val_span),
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => val.clone(),
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "binary".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bytes/reverse.rs

@@ -81,13 +81,15 @@ fn reverse(val: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
                 span: *val_span,
             }
         }
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => val.clone(),
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "binary".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/bytes/starts_with.rs

@@ -74,26 +74,17 @@ impl Command for BytesStartsWith {
             Example {
                 description: "Checks if binary starts with `0x[1F FF AA]`",
                 example: "0x[1F FF AA AA] | bytes starts-with 0x[1F FF AA]",
-                result: Some(Value::Bool {
+                result: Some(Value::test_bool(true)),
-                    val: true,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Checks if binary starts with `0x[1F]`",
                 example: "0x[1F FF AA AA] | bytes starts-with 0x[1F]",
-                result: Some(Value::Bool {
+                result: Some(Value::test_bool(true)),
-                    val: true,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Checks if binary starts with `0x[1F]`",
                 example: "0x[1F FF AA AA] | bytes starts-with 0x[11]",
-                result: Some(Value::Bool {
+                result: Some(Value::test_bool(false)),
-                    val: false,
-                    span: Span::test_data(),
-                }),
             },
         ]
     }
@@ -104,17 +95,16 @@ fn starts_with(val: &Value, args: &Arguments, span: Span) -> Value {
         Value::Binary {
             val,
             span: val_span,
-        } => Value::Bool {
+        } => Value::boolean(val.starts_with(&args.pattern), *val_span),
-            val: val.starts_with(&args.pattern),
+        // Propagate errors by explicitly matching them before the final case.
-            span: *val_span,
+        Value::Error { .. } => val.clone(),
-        },
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!(
+                "binary".into(),
-                    "Input's type is {}. This command only works with bytes.",
+                other.get_type().to_string(),
-                    other.get_type()
-                ),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/charting/hashable_value.rs

@@ -53,7 +53,7 @@ impl Default for HashableValue {
     fn default() -> Self {
         HashableValue::Bool {
             val: false,
-            span: Span { start: 0, end: 0 },
+            span: Span::unknown(),
         }
     }
 }
@@ -78,13 +78,14 @@ impl HashableValue {
             Value::String { val, span } => Ok(HashableValue::String { val, span }),
             Value::Binary { val, span } => Ok(HashableValue::Binary { val, span }),
 
-            _ => {
+            // Explicitly propagate errors instead of dropping them.
-                let input_span = value.span().unwrap_or(span);
+            Value::Error { error } => Err(error),
-                Err(ShellError::UnsupportedInput(
+            _ => Err(ShellError::UnsupportedInput(
-                    format!("input value {value:?} is not hashable"),
+                "input value is not hashable".into(),
-                    input_span,
+                format!("input type: {:?}", value.get_type()),
-                ))
+                span,
-            }
+                value.expect_span(),
+            )),
         }
     }
 
@@ -214,7 +215,7 @@ mod test {
         ];
         for (val, expect_hashable_val) in values.into_iter() {
             assert_eq!(
-                HashableValue::from_value(val, Span { start: 0, end: 0 }).unwrap(),
+                HashableValue::from_value(val, Span::unknown()).unwrap(),
                 expect_hashable_val
             );
         }
@@ -245,7 +246,7 @@ mod test {
             },
         ];
         for v in values {
-            assert!(HashableValue::from_value(v, Span { start: 0, end: 0 }).is_err())
+            assert!(HashableValue::from_value(v, Span::unknown()).is_err())
         }
     }
 
@@ -266,7 +267,7 @@ mod test {
         for val in values.into_iter() {
             let expected_val = val.clone();
             assert_eq!(
-                HashableValue::from_value(val, Span { start: 0, end: 0 })
+                HashableValue::from_value(val, Span::unknown())
                     .unwrap()
                     .into_value(),
                 expected_val
@@ -279,14 +280,11 @@ mod test {
         assert_eq!(
             HashableValue::Bool {
                 val: true,
-                span: Span { start: 0, end: 1 }
+                span: Span::new(0, 1)
             },
             HashableValue::Bool {
                 val: true,
-                span: Span {
+                span: Span::new(90, 1000)
-                    start: 90,
-                    end: 1000
-                }
             }
         )
     }
@@ -299,7 +297,7 @@ mod test {
         assert!(set.contains(&HashableValue::Bool { val: true, span }));
 
         // hashable value doesn't care about span.
-        let diff_span = Span { start: 1, end: 2 };
+        let diff_span = Span::new(1, 2);
         set.insert(HashableValue::Bool {
             val: true,
             span: diff_span,

crates/nu-command/src/charting/histogram.rs

@@ -50,7 +50,7 @@ impl Command for Histogram {
             },
             Example {
                 description: "Compute a histogram for a list of numbers",
-                example: "echo [1 2 1] | histogram",
+                example: "[1 2 1] | histogram",
                 result: Some(Value::List {
                         vals: vec![Value::Record {
                             cols: vec!["value".to_string(), "count".to_string(), "quantile".to_string(), "percentage".to_string(), "frequency".to_string()],
@@ -80,7 +80,7 @@ impl Command for Histogram {
             },
             Example {
                 description: "Compute a histogram for a list of numbers, and percentage is based on the maximum value",
-                example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram --percentage-type relative",
+                example: "[1 2 3 1 1 1 2 2 1 1] | histogram --percentage-type relative",
                 result: None,
             }
         ]
@@ -98,12 +98,11 @@ impl Command for Histogram {
         let frequency_name_arg = call.opt::<Spanned<String>>(engine_state, stack, 1)?;
         let frequency_column_name = match frequency_name_arg {
             Some(inner) => {
-                let span = inner.span;
                 if ["value", "count", "quantile", "percentage"].contains(&inner.item.as_str()) {
-                    return Err(ShellError::UnsupportedInput(
+                    return Err(ShellError::TypeMismatch(
                         "frequency-column-name can't be 'value', 'count' or 'percentage'"
                             .to_string(),
-                        span,
+                        inner.span,
                     ));
                 }
                 inner.item
@@ -119,7 +118,7 @@ impl Command for Histogram {
                 "normalize" => PercentageCalcMethod::Normalize,
                 "relative" => PercentageCalcMethod::Relative,
                 _ => {
-                    return Err(ShellError::UnsupportedInput(
+                    return Err(ShellError::TypeMismatch(
                         "calc method can only be 'normalize' or 'relative'".to_string(),
                         inner.span,
                     ))
@@ -130,16 +129,15 @@ impl Command for Histogram {
         let span = call.head;
         let data_as_value = input.into_value(span);
         // `input` is not a list, here we can return an error.
-        match data_as_value.as_list() {
+        run_histogram(
-            Ok(list_value) => run_histogram(
+            data_as_value.as_list()?.to_vec(),
-                list_value.to_vec(),
+            column_name,
-                column_name,
+            frequency_column_name,
-                frequency_column_name,
+            calc_method,
-                calc_method,
+            span,
-                span,
+            // Note that as_list() filters out Value::Error here.
-            ),
+            data_as_value.expect_span(),
-            Err(e) => Err(e),
+        )
-        }
     }
 }
 
@@ -149,6 +147,7 @@ fn run_histogram(
     freq_column: String,
     calc_method: PercentageCalcMethod,
     head_span: Span,
+    list_span: Span,
 ) -> Result<PipelineData, ShellError> {
     let mut inputs = vec![];
     // convert from inputs to hashable values.
@@ -157,14 +156,24 @@ fn run_histogram(
             // some invalid input scenario needs to handle:
             // Expect input is a list of hashable value, if one value is not hashable, throw out error.
             for v in values {
-                let current_span = v.span().unwrap_or(head_span);
+                match v {
-                inputs.push(HashableValue::from_value(v, head_span).map_err(|_| {
+                    // Propagate existing errors.
-                    ShellError::UnsupportedInput(
+                    Value::Error { error } => return Err(error),
-                        "--column-name is not provided, can only support a list of simple value."
+                    _ => {
-                            .to_string(),
+                        let t = v.get_type();
-                        current_span,
+                        let span = v.expect_span();
-                    )
+                        inputs.push(HashableValue::from_value(v, head_span).map_err(|_| {
-                })?);
+                        ShellError::UnsupportedInput(
+                            "Since --column-name was not provided, only lists of hashable values are supported.".to_string(),
+                            format!(
+                                "input type: {t:?}"
+                            ),
+                            head_span,
+                            span,
+                        )
+                    })?)
+                    }
+                }
             }
         }
         Some(ref col) => {
@@ -186,14 +195,17 @@ fn run_histogram(
                             }
                         }
                     }
+                    // Propagate existing errors.
+                    Value::Error { error } => return Err(error),
                     _ => continue,
                 }
             }
 
             if inputs.is_empty() {
-                return Err(ShellError::UnsupportedInput(
+                return Err(ShellError::CantFindColumn(
-                    format!("expect input is table, and inputs doesn't contain any value which has {col_name} column"),
+                    col_name.clone(),
                     head_span,
+                    list_span,
                 ));
             }
         }
@@ -249,25 +261,33 @@ fn histogram_impl(
         let percentage = format!("{:.2}%", quantile * 100_f64);
         let freq = "*".repeat((MAX_FREQ_COUNT * quantile).floor() as usize);
 
-        result.push(Value::Record {
+        result.push((
-            cols: result_cols.clone(),
+            count, // attach count first for easily sorting.
-            vals: vec![
+            Value::Record {
-                val.into_value(),
+                cols: result_cols.clone(),
-                Value::Int { val: count, span },
+                vals: vec![
-                Value::Float {
+                    val.into_value(),
-                    val: quantile,
+                    Value::Int { val: count, span },
-                    span,
+                    Value::Float {
-                },
+                        val: quantile,
-                Value::String {
+                        span,
-                    val: percentage,
+                    },
-                    span,
+                    Value::String {
-                },
+                        val: percentage,
-                Value::String { val: freq, span },
+                        span,
-            ],
+                    },
-            span,
+                    Value::String { val: freq, span },
-        });
+                ],
+                span,
+            },
+        ));
     }
-    Value::List { vals: result, span }.into_pipeline_data()
+    result.sort_by(|a, b| b.0.cmp(&a.0));
+    Value::List {
+        vals: result.into_iter().map(|x| x.1).collect(),
+        span,
+    }
+    .into_pipeline_data()
 }
 
 #[cfg(test)]

crates/nu-command/src/conversions/fmt.rs

@@ -44,38 +44,14 @@ impl Command for Fmt {
                     "upperhex".into(),
                 ],
                 vals: vec![
-                    Value::String {
+                    Value::test_string("0b101010"),
-                        val: "0b101010".to_string(),
+                    Value::test_string("42"),
-                        span: Span::test_data(),
+                    Value::test_string("42"),
-                    },
+                    Value::test_string("4.2e1"),
-                    Value::String {
+                    Value::test_string("0x2a"),
-                        val: "42".to_string(),
+                    Value::test_string("0o52"),
-                        span: Span::test_data(),
+                    Value::test_string("4.2E1"),
-                    },
+                    Value::test_string("0x2A"),
-                    Value::String {
-                        val: "42".to_string(),
-                        span: Span::test_data(),
-                    },
-                    Value::String {
-                        val: "4.2e1".to_string(),
-                        span: Span::test_data(),
-                    },
-                    Value::String {
-                        val: "0x2a".to_string(),
-                        span: Span::test_data(),
-                    },
-                    Value::String {
-                        val: "0o52".to_string(),
-                        span: Span::test_data(),
-                    },
-                    Value::String {
-                        val: "4.2E1".to_string(),
-                        span: Span::test_data(),
-                    },
-                    Value::String {
-                        val: "0x2A".to_string(),
-                        span: Span::test_data(),
-                    },
                 ],
                 span: Span::test_data(),
             }),
@@ -108,10 +84,15 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
     match input {
         Value::Int { val, .. } => fmt_it(*val, span),
         Value::Filesize { val, .. } => fmt_it(*val, span),
-        _ => Value::Error {
+        // Propagate errors by explicitly matching them before the final case.
-            error: ShellError::UnsupportedInput(
+        Value::Error { .. } => input.clone(),
-                format!("unsupported input type: {:?}", input.get_type()),
+        other => Value::Error {
+            error: ShellError::OnlySupportsThisInputType(
+                "integer or filesize".into(),
+                other.get_type().to_string(),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }
@@ -122,31 +103,31 @@ fn fmt_it(num: i64, span: Span) -> Value {
     let mut vals = vec![];
 
     cols.push("binary".into());
-    vals.push(Value::string(format!("{:#b}", num), span));
+    vals.push(Value::string(format!("{num:#b}"), span));
 
     cols.push("debug".into());
-    vals.push(Value::string(format!("{:#?}", num), span));
+    vals.push(Value::string(format!("{num:#?}"), span));
 
     cols.push("display".into());
-    vals.push(Value::string(format!("{}", num), span));
+    vals.push(Value::string(format!("{num}"), span));
 
     cols.push("lowerexp".into());
-    vals.push(Value::string(format!("{:#e}", num), span));
+    vals.push(Value::string(format!("{num:#e}"), span));
 
     cols.push("lowerhex".into());
-    vals.push(Value::string(format!("{:#x}", num), span));
+    vals.push(Value::string(format!("{num:#x}"), span));
 
     cols.push("octal".into());
-    vals.push(Value::string(format!("{:#o}", num), span));
+    vals.push(Value::string(format!("{num:#o}"), span));
 
     // cols.push("pointer".into());
     // vals.push(Value::string(format!("{:#p}", &num), span));
 
     cols.push("upperexp".into());
-    vals.push(Value::string(format!("{:#E}", num), span));
+    vals.push(Value::string(format!("{num:#E}"), span));
 
     cols.push("upperhex".into());
-    vals.push(Value::string(format!("{:#X}", num), span));
+    vals.push(Value::string(format!("{num:#X}"), span));
 
     Value::Record { cols, vals, span }
 }

crates/nu-command/src/conversions/into/binary.rs

@@ -177,13 +177,24 @@ pub fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
             val: int_to_endian(i64::from(*val)),
             span,
         },
+        Value::Duration { val, .. } => Value::Binary {
+            val: int_to_endian(*val),
+            span,
+        },
         Value::Date { val, .. } => Value::Binary {
             val: val.format("%c").to_string().as_bytes().to_vec(),
             span,
         },
-
+        // Propagate errors by explicitly matching them before the final case.
-        _ => Value::Error {
+        Value::Error { .. } => input.clone(),
-            error: ShellError::UnsupportedInput("'into binary' for unsupported type".into(), span),
+        other => Value::Error {
+            error: ShellError::OnlySupportsThisInputType(
+                "integer, float, filesize, string, date, duration, binary or bool".into(),
+                other.get_type().to_string(),
+                span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
+            ),
         },
     }
 }

crates/nu-command/src/conversions/into/bool.rs

@@ -54,7 +54,7 @@ impl Command for SubCommand {
         vec![
             Example {
                 description: "Convert value to boolean in table",
-                example: "echo [[value]; ['false'] ['1'] [0] [1.0] [true]] | into bool value",
+                example: "[[value]; ['false'] ['1'] [0] [1.0] [true]] | into bool value",
                 result: Some(Value::List {
                     vals: vec![
                         Value::Record {
@@ -163,10 +163,15 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
             Ok(val) => Value::Bool { val, span },
             Err(error) => Value::Error { error },
         },
-        _ => Value::Error {
+        // Propagate errors by explicitly matching them before the final case.
-            error: ShellError::UnsupportedInput(
+        Value::Error { .. } => input.clone(),
-                "'into bool' does not support this input".into(),
+        other => Value::Error {
+            error: ShellError::OnlySupportsThisInputType(
+                "bool, integer, float or string".into(),
+                other.get_type().to_string(),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/conversions/into/command.rs

@@ -2,7 +2,7 @@ use nu_engine::get_full_help;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, IntoPipelineData, PipelineData, Signature, Value,
+    Category, IntoPipelineData, PipelineData, Signature, Type, Value,
 };
 
 #[derive(Clone)]
@@ -14,13 +14,19 @@ impl Command for Into {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("into").category(Category::Conversions)
+        Signature::build("into")
+            .category(Category::Conversions)
+            .input_output_types(vec![(Type::Nothing, Type::String)])
     }
 
     fn usage(&self) -> &str {
         "Commands to convert data from one type to another."
     }
 
+    fn extra_usage(&self) -> &str {
+        "You must use one of the following subcommands. Using this command as-is will only produce this help message."
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -41,15 +47,3 @@ impl Command for Into {
         .into_pipeline_data())
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(Into {})
-    }
-}

crates/nu-command/src/conversions/into/datetime.rs

@@ -147,41 +147,19 @@ impl Command for SubCommand {
     }
 
     fn examples(&self) -> Vec<Example> {
-        let example_result_1 = |secs: i64, nsecs: u32| {
+        let example_result_1 = |secs: i64, nsecs: u32| match Utc.timestamp_opt(secs, nsecs) {
-            let dt = match Utc.timestamp_opt(secs, nsecs) {
+            LocalResult::Single(dt) => Some(Value::Date {
-                LocalResult::Single(dt) => Some(dt),
+                val: dt.into(),
-                _ => None,
+                span: Span::test_data(),
-            };
+            }),
-            match dt {
+            _ => panic!("datetime: help example is invalid"),
-                Some(dt) => Some(Value::Date {
-                    val: dt.into(),
-                    span: Span::test_data(),
-                }),
-                None => Some(Value::Error {
-                    error: ShellError::UnsupportedInput(
-                        "The given datetime representation is unsupported.".to_string(),
-                        Span::test_data(),
-                    ),
-                }),
-            }
         };
-        let example_result_2 = |millis: i64| {
+        let example_result_2 = |millis: i64| match Utc.timestamp_millis_opt(millis) {
-            let dt = match Utc.timestamp_millis_opt(millis) {
+            LocalResult::Single(dt) => Some(Value::Date {
-                LocalResult::Single(dt) => Some(dt),
+                val: dt.into(),
-                _ => None,
+                span: Span::test_data(),
-            };
+            }),
-            match dt {
+            _ => panic!("datetime: help example is invalid"),
-                Some(dt) => Some(Value::Date {
-                    val: dt.into(),
-                    span: Span::test_data(),
-                }),
-                None => Some(Value::Error {
-                    error: ShellError::UnsupportedInput(
-                        "The given datetime representation is unsupported.".to_string(),
-                        Span::test_data(),
-                    ),
-                }),
-            }
         };
         vec![
             Example {
@@ -213,7 +191,7 @@ impl Command for SubCommand {
             },
             Example {
                 description:
-                    "Convert timestamps like the sqlite history t",
+                    "Convert a millisecond-precise timestamp",
                 example: "1656165681720 | into datetime",
                 result: example_result_2(1656165681720)
             },
@@ -231,11 +209,16 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
     let timestamp = match input {
         Value::Int { val, .. } => Ok(*val),
         Value::String { val, .. } => val.parse::<i64>(),
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => return input.clone(),
         other => {
             return Value::Error {
-                error: ShellError::UnsupportedInput(
+                error: ShellError::OnlySupportsThisInputType(
-                    format!("Expected string or int, got {} instead", other.get_type()),
+                    "string and integer".into(),
+                    other.get_type().to_string(),
                     head,
+                    // This line requires the Value::Error match above.
+                    other.expect_span(),
                 ),
             };
         }
@@ -248,113 +231,68 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
         if ts.abs() > TIMESTAMP_BOUND {
             return Value::Error {
                 error: ShellError::UnsupportedInput(
-                    "Given timestamp is out of range, it should between -8e+12 and 8e+12"
+                    "timestamp is out of range; it should between -8e+12 and 8e+12".to_string(),
-                        .to_string(),
+                    format!("timestamp is {ts:?}"),
                     head,
+                    // Again, can safely unwrap this from here on
+                    input.expect_span(),
                 ),
             };
         }
 
+        macro_rules! match_datetime {
+            ($expr:expr) => {
+                match $expr {
+                    LocalResult::Single(dt) => Value::Date {
+                        val: dt.into(),
+                        span: head,
+                    },
+                    _ => {
+                        return Value::Error {
+                            error: ShellError::UnsupportedInput(
+                                "The given local datetime representation is invalid.".into(),
+                                format!("timestamp is {:?}", ts),
+                                head,
+                                head,
+                            ),
+                        };
+                    }
+                }
+            };
+        }
+
         return match timezone {
             // default to UTC
             None => {
                 // be able to convert chrono::Utc::now()
-                let dt = match ts.to_string().len() {
+                match ts.to_string().len() {
-                    x if x > 13 => Utc.timestamp_nanos(ts).into(),
+                    x if x > 13 => Value::Date {
-                    x if x > 10 => match Utc.timestamp_millis_opt(ts) {
+                        val: Utc.timestamp_nanos(ts).into(),
-                        LocalResult::Single(dt) => dt.into(),
+                        span: head,
-                        _ => {
-                            return Value::Error {
-                                // This error message is from chrono
-                                error: ShellError::UnsupportedInput(
-                                    "The given local datetime representation is invalid."
-                                        .to_string(),
-                                    head,
-                                ),
-                            };
-                        }
                     },
-                    _ => match Utc.timestamp_opt(ts, 0) {
+                    x if x > 10 => match_datetime!(Utc.timestamp_millis_opt(ts)),
-                        LocalResult::Single(dt) => dt.into(),
+                    _ => match_datetime!(Utc.timestamp_opt(ts, 0)),
-                        _ => {
-                            return Value::Error {
-                                error: ShellError::UnsupportedInput(
-                                    "The given local datetime representation is invalid."
-                                        .to_string(),
-                                    head,
-                                ),
-                            }
-                        }
-                    },
-                };
-
-                Value::Date {
-                    val: dt,
-                    span: head,
                 }
             }
             Some(Spanned { item, span }) => match item {
-                Zone::Utc => match Utc.timestamp_opt(ts, 0) {
+                Zone::Utc => match_datetime!(Utc.timestamp_opt(ts, 0)),
-                    LocalResult::Single(val) => Value::Date {
+                Zone::Local => match_datetime!(Local.timestamp_opt(ts, 0)),
-                        val: val.into(),
-                        span: head,
-                    },
-                    _ => Value::Error {
-                        error: ShellError::UnsupportedInput(
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
-                    },
-                },
-                Zone::Local => match Local.timestamp_opt(ts, 0) {
-                    LocalResult::Single(val) => Value::Date {
-                        val: val.into(),
-                        span: head,
-                    },
-                    _ => Value::Error {
-                        error: ShellError::UnsupportedInput(
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
-                    },
-                },
                 Zone::East(i) => match FixedOffset::east_opt((*i as i32) * HOUR) {
-                    Some(eastoffset) => match eastoffset.timestamp_opt(ts, 0) {
+                    Some(eastoffset) => match_datetime!(eastoffset.timestamp_opt(ts, 0)),
-                        LocalResult::Single(val) => Value::Date { val, span: head },
-                        _ => Value::Error {
-                            error: ShellError::UnsupportedInput(
-                                "The given local datetime representation is invalid.".to_string(),
-                                *span,
-                            ),
-                        },
-                    },
                     None => Value::Error {
-                        error: ShellError::UnsupportedInput(
+                        error: ShellError::DatetimeParseError(*span),
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
                     },
                 },
                 Zone::West(i) => match FixedOffset::west_opt((*i as i32) * HOUR) {
-                    Some(westoffset) => match westoffset.timestamp_opt(ts, 0) {
+                    Some(westoffset) => match_datetime!(westoffset.timestamp_opt(ts, 0)),
-                        LocalResult::Single(val) => Value::Date { val, span: head },
-                        _ => Value::Error {
-                            error: ShellError::UnsupportedInput(
-                                "The given local datetime representation is invalid.".to_string(),
-                                *span,
-                            ),
-                        },
-                    },
                     None => Value::Error {
-                        error: ShellError::UnsupportedInput(
+                        error: ShellError::DatetimeParseError(*span),
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
                     },
                 },
                 Zone::Error => Value::Error {
-                    error: ShellError::UnsupportedInput(
+                    // This is an argument error, not an input error
-                        "Cannot convert given timezone or offset to timestamp".to_string(),
+                    error: ShellError::TypeMismatch(
+                        "Invalid timezone or offset".to_string(),
                         *span,
                     ),
                 },
@@ -391,10 +329,15 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
                 },
             }
         }
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => input.clone(),
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                format!("Expected string, got {} instead", other.get_type()),
+                "string".into(),
+                other.get_type().to_string(),
                 head,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }

crates/nu-command/src/conversions/into/decimal.rs

@@ -86,7 +86,7 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
             let other = s.trim();
 
             match other.parse::<f64>() {
-                Ok(x) => Value::Float { val: x, span: head },
+                Ok(x) => Value::float(x, head),
                 Err(reason) => Value::Error {
                     error: ShellError::CantConvert(
                         "float".to_string(),
@@ -97,10 +97,7 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
                 },
             }
         }
-        Value::Int { val: v, span } => Value::Float {
+        Value::Int { val: v, span } => Value::float(*v as f64, *span),
-            val: *v as f64,
-            span: *span,
-        },
         Value::Bool { val: b, span } => Value::Float {
             val: match b {
                 true => 1.0,
@@ -108,18 +105,17 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
             },
             span: *span,
         },
-        other => {
+        // Propagate errors by explicitly matching them before the final case.
-            let span = other.span();
+        Value::Error { .. } => input.clone(),
-            match span {
+        other => Value::Error {
-                Ok(s) => {
+            error: ShellError::OnlySupportsThisInputType(
-                    let got = format!("Expected a string, got {} instead", other.get_type());
+                "string, integer or bool".into(),
-                    Value::Error {
+                other.get_type().to_string(),
-                        error: ShellError::UnsupportedInput(got, s),
+                head,
-                    }
+                // This line requires the Value::Error match above.
-                }
+                other.expect_span(),
-                Err(e) => Value::Error { error: e },
+            ),
-            }
+        },
-        }
     }
 }
 

crates/nu-command/src/conversions/into/duration.rs

@@ -65,7 +65,8 @@ impl Command for SubCommand {
         vec![
             Example {
                 description: "Convert string to duration in table",
-                example: "echo [[value]; ['1sec'] ['2min'] ['3hr'] ['4day'] ['5wk']] | into duration value",
+                example:
+                    "[[value]; ['1sec'] ['2min'] ['3hr'] ['4day'] ['5wk']] | into duration value",
                 result: Some(Value::List {
                     vals: vec![
                         Value::Record {
@@ -467,9 +468,11 @@ fn action(
                     }
                 } else {
                     Value::Error {
-                        error: ShellError::UnsupportedInput(
+                        error: ShellError::CantConvert(
-                            "'into duration' does not support this string input".into(),
+                            "string".into(),
+                            "duration".into(),
                             span,
+                            None,
                         ),
                     }
                 }
@@ -480,10 +483,15 @@ fn action(
                 }
             }
         }
-        _ => Value::Error {
+        // Propagate errors by explicitly matching them before the final case.
-            error: ShellError::UnsupportedInput(
+        Value::Error { .. } => input.clone(),
-                "'into duration' does not support this input".into(),
+        other => Value::Error {
+            error: ShellError::OnlySupportsThisInputType(
+                "string or duration".into(),
+                other.get_type().to_string(),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }
@@ -502,7 +510,7 @@ mod test {
 
     #[test]
     fn turns_ns_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 2);
         let word = Value::test_string("3ns");
         let expected = Value::Duration { val: 3, span };
         let convert_duration = None;
@@ -513,7 +521,7 @@ mod test {
 
     #[test]
     fn turns_us_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 2);
         let word = Value::test_string("4us");
         let expected = Value::Duration {
             val: 4 * 1000,
@@ -527,7 +535,7 @@ mod test {
 
     #[test]
     fn turns_ms_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 2);
         let word = Value::test_string("5ms");
         let expected = Value::Duration {
             val: 5 * 1000 * 1000,
@@ -541,7 +549,7 @@ mod test {
 
     #[test]
     fn turns_sec_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 3);
         let word = Value::test_string("1sec");
         let expected = Value::Duration {
             val: 1000 * 1000 * 1000,
@@ -555,7 +563,7 @@ mod test {
 
     #[test]
     fn turns_min_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 3);
         let word = Value::test_string("7min");
         let expected = Value::Duration {
             val: 7 * 60 * 1000 * 1000 * 1000,
@@ -569,7 +577,7 @@ mod test {
 
     #[test]
     fn turns_hr_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 3);
         let word = Value::test_string("42hr");
         let expected = Value::Duration {
             val: 42 * 60 * 60 * 1000 * 1000 * 1000,
@@ -583,7 +591,7 @@ mod test {
 
     #[test]
     fn turns_day_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 5);
         let word = Value::test_string("123day");
         let expected = Value::Duration {
             val: 123 * 24 * 60 * 60 * 1000 * 1000 * 1000,
@@ -597,7 +605,7 @@ mod test {
 
     #[test]
     fn turns_wk_to_duration() {
-        let span = Span::test_data();
+        let span = Span::new(0, 2);
         let word = Value::test_string("3wk");
         let expected = Value::Duration {
             val: 3 * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000,

crates/nu-command/src/conversions/into/filesize.rs

@@ -116,20 +116,18 @@ pub fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
                 val: 0,
                 span: value_span,
             },
-            _ => Value::Error {
+            other => Value::Error {
-                error: ShellError::UnsupportedInput(
+                error: ShellError::OnlySupportsThisInputType(
-                    "'into filesize' for unsupported type".into(),
+                    "string and integer".into(),
+                    other.get_type().to_string(),
+                    span,
                     value_span,
                 ),
             },
         }
     } else {
-        Value::Error {
+        // Propagate existing errors
-            error: ShellError::UnsupportedInput(
+        input.clone()
-                "'into filesize' for unsupported type".into(),
-                span,
-            ),
-        }
     }
 }
 fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {

crates/nu-command/src/conversions/into/int.rs

@@ -70,7 +70,7 @@ impl Command for SubCommand {
         let radix: u32 = match radix {
             Some(Value::Int { val, span }) => {
                 if !(2..=36).contains(&val) {
-                    return Err(ShellError::UnsupportedInput(
+                    return Err(ShellError::TypeMismatch(
                         "Radix must lie in the range [2, 36]".to_string(),
                         span,
                     ));
@@ -92,7 +92,7 @@ impl Command for SubCommand {
         vec![
             Example {
                 description: "Convert string to integer in table",
-                example: "echo [[num]; ['-5'] [4] [1.5]] | into int num",
+                example: "[[num]; ['-5'] [4] [1.5]] | into int num",
                 result: None,
             },
             Example {
@@ -113,10 +113,7 @@ impl Command for SubCommand {
             Example {
                 description: "Convert file size to integer",
                 example: "4KB | into int",
-                result: Some(Value::Int {
+                result: Some(Value::test_int(4000)),
-                    val: 4000,
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "Convert bool to integer",
@@ -190,9 +187,11 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
                         Ok(v) => v,
                         _ => {
                             return Value::Error {
-                                error: ShellError::UnsupportedInput(
+                                error: ShellError::CantConvert(
-                                    "Could not convert float to integer".to_string(),
+                                    "float".to_string(),
+                                    "integer".to_string(),
                                     span,
+                                    None,
                                 ),
                             }
                         }
@@ -222,6 +221,7 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
             val: val.timestamp(),
             span,
         },
+        Value::Duration { val, .. } => Value::Int { val: *val, span },
         Value::Binary { val, span } => {
             use byteorder::{BigEndian, ByteOrder, LittleEndian};
 
@@ -233,26 +233,25 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
                 }
                 val.resize(8, 0);
 
-                Value::Int {
+                Value::int(LittleEndian::read_i64(&val), *span)
-                    val: LittleEndian::read_i64(&val),
-                    span: *span,
-                }
             } else {
                 while val.len() < 8 {
                     val.insert(0, 0);
                 }
                 val.resize(8, 0);
 
-                Value::Int {
+                Value::int(BigEndian::read_i64(&val), *span)
-                    val: BigEndian::read_i64(&val),
-                    span: *span,
-                }
             }
         }
-        _ => Value::Error {
+        // Propagate errors by explicitly matching them before the final case.
-            error: ShellError::UnsupportedInput(
+        Value::Error { .. } => input.clone(),
-                format!("'into int' for unsupported type '{}'", input.get_type()),
+        other => Value::Error {
+            error: ShellError::OnlySupportsThisInputType(
+                "integer, float, filesize, date, string, binary, duration or bool".into(),
+                other.get_type().to_string(),
                 span,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     }
@@ -269,13 +268,13 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
             // octal
             {
                 match int_from_string(val, head) {
-                    Ok(x) => return Value::Int { val: x, span: head },
+                    Ok(x) => return Value::int(x, head),
                     Err(e) => return Value::Error { error: e },
                 }
             } else if val.starts_with("00") {
                 // It's a padded string
                 match i64::from_str_radix(val, radix) {
-                    Ok(n) => return Value::Int { val: n, span: head },
+                    Ok(n) => return Value::int(n, head),
                     Err(e) => {
                         return Value::Error {
                             error: ShellError::CantConvert(
@@ -290,17 +289,22 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
             }
             val.to_string()
         }
-        _ => {
+        // Propagate errors by explicitly matching them before the final case.
+        Value::Error { .. } => return input.clone(),
+        other => {
             return Value::Error {
-                error: ShellError::UnsupportedInput(
+                error: ShellError::OnlySupportsThisInputType(
-                    "only strings or integers are supported".to_string(),
+                    "string and integer".into(),
+                    other.get_type().to_string(),
                     head,
+                    // This line requires the Value::Error match above.
+                    other.expect_span(),
                 ),
-            }
+            };
         }
     };
     match i64::from_str_radix(i.trim(), radix) {
-        Ok(n) => Value::Int { val: n, span: head },
+        Ok(n) => Value::int(n, head),
         Err(_reason) => Value::Error {
             error: ShellError::CantConvert("string".to_string(), "int".to_string(), head, None),
         },
@@ -363,8 +367,7 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
                     "string".to_string(),
                     span,
                     Some(format!(
-                        r#"string "{}" does not represent a valid integer"#,
+                        r#"string "{trimmed}" does not represent a valid integer"#
-                        trimmed
                     )),
                 )),
             },

crates/nu-command/src/conversions/into/record.rs

@@ -49,7 +49,7 @@ impl Command for SubCommand {
         vec![
             Example {
                 description: "Convert from one row table to record",
-                example: "echo [[value]; [false]] | into record",
+                example: "[[value]; [false]] | into record",
                 result: Some(Value::Record {
                     cols: vec!["value".to_string()],
                     vals: vec![Value::boolean(false, span)],
@@ -183,10 +183,14 @@ fn into_record(
             Value::Record { cols, vals, span }
         }
         Value::Record { cols, vals, span } => Value::Record { cols, vals, span },
+        Value::Error { .. } => input,
         other => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::OnlySupportsThisInputType(
-                "'into record' does not support this input".into(),
+                "string".into(),
-                other.span().unwrap_or(call.head),
+                other.get_type().to_string(),
+                call.head,
+                // This line requires the Value::Error match above.
+                other.expect_span(),
             ),
         },
     };

crates/nu-command/src/conversions/into/string.rs

@@ -79,34 +79,22 @@ impl Command for SubCommand {
             Example {
                 description: "convert integer to string and append three decimal places",
                 example: "5 | into string -d 3",
-                result: Some(Value::String {
+                result: Some(Value::test_string("5.000")),
-                    val: "5.000".to_string(),
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "convert decimal to string and round to nearest integer",
                 example: "1.7 | into string -d 0",
-                result: Some(Value::String {
+                result: Some(Value::test_string("2")),
-                    val: "2".to_string(),
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "convert decimal to string",
                 example: "1.7 | into string -d 1",
-                result: Some(Value::String {
+                result: Some(Value::test_string("1.7")),
-                    val: "1.7".to_string(),
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "convert decimal to string and limit to 2 decimals",
                 example: "1.734 | into string -d 2",
-                result: Some(Value::String {
+                result: Some(Value::test_string("1.73")),
-                    val: "1.73".to_string(),
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "try to convert decimal to string and provide negative decimal points",
@@ -123,26 +111,17 @@ impl Command for SubCommand {
             Example {
                 description: "convert decimal to string",
                 example: "4.3 | into string",
-                result: Some(Value::String {
+                result: Some(Value::test_string("4.3")),
-                    val: "4.3".to_string(),
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "convert string to string",
                 example: "'1234' | into string",
-                result: Some(Value::String {
+                result: Some(Value::test_string("1234")),
-                    val: "1234".to_string(),
-                    span: Span::test_data(),
-                }),
             },
             Example {
                 description: "convert boolean to string",
                 example: "true | into string",
-                result: Some(Value::String {
+                result: Some(Value::test_string("true")),
-                    val: "true".to_string(),
-                    span: Span::test_data(),
-                }),
             },
             // TODO: This should work but does not; see https://github.com/nushell/nushell/issues/7032
             // Example {
@@ -175,7 +154,7 @@ fn string_helper(
     let decimals_value: Option<i64> = call.get_flag(engine_state, stack, "decimals")?;
     if let Some(decimal_val) = decimals_value {
         if decimals && decimal_val.is_negative() {
-            return Err(ShellError::UnsupportedInput(
+            return Err(ShellError::TypeMismatch(
                 "Cannot accept negative integers for decimals arguments".to_string(),
                 head,
             ));
@@ -227,7 +206,7 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
             if decimals {
                 let decimal_value = digits.unwrap_or(2) as usize;
                 Value::String {
-                    val: format!("{:.*}", decimal_value, val),
+                    val: format!("{val:.decimal_value$}"),
                     span,
                 }
             } else {
@@ -255,12 +234,7 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
             span,
         },
         Value::Error { error } => Value::String {
-            val: {
+            val: into_code(error).unwrap_or_default(),
-                match into_code(error) {
-                    Some(code) => code,
-                    None => "".to_string(),
-                }
-            },
             span,
         },
         Value::Nothing { .. } => Value::String {
@@ -272,9 +246,11 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
             vals: _,
             span: _,
         } => Value::Error {
-            error: ShellError::UnsupportedInput(
+            error: ShellError::CantConvert(
-                "Cannot convert Record into string".to_string(),
+                "record".into(),
+                "string".into(),
                 span,
+                Some("try using the `to nuon` command".into()),
             ),
         },
         Value::Binary { .. } => Value::Error {

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

@@ -43,10 +43,10 @@ impl Command for Alias {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

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

@@ -37,14 +37,13 @@ impl Command for Ast {
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let head = call.head;
         let pipeline: Spanned<String> = call.req(engine_state, stack, 0)?;
         let mut working_set = StateWorkingSet::new(engine_state);
 
         let (output, err) = parse(&mut working_set, None, pipeline.item.as_bytes(), false, &[]);
-        eprintln!("output: {:#?}\nerror: {:#?}", output, err);
+        eprintln!("output: {output:#?}\nerror: {err:#?}");
 
-        Ok(PipelineData::new(head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

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

@@ -0,0 +1,104 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, SyntaxShape, Type};
+
+#[derive(Clone)]
+pub struct Const;
+
+impl Command for Const {
+    fn name(&self) -> &str {
+        "const"
+    }
+
+    fn usage(&self) -> &str {
+        "Create a parse-time constant."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("const")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .allow_variants_without_examples(true)
+            .required("const_name", SyntaxShape::VarWithOptType, "constant name")
+            .required(
+                "initial_value",
+                SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
+                "equals sign followed by constant value",
+            )
+            .category(Category::Core)
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"This command is a parser keyword. For details, check:
+  https://www.nushell.sh/book/thinking_in_nu.html"#
+    }
+
+    fn is_parser_keyword(&self) -> bool {
+        true
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["set", "let"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let var_id = call
+            .positional_nth(0)
+            .expect("checked through parser")
+            .as_var()
+            .expect("internal error: missing variable");
+
+        if let Some(constval) = engine_state.find_constant(var_id, &[]) {
+            // Instead of creating a second copy of the value in the stack, we could change
+            // stack.get_var() to check engine_state.find_constant().
+            stack.add_var(var_id, constval.clone());
+
+            Ok(PipelineData::empty())
+        } else {
+            Err(ShellError::NushellFailedSpanned(
+                "Missing Constant".to_string(),
+                "constant not added by the parser".to_string(),
+                call.head,
+            ))
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create a new parse-time constant.",
+                example: "const x = 10",
+                result: None,
+            },
+            Example {
+                description: "Create a composite constant value",
+                example: "const x = { a: 10, b: 20 }",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use nu_protocol::engine::CommandType;
+
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Const {})
+    }
+
+    #[test]
+    fn test_command_type() {
+        assert!(matches!(Const.command_type(), CommandType::Keyword));
+    }
+}

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

@@ -39,6 +39,8 @@ impl Command for Debug {
         let config = engine_state.get_config().clone();
         let raw = call.has_flag("raw");
 
+        // Should PipelineData::Empty result in an error here?
+
         input.map(
             move |x| {
                 if raw {
@@ -74,7 +76,7 @@ impl Command for Debug {
             },
             Example {
                 description: "Debug print a table",
-                example: "echo [[version patch]; [0.1.0 false] [0.1.1 true] [0.2.0 false]] | debug",
+                example: "[[version patch]; [0.1.0 false] [0.1.1 true] [0.2.0 false]] | debug",
                 result: Some(Value::List {
                     vals: vec![
                         Value::test_string("{version: 0.1.0, patch: false}"),

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

@@ -36,10 +36,10 @@ impl Command for Def {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct DefEnv;
@@ -62,20 +62,17 @@ def-env cd_with_fallback [arg = ""] {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Set environment variable by call a custom command",
             example: r#"def-env foo [] { let-env BAR = "BAZ" }; foo; $env.BAR"#,
-            result: Some(Value::String {
+            result: Some(Value::test_string("BAZ")),
-                val: "BAZ".to_string(),
-                span: Span::test_data(),
-            }),
         }]
     }
 }

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

@@ -19,6 +19,11 @@ impl Command for Describe {
     fn signature(&self) -> Signature {
         Signature::build("describe")
             .input_output_types(vec![(Type::Any, Type::String)])
+            .switch(
+                "no-collect",
+                "do not collect streams of structured data",
+                Some('n'),
+            )
             .category(Category::Core)
     }
 
@@ -30,32 +35,58 @@ impl Command for Describe {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let head = call.head;
-        if matches!(input, PipelineData::ExternalStream { .. }) {
-            Ok(PipelineData::Value(
-                Value::string("raw input", call.head),
-                None,
-            ))
-        } else {
-            let value = input.into_value(call.head);
-            let description = match value {
-                Value::CustomValue { val, .. } => val.value_string(),
-                _ => value.get_type().to_string(),
-            };
 
-            Ok(Value::String {
+        let no_collect: bool = call.has_flag("no-collect");
-                val: description,
+
-                span: head,
+        let description = match input {
+            PipelineData::ExternalStream { .. } => "raw input".into(),
+            PipelineData::ListStream(_, _) => {
+                if no_collect {
+                    "stream".into()
+                } else {
+                    let value = input.into_value(head);
+                    let base_description = match value {
+                        Value::CustomValue { val, .. } => val.value_string(),
+                        _ => value.get_type().to_string(),
+                    };
+
+                    format!("{base_description} (stream)")
+                }
             }
-            .into_pipeline_data())
+            _ => {
+                let value = input.into_value(head);
+                match value {
+                    Value::CustomValue { val, .. } => val.value_string(),
+                    _ => value.get_type().to_string(),
+                }
+            }
+        };
+
+        Ok(Value::String {
+            val: description,
+            span: head,
         }
+        .into_pipeline_data())
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
+        vec![
-            description: "Describe the type of a string",
+            Example {
-            example: "'hello' | describe",
+                description: "Describe the type of a string",
-            result: Some(Value::test_string("string")),
+                example: "'hello' | describe",
-        }]
+                result: Some(Value::test_string("string")),
+            },
+            Example {
+                description: "Describe a stream of data, collecting it first",
+                example: "[1 2 3] | each {|i| $i} | describe",
+                result: Some(Value::test_string("list<int> (stream)")),
+            },
+            Example {
+                description: "Describe the input but do not collect streams",
+                example: "[1 2 3] | each {|i| $i} | describe --no-collect",
+                result: Some(Value::test_string("stream")),
+            },
+        ]
     }
 
     fn search_terms(&self) -> Vec<&str> {

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

@@ -1,8 +1,11 @@
+use std::thread;
+
 use nu_engine::{eval_block_with_early_return, CallExt};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Closure, Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, ListStream, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
+    Category, Example, ListStream, PipelineData, RawStream, ShellError, Signature, SyntaxShape,
+    Type, Value,
 };
 
 #[derive(Clone)]
@@ -14,7 +17,7 @@ impl Command for Do {
     }
 
     fn usage(&self) -> &str {
-        "Run a block"
+        "Run a closure, providing it with the pipeline input"
     }
 
     fn signature(&self) -> Signature {
@@ -23,25 +26,25 @@ impl Command for Do {
             .input_output_types(vec![(Type::Any, Type::Any)])
             .switch(
                 "ignore-errors",
-                "ignore errors as the block runs",
+                "ignore errors as the closure runs",
                 Some('i'),
             )
             .switch(
                 "ignore-shell-errors",
-                "ignore shell errors as the block runs",
+                "ignore shell errors as the closure runs",
                 Some('s'),
             )
             .switch(
                 "ignore-program-errors",
-                "ignore program errors as the block runs",
+                "ignore external program errors as the closure runs",
                 Some('p'),
             )
             .switch(
                 "capture-errors",
-                "capture errors as the block runs and return it",
+                "catch errors as the closure runs, and return them",
                 Some('c'),
             )
-            .rest("rest", SyntaxShape::Any, "the parameter(s) for the block")
+            .rest("rest", SyntaxShape::Any, "the parameter(s) for the closure")
             .category(Category::Core)
     }
 
@@ -106,7 +109,7 @@ impl Command for Do {
             block,
             input,
             call.redirect_stdout,
-            capture_errors || ignore_shell_errors || ignore_program_errors,
+            call.redirect_stdout,
         );
 
         match result {
@@ -118,6 +121,58 @@ impl Command for Do {
                 metadata,
                 trim_end_newline,
             }) if capture_errors => {
+                // Use a thread to receive stdout message.
+                // Or we may get a deadlock if child process sends out too much bytes to stderr.
+                //
+                // For example: in normal linux system, stderr pipe's limit is 65535 bytes.
+                // if child process sends out 65536 bytes, the process will be hanged because no consumer
+                // consumes the first 65535 bytes
+                // So we need a thread to receive stdout message, then the current thread can continue to consume
+                // stderr messages.
+                let stdout_handler = stdout.map(|stdout_stream| {
+                    thread::Builder::new()
+                        .name("stderr redirector".to_string())
+                        .spawn(move || {
+                            let ctrlc = stdout_stream.ctrlc.clone();
+                            let span = stdout_stream.span;
+                            RawStream::new(
+                                Box::new(
+                                    vec![stdout_stream.into_bytes().map(|s| s.item)].into_iter(),
+                                ),
+                                ctrlc,
+                                span,
+                                None,
+                            )
+                        })
+                        .expect("Failed to create thread")
+                });
+
+                // Intercept stderr so we can return it in the error if the exit code is non-zero.
+                // The threading issues mentioned above dictate why we also need to intercept stdout.
+                let mut stderr_ctrlc = None;
+                let stderr_msg = match stderr {
+                    None => "".to_string(),
+                    Some(stderr_stream) => {
+                        stderr_ctrlc = stderr_stream.ctrlc.clone();
+                        stderr_stream.into_string().map(|s| s.item)?
+                    }
+                };
+
+                let stdout = if let Some(handle) = stdout_handler {
+                    match handle.join() {
+                        Err(err) => {
+                            return Err(ShellError::ExternalCommand(
+                                "Fail to receive external commands stdout message".to_string(),
+                                format!("{err:?}"),
+                                span,
+                            ));
+                        }
+                        Ok(res) => Some(res),
+                    }
+                } else {
+                    None
+                };
+
                 let mut exit_code_ctrlc = None;
                 let exit_code: Vec<Value> = match exit_code {
                     None => vec![],
@@ -128,11 +183,6 @@ impl Command for Do {
                 };
                 if let Some(Value::Int { val: code, .. }) = exit_code.last() {
                     if *code != 0 {
-                        let stderr_msg = match stderr {
-                            None => "".to_string(),
-                            Some(stderr_stream) => stderr_stream.into_string().map(|s| s.item)?,
-                        };
-
                         return Err(ShellError::ExternalCommand(
                             "External command failed".to_string(),
                             stderr_msg,
@@ -143,7 +193,12 @@ impl Command for Do {
 
                 Ok(PipelineData::ExternalStream {
                     stdout,
-                    stderr,
+                    stderr: Some(RawStream::new(
+                        Box::new(vec![Ok(stderr_msg.into_bytes())].into_iter()),
+                        stderr_ctrlc,
+                        span,
+                        None,
+                    )),
                     exit_code: Some(ListStream::from_stream(
                         exit_code.into_iter(),
                         exit_code_ctrlc,
@@ -168,10 +223,9 @@ impl Command for Do {
                 metadata,
                 trim_end_newline,
             }),
-            Ok(PipelineData::Value(Value::Error { .. }, ..)) if ignore_shell_errors => {
+            Ok(PipelineData::Value(Value::Error { .. }, ..)) | Err(_) if ignore_shell_errors => {
-                Ok(PipelineData::new(call.head))
+                Ok(PipelineData::empty())
             }
-            Err(_) if ignore_shell_errors => Ok(PipelineData::new(call.head)),
             r => r,
         }
     }
@@ -179,22 +233,27 @@ impl Command for Do {
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "Run the block",
+                description: "Run the closure",
                 example: r#"do { echo hello }"#,
                 result: Some(Value::test_string("hello")),
             },
             Example {
-                description: "Run the block and ignore both shell and program errors",
+                description: "Run a stored first-class closure",
+                example: r#"let text = "I am enclosed"; let hello = {|| echo $text}; do $hello"#,
+                result: Some(Value::test_string("I am enclosed")),
+            },
+            Example {
+                description: "Run the closure and ignore both shell and external program errors",
                 example: r#"do -i { thisisnotarealcommand }"#,
                 result: None,
             },
             Example {
-                description: "Run the block and ignore shell errors",
+                description: "Run the closure and ignore shell errors",
                 example: r#"do -s { thisisnotarealcommand }"#,
                 result: None,
             },
             Example {
-                description: "Run the block and ignore program errors",
+                description: "Run the closure and ignore external program errors",
                 example: r#"do -p { nu -c 'exit 1' }; echo "I'll still run""#,
                 result: None,
             },
@@ -204,12 +263,12 @@ impl Command for Do {
                 result: None,
             },
             Example {
-                description: "Run the block, with a positional parameter",
+                description: "Run the closure, with a positional parameter",
                 example: r#"do {|x| 100 + $x } 77"#,
                 result: Some(Value::test_int(177)),
             },
             Example {
-                description: "Run the block, with input",
+                description: "Run the closure, with input",
                 example: r#"77 | do {|x| 100 + $in }"#,
                 result: None, // TODO: returns 177
             },

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

@@ -51,13 +51,7 @@ little reason to use this over just writing the values as-is."#
                 std::cmp::Ordering::Equal => PipelineData::Value(to_be_echoed[0].clone(), None),
 
                 //  When there are no elements, we echo the empty string
-                std::cmp::Ordering::Less => PipelineData::Value(
+                std::cmp::Ordering::Less => PipelineData::Value(Value::string("", call.head), None),
-                    Value::String {
-                        val: "".to_string(),
-                        span: call.head,
-                    },
-                    None,
-                ),
             }
         })
     }

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

@@ -2,7 +2,7 @@ use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
 
 #[derive(Clone)]
@@ -15,6 +15,7 @@ impl Command for ErrorMake {
 
     fn signature(&self) -> Signature {
         Signature::build("error make")
+            .input_output_types(vec![(Type::Nothing, Type::Error)])
             .required("error_struct", SyntaxShape::Record, "the error to create")
             .switch(
                 "unspanned",
@@ -108,10 +109,7 @@ fn make_error(value: &Value, throw_span: Option<Span>) -> Option<ShellError> {
                     ) => Some(ShellError::GenericError(
                         message,
                         label_text,
-                        Some(Span {
+                        Some(Span::new(start as usize, end as usize)),
-                            start: start as usize,
-                            end: end as usize,
-                        }),
                         None,
                         Vec::new(),
                     )),

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

@@ -2,7 +2,7 @@ use nu_engine::get_full_help;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, Signature, Span, Type, Value,
+    Category, Example, IntoPipelineData, PipelineData, Signature, Type, Value,
 };
 
 #[derive(Clone)]
@@ -56,10 +56,7 @@ impl Command for ExportCommand {
         vec![Example {
             description: "Export a definition from a module",
             example: r#"module utils { export def my-command [] { "hello" } }; use utils my-command; my-command"#,
-            result: Some(Value::String {
+            result: Some(Value::test_string("hello")),
-                val: "hello".to_string(),
-                span: Span::test_data(),
-            }),
         }]
     }
 

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

@@ -39,10 +39,10 @@ impl Command for ExportAlias {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct ExportDef;
@@ -36,20 +36,17 @@ impl Command for ExportDef {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Define a custom command in a module and call it",
             example: r#"module spam { export def foo [] { "foo" } }; use spam foo; foo"#,
-            result: Some(Value::String {
+            result: Some(Value::test_string("foo")),
-                val: "foo".to_string(),
-                span: Span::test_data(),
-            }),
         }]
     }
 

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct ExportDefEnv;
@@ -62,20 +62,17 @@ export def-env cd_with_fallback [arg = ""] {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Define a custom command that participates in the environment in a module and call it",
             example: r#"module foo { export def-env bar [] { let-env FOO_BAR = "BAZ" } }; use foo bar; bar; $env.FOO_BAR"#,
-            result: Some(Value::String {
+            result: Some(Value::test_string("BAZ")),
-                val: "BAZ".to_string(),
-                span: Span::test_data(),
-            }),
         }]
     }
 

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

@@ -35,10 +35,10 @@ impl Command for ExportExtern {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct ExportUse;
@@ -17,7 +17,12 @@ impl Command for ExportUse {
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("export use")
             .input_output_types(vec![(Type::Nothing, Type::Nothing)])
-            .required("pattern", SyntaxShape::ImportPattern, "import pattern")
+            .required("module", SyntaxShape::String, "Module or module file")
+            .optional(
+                "members",
+                SyntaxShape::Any,
+                "Which members of the module to import",
+            )
             .category(Category::Core)
     }
 
@@ -34,10 +39,10 @@ impl Command for ExportUse {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -48,10 +53,7 @@ impl Command for ExportUse {
     use eggs foo
     foo
             "#,
-            result: Some(Value::String {
+            result: Some(Value::test_string("foo")),
-                val: "foo".to_string(),
-                span: Span::test_data(),
-            }),
         }]
     }
 

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

@@ -35,10 +35,10 @@ impl Command for Extern {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        call: &Call,
+        _call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::new(call.head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

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

@@ -2,7 +2,7 @@ use nu_engine::{eval_block, eval_expression, CallExt};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Block, Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, ListStream, PipelineData, ShellError, Signature, SyntaxShape, Value,
+    Category, Example, ListStream, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
 };
 
 #[derive(Clone)]
@@ -19,6 +19,8 @@ impl Command for For {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("for")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .allow_variants_without_examples(true)
             .required(
                 "var_name",
                 SyntaxShape::VarWithOptType,
@@ -91,13 +93,7 @@ impl Command for For {
                         if numbered {
                             Value::Record {
                                 cols: vec!["index".into(), "item".into()],
-                                vals: vec![
+                                vals: vec![Value::int(idx as i64, head), x],
-                                    Value::Int {
-                                        val: idx as i64,
-                                        span: head,
-                                    },
-                                    x,
-                                ],
                                 span: head,
                             }
                         } else {
@@ -110,7 +106,7 @@ impl Command for For {
                         &engine_state,
                         stack,
                         &block,
-                        PipelineData::new(head),
+                        PipelineData::empty(),
                         redirect_stdout,
                         redirect_stderr,
                     ) {
@@ -124,7 +120,10 @@ impl Command for For {
                             return Err(err);
                         }
                         Ok(pipeline) => {
-                            pipeline.into_value(head);
+                            let exit_code = pipeline.print(&engine_state, stack, false, false)?;
+                            if exit_code != 0 {
+                                break;
+                            }
                         }
                     }
                 }
@@ -136,13 +135,7 @@ impl Command for For {
                         if numbered {
                             Value::Record {
                                 cols: vec!["index".into(), "item".into()],
-                                vals: vec![
+                                vals: vec![Value::int(idx as i64, head), x],
-                                    Value::Int {
-                                        val: idx as i64,
-                                        span: head,
-                                    },
-                                    x,
-                                ],
                                 span: head,
                             }
                         } else {
@@ -155,7 +148,7 @@ impl Command for For {
                         &engine_state,
                         stack,
                         &block,
-                        PipelineData::new(head),
+                        PipelineData::empty(),
                         redirect_stdout,
                         redirect_stderr,
                     ) {
@@ -169,7 +162,10 @@ impl Command for For {
                             return Err(err);
                         }
                         Ok(pipeline) => {
-                            pipeline.into_value(head);
+                            let exit_code = pipeline.print(&engine_state, stack, false, false)?;
+                            if exit_code != 0 {
+                                break;
+                            }
                         }
                     }
                 }
@@ -181,14 +177,14 @@ impl Command for For {
                     &engine_state,
                     stack,
                     &block,
-                    PipelineData::new(head),
+                    PipelineData::empty(),
                     redirect_stdout,
                     redirect_stderr,
                 )?
                 .into_value(head);
             }
         }
-        Ok(PipelineData::new(head))
+        Ok(PipelineData::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

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

@@ -1,17 +1,18 @@
+use crate::help_aliases::help_aliases;
+use crate::help_commands::help_commands;
+use crate::help_modules::help_modules;
 use fancy_regex::Regex;
 use nu_ansi_term::{
-    Color::{Default, Red, White},
+    Color::{Red, White},
     Style,
 };
-use nu_color_config::get_color_config;
+use nu_engine::CallExt;
-use nu_engine::{get_full_help, CallExt};
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    span, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
+    span, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Spanned,
-    ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
+    SyntaxShape, Type, Value,
 };
-use std::borrow::Borrow;
 #[derive(Clone)]
 pub struct Help;
 
@@ -26,7 +27,7 @@ impl Command for Help {
             .rest(
                 "rest",
                 SyntaxShape::String,
-                "the name of command to get help on",
+                "the name of command, alias or module to get help on",
             )
             .named(
                 "find",
@@ -38,7 +39,11 @@ impl Command for Help {
     }
 
     fn usage(&self) -> &str {
-        "Display help information about commands."
+        "Display help information about different parts of Nushell."
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"`help word` searches for "word" in commands, aliases and modules, in that order."#
     }
 
     fn run(
@@ -48,275 +53,18 @@ impl Command for Help {
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        help(engine_state, stack, call)
+        let head = call.head;
-    }
+        let find: Option<Spanned<String>> = call.get_flag(engine_state, stack, "find")?;
+        let rest: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
 
-    fn examples(&self) -> Vec<Example> {
+        if rest.is_empty() && find.is_none() {
-        vec![
+            let msg = r#"Welcome to Nushell.
-            Example {
-                description: "show all commands and sub-commands",
-                example: "help commands",
-                result: None,
-            },
-            Example {
-                description: "show help for single command",
-                example: "help match",
-                result: None,
-            },
-            Example {
-                description: "show help for single sub-command",
-                example: "help str lpad",
-                result: None,
-            },
-            Example {
-                description: "search for string in command names, usage and search terms",
-                example: "help --find char",
-                result: None,
-            },
-        ]
-    }
-}
-
-fn help(
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    call: &Call,
-) -> Result<PipelineData, ShellError> {
-    let head = call.head;
-    let find: Option<Spanned<String>> = call.get_flag(engine_state, stack, "find")?;
-    let rest: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
-    let commands = engine_state.get_decl_ids_sorted(false);
-    let config = engine_state.get_config();
-    let color_hm = get_color_config(config);
-    let default_style = Style::new().fg(Default).on(Default);
-    let string_style = match color_hm.get("string") {
-        Some(style) => style,
-        None => &default_style,
-    };
-
-    if let Some(f) = find {
-        let org_search_string = f.item.clone();
-        let search_string = f.item.to_lowercase();
-        let mut found_cmds_vec = Vec::new();
-
-        for decl_id in commands {
-            let mut cols = vec![];
-            let mut vals = vec![];
-            let decl = engine_state.get_decl(decl_id);
-            let sig = decl.signature().update_from_command(decl.borrow());
-            let signatures = sig.to_string();
-            let key = sig.name;
-            let usage = sig.usage;
-            let search_terms = sig.search_terms;
-
-            let matches_term = if !search_terms.is_empty() {
-                search_terms
-                    .iter()
-                    .any(|term| term.to_lowercase().contains(&search_string))
-            } else {
-                false
-            };
-
-            let key_match = key.to_lowercase().contains(&search_string);
-            let usage_match = usage.to_lowercase().contains(&search_string);
-            if key_match || usage_match || matches_term {
-                cols.push("name".into());
-                vals.push(Value::String {
-                    val: if key_match {
-                        highlight_search_string(&key, &org_search_string, string_style)?
-                    } else {
-                        key
-                    },
-                    span: head,
-                });
-
-                cols.push("category".into());
-                vals.push(Value::String {
-                    val: sig.category.to_string(),
-                    span: head,
-                });
-
-                cols.push("command_type".into());
-                vals.push(Value::String {
-                    val: format!("{:?}", decl.command_type()).to_lowercase(),
-                    span: head,
-                });
-
-                cols.push("usage".into());
-                vals.push(Value::String {
-                    val: if usage_match {
-                        highlight_search_string(&usage, &org_search_string, string_style)?
-                    } else {
-                        usage
-                    },
-                    span: head,
-                });
-
-                cols.push("signatures".into());
-                vals.push(Value::String {
-                    val: if decl.is_parser_keyword() {
-                        "".to_string()
-                    } else {
-                        signatures
-                    },
-                    span: head,
-                });
-
-                cols.push("search_terms".into());
-                vals.push(if search_terms.is_empty() {
-                    Value::nothing(head)
-                } else {
-                    Value::String {
-                        val: if matches_term {
-                            search_terms
-                                .iter()
-                                .map(|term| {
-                                    if term.to_lowercase().contains(&search_string) {
-                                        match highlight_search_string(
-                                            term,
-                                            &org_search_string,
-                                            string_style,
-                                        ) {
-                                            Ok(s) => s,
-                                            Err(_) => {
-                                                string_style.paint(term.to_string()).to_string()
-                                            }
-                                        }
-                                    } else {
-                                        string_style.paint(term.to_string()).to_string()
-                                    }
-                                })
-                                .collect::<Vec<_>>()
-                                .join(", ")
-                        } else {
-                            search_terms.join(", ")
-                        },
-                        span: head,
-                    }
-                });
-
-                found_cmds_vec.push(Value::Record {
-                    cols,
-                    vals,
-                    span: head,
-                });
-            }
-        }
-
-        return Ok(found_cmds_vec
-            .into_iter()
-            .into_pipeline_data(engine_state.ctrlc.clone()));
-    }
-
-    if !rest.is_empty() {
-        let mut found_cmds_vec = Vec::new();
-
-        if rest[0].item == "commands" {
-            for decl_id in commands {
-                let mut cols = vec![];
-                let mut vals = vec![];
-
-                let decl = engine_state.get_decl(decl_id);
-                let sig = decl.signature().update_from_command(decl.borrow());
-
-                let signatures = sig.to_string();
-                let key = sig.name;
-                let usage = sig.usage;
-                let search_terms = sig.search_terms;
-
-                cols.push("name".into());
-                vals.push(Value::String {
-                    val: key,
-                    span: head,
-                });
-
-                cols.push("category".into());
-                vals.push(Value::String {
-                    val: sig.category.to_string(),
-                    span: head,
-                });
-
-                cols.push("command_type".into());
-                vals.push(Value::String {
-                    val: format!("{:?}", decl.command_type()).to_lowercase(),
-                    span: head,
-                });
-
-                cols.push("usage".into());
-                vals.push(Value::String {
-                    val: usage,
-                    span: head,
-                });
-
-                cols.push("signatures".into());
-                vals.push(Value::String {
-                    val: if decl.is_parser_keyword() {
-                        "".to_string()
-                    } else {
-                        signatures
-                    },
-                    span: head,
-                });
-
-                cols.push("search_terms".into());
-                vals.push(if search_terms.is_empty() {
-                    Value::nothing(head)
-                } else {
-                    Value::String {
-                        val: search_terms.join(", "),
-                        span: head,
-                    }
-                });
-
-                found_cmds_vec.push(Value::Record {
-                    cols,
-                    vals,
-                    span: head,
-                });
-            }
-
-            Ok(found_cmds_vec
-                .into_iter()
-                .into_pipeline_data(engine_state.ctrlc.clone()))
-        } else {
-            let mut name = String::new();
-
-            for r in &rest {
-                if !name.is_empty() {
-                    name.push(' ');
-                }
-                name.push_str(&r.item);
-            }
-
-            let output = engine_state
-                .get_signatures_with_examples(false)
-                .iter()
-                .filter(|(signature, _, _, _, _)| signature.name == name)
-                .map(|(signature, examples, _, _, is_parser_keyword)| {
-                    get_full_help(signature, examples, engine_state, stack, *is_parser_keyword)
-                })
-                .collect::<Vec<String>>();
-
-            if !output.is_empty() {
-                Ok(Value::String {
-                    val: output.join("======================\n\n"),
-                    span: call.head,
-                }
-                .into_pipeline_data())
-            } else {
-                Err(ShellError::CommandNotFound(span(&[
-                    rest[0].span,
-                    rest[rest.len() - 1].span,
-                ])))
-            }
-        }
-    } else {
-        let msg = r#"Welcome to Nushell.
 
 Here are some tips to help you get started.
+  * help -h or help help - show available `help` subcommands and examples
   * help commands - list all available commands
-  * help <command name> - display help about a particular command
+  * help <name> - display help about a particular command, alias, or module
-  * help --find <text to search> - search through all of help
+  * help --find <text to search> - search through all help commands table
 
 Nushell works on the idea of a "pipeline". Pipelines are commands connected with the '|' character.
 Each stage in the pipeline works together to load, parse, and display information to you.
@@ -334,12 +82,111 @@ Get the processes on your system actively using CPU:
 
 You can also learn more at https://www.nushell.sh/book/"#;
 
-        Ok(Value::String {
+            Ok(Value::string(msg, head).into_pipeline_data())
-            val: msg.into(),
+        } else if find.is_some() {
-            span: head,
+            help_commands(engine_state, stack, call)
+        } else {
+            let result = help_commands(engine_state, stack, call);
+
+            let result = if let Err(ShellError::CommandNotFound(_)) = result {
+                help_aliases(engine_state, stack, call)
+            } else {
+                result
+            };
+
+            let result = if let Err(ShellError::AliasNotFound(_)) = result {
+                help_modules(engine_state, stack, call)
+            } else {
+                result
+            };
+
+            if let Err(ShellError::ModuleNotFoundAtRuntime(_, _)) = result {
+                let rest_spans: Vec<Span> = rest.iter().map(|arg| arg.span).collect();
+                Err(ShellError::NotFound(span(&rest_spans)))
+            } else {
+                result
+            }
         }
-        .into_pipeline_data())
     }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "show help for single command, alias, or module",
+                example: "help match",
+                result: None,
+            },
+            Example {
+                description: "show help for single sub-command, alias, or module",
+                example: "help str lpad",
+                result: None,
+            },
+            Example {
+                description: "search for string in command names, usage and search terms",
+                example: "help --find char",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub fn highlight_search_in_table(
+    table: Vec<Value>, // list of records
+    search_string: &str,
+    searched_cols: &[&str],
+    string_style: &Style,
+) -> Result<Vec<Value>, ShellError> {
+    let orig_search_string = search_string;
+    let search_string = search_string.to_lowercase();
+    let mut matches = vec![];
+
+    for record in table {
+        let (cols, mut vals, record_span) = if let Value::Record { cols, vals, span } = record {
+            (cols, vals, span)
+        } else {
+            return Err(ShellError::NushellFailedSpanned(
+                "Expected record".to_string(),
+                format!("got {}", record.get_type()),
+                record.span()?,
+            ));
+        };
+
+        let has_match = cols.iter().zip(vals.iter_mut()).fold(
+            Ok(false),
+            |acc: Result<bool, ShellError>, (col, val)| {
+                if searched_cols.contains(&col.as_str()) {
+                    if let Value::String { val: s, span } = val {
+                        if s.to_lowercase().contains(&search_string) {
+                            *val = Value::String {
+                                val: highlight_search_string(s, orig_search_string, string_style)?,
+                                span: *span,
+                            };
+                            Ok(true)
+                        } else {
+                            // column does not contain the searched string
+                            acc
+                        }
+                    } else {
+                        // ignore non-string values
+                        acc
+                    }
+                } else {
+                    // don't search this column
+                    acc
+                }
+            },
+        )?;
+
+        if has_match {
+            matches.push(Value::Record {
+                cols,
+                vals,
+                span: record_span,
+            });
+        }
+    }
+
+    Ok(matches)
 }
 
 // Highlight the search string using ANSI escape sequences and regular expressions.
@@ -348,7 +195,7 @@ pub fn highlight_search_string(
     needle: &str,
     string_style: &Style,
 ) -> Result<String, ShellError> {
-    let regex_string = format!("(?i){}", needle);
+    let regex_string = format!("(?i){needle}");
     let regex = match Regex::new(&regex_string) {
         Ok(regex) => regex,
         Err(err) => {

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

@@ -0,0 +1,181 @@
+use crate::help::highlight_search_in_table;
+use nu_color_config::StyleComputer;
+use nu_engine::{scope::ScopeData, CallExt};
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    span, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
+    ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
+};
+use std::borrow::Cow;
+
+#[derive(Clone)]
+pub struct HelpAliases;
+
+impl Command for HelpAliases {
+    fn name(&self) -> &str {
+        "help aliases"
+    }
+
+    fn usage(&self) -> &str {
+        "Show help on nushell aliases."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("help aliases")
+            .category(Category::Core)
+            .rest(
+                "rest",
+                SyntaxShape::String,
+                "the name of alias to get help on",
+            )
+            .named(
+                "find",
+                SyntaxShape::String,
+                "string to find in alias names and usage",
+                Some('f'),
+            )
+            .input_output_types(vec![(Type::Nothing, Type::Table(vec![]))])
+            .allow_variants_without_examples(true)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "show all aliases",
+                example: "help aliases",
+                result: None,
+            },
+            Example {
+                description: "show help for single alias",
+                example: "help aliases my-alias",
+                result: None,
+            },
+            Example {
+                description: "search for string in alias names and usages",
+                example: "help aliases --find my-alias",
+                result: None,
+            },
+        ]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        help_aliases(engine_state, stack, call)
+    }
+}
+
+pub fn help_aliases(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+) -> Result<PipelineData, ShellError> {
+    let head = call.head;
+    let find: Option<Spanned<String>> = call.get_flag(engine_state, stack, "find")?;
+    let rest: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
+
+    // 🚩The following two-lines are copied from filters/find.rs:
+    let style_computer = StyleComputer::from_config(engine_state, stack);
+    // Currently, search results all use the same style.
+    // Also note that this sample string is passed into user-written code (the closure that may or may not be
+    // defined for "string").
+    let string_style = style_computer.compute("string", &Value::string("search result", head));
+
+    if let Some(f) = find {
+        let all_cmds_vec = build_help_aliases(engine_state, stack, head);
+        let found_cmds_vec =
+            highlight_search_in_table(all_cmds_vec, &f.item, &["name", "usage"], &string_style)?;
+
+        return Ok(found_cmds_vec
+            .into_iter()
+            .into_pipeline_data(engine_state.ctrlc.clone()));
+    }
+
+    if rest.is_empty() {
+        let found_cmds_vec = build_help_aliases(engine_state, stack, head);
+
+        Ok(found_cmds_vec
+            .into_iter()
+            .into_pipeline_data(engine_state.ctrlc.clone()))
+    } else {
+        let mut name = String::new();
+
+        for r in &rest {
+            if !name.is_empty() {
+                name.push(' ');
+            }
+            name.push_str(&r.item);
+        }
+
+        let alias_id = if let Some(id) = engine_state.find_alias(name.as_bytes(), &[]) {
+            id
+        } else {
+            return Err(ShellError::AliasNotFound(span(
+                &rest.iter().map(|r| r.span).collect::<Vec<Span>>(),
+            )));
+        };
+
+        let alias_expansion = engine_state
+            .get_alias(alias_id)
+            .iter()
+            .map(|span| String::from_utf8_lossy(engine_state.get_span_contents(span)))
+            .collect::<Vec<Cow<str>>>()
+            .join(" ");
+
+        let alias_usage = engine_state.build_alias_usage(alias_id);
+
+        // TODO: merge this into documentation.rs at some point
+        const G: &str = "\x1b[32m"; // green
+        const C: &str = "\x1b[36m"; // cyan
+        const RESET: &str = "\x1b[0m"; // reset
+
+        let mut long_desc = String::new();
+
+        if let Some((usage, extra_usage)) = alias_usage {
+            long_desc.push_str(&usage);
+            long_desc.push_str("\n\n");
+
+            if !extra_usage.is_empty() {
+                long_desc.push_str(&extra_usage);
+                long_desc.push_str("\n\n");
+            }
+        }
+
+        long_desc.push_str(&format!("{G}Alias{RESET}: {C}{name}{RESET}"));
+        long_desc.push_str("\n\n");
+        long_desc.push_str(&format!("{G}Expansion{RESET}:\n  {alias_expansion}"));
+
+        let config = engine_state.get_config();
+        if !config.use_ansi_coloring {
+            long_desc = nu_utils::strip_ansi_string_likely(long_desc);
+        }
+
+        Ok(Value::String {
+            val: long_desc,
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+fn build_help_aliases(engine_state: &EngineState, stack: &Stack, span: Span) -> Vec<Value> {
+    let mut scope_data = ScopeData::new(engine_state, stack);
+    scope_data.populate_aliases();
+
+    scope_data.collect_aliases(span)
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_examples() {
+        use super::HelpAliases;
+        use crate::test_examples;
+        test_examples(HelpAliases {})
+    }
+}