Bump to 0.41 (#4187)

* bye bye upx, let's try stripping alone

* remove all stripping - not sure it's even working

.azure/azure-pipelines.yml

@@ -34,7 +34,6 @@ steps:
       if [ -e /etc/debian_version ]
       then
         sudo apt-get -y install libxcb-composite0-dev libx11-dev
-        sudo npm install -g wasm-pack
       fi
       if [ "$(uname)" == "Darwin" ]; then
         curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain "stable"
@@ -50,10 +49,10 @@ steps:
   - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'unflagged')
     displayName: Run tests
-  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used -A clippy::needless_collect
     condition: eq(variables['style'], 'unflagged')
     displayName: Check clippy lints
-  - bash: cd samples/wasm && wasm-pack build
+  - bash: cd samples/wasm && npm install wasm-pack && node ./node_modules/wasm-pack/run.js build
     condition: eq(variables['style'], 'wasm')
     displayName: Wasm build
   - bash: RUSTFLAGS="-D warnings" cargo test --all --no-default-features --features=rustyline-support

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,47 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1.
-2.
-3.
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Configuration (please complete the following information):**
-
-Run `version | pivot` and paste the output to show OS, features, etc.
-
-```
-> version | pivot
-╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
-│ # │ Column0            │ Column1                                                               │
-├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
-│ 0 │ version            │ 0.24.1                                                                │
-│ 1 │ build_os           │ macos-x86_64                                                          │
-│ 2 │ rust_version       │ rustc 1.48.0                                                          │
-│ 3 │ cargo_version      │ cargo 1.48.0                                                          │
-│ 4 │ pkg_version        │ 0.24.1                                                                │
-│ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
-│ 6 │ build_rust_channel │ release                                                               │
-│ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, ptree, rich-benchmark, │
-│   │                    │ rustyline, term, uuid, which, zip                                     │
-╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
-```
-
-
-**Add any other context about the problem here.**

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,65 @@
+name: Bug Report
+description: Create a report to help us improve
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: How to reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1.
+        2.
+        3.
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+      placeholder: I expected nu to...
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: Please add any relevant screenshots here, if any
+    validations:
+      required: false
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: "Please run `> version | pivot key value | to md` and paste the output to show OS, features, etc"
+      placeholder: |
+        > version | pivot key value | to md
+        ╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
+        │ # │ key                │ value                                                                 │
+        ├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
+        │ 0 │ version            │ 0.24.1                                                                │
+        │ 1 │ build_os           │ macos-x86_64                                                          │
+        │ 2 │ rust_version       │ rustc 1.48.0                                                          │
+        │ 3 │ cargo_version      │ cargo 1.48.0                                                          │
+        │ 4 │ pkg_version        │ 0.24.1                                                                │
+        │ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
+        │ 6 │ build_rust_channel │ release                                                               │
+        │ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, rich-benchmark,        │
+        │   │                    │ rustyline, term, uuid, which, zip                                     │
+        ╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,34 @@
+name: Feature Request
+description: "When you want a new feature for something that doesn't already exist"
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Related problem
+      description: Is your feature request related to a problem? Please describe.
+      placeholder: |
+        A clear and concise description of what the problem is.
+        Example: I am trying to do [...] but [...]
+    validations:
+      required: false
+  - type: textarea
+    id: desired
+    attributes:
+      label: "Describe the solution you'd like"
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: "Describe alternatives you've considered"
+      description: "A clear and concise description of any alternative solutions or features you've considered."
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context and details
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/workflows/docker-publish.yml

@@ -1,118 +0,0 @@
-name: Publish consumable Docker images
-
-on:
-  push:
-    tags: ['v?[0-9]+.[0-9]+.[0-9]+*']
-
-jobs:
-  compile:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        arch:
-        - x86_64-unknown-linux-musl
-        - x86_64-unknown-linux-gnu
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install rust-embedded/cross
-      env: { VERSION: v0.1.16 }
-      run: >-
-        wget -nv https://github.com/rust-embedded/cross/releases/download/${VERSION}/cross-${VERSION}-x86_64-unknown-linux-gnu.tar.gz
-        -O- | sudo tar xz -C /usr/local/bin/
-    - name: compile for specific target
-      env: { arch: '${{ matrix.arch }}' }
-      run: |
-        cross build --target ${{ matrix.arch }} --release
-        # leave only the executable file
-        rm -frd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
-        find . -empty -delete
-    - uses: actions/upload-artifact@master
-      with:
-        name: ${{ matrix.arch }}
-        path: target/${{ matrix.arch }}/release
-
-  docker:
-    name: Build and publish docker images
-    needs: compile
-    runs-on: ubuntu-latest
-    env:
-      DOCKER_REGISTRY: quay.io/nushell
-      DOCKER_PASSWORD: ${{ secrets.DOCKER_REGISTRY }}
-      DOCKER_USER: ${{ secrets.DOCKER_USER }}
-    strategy:
-      matrix:
-        tag:
-        - alpine
-        - slim
-        - debian
-        - glibc-busybox
-        - musl-busybox
-        - musl-distroless
-        - glibc-distroless
-        - glibc
-        - musl
-        include:
-        - { tag: alpine,           base-image: alpine,                     arch: x86_64-unknown-linux-musl, plugin: true,  use-patch: false}
-        - { tag: slim,             base-image: 'debian:stable-slim',       arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
-        - { tag: debian,           base-image: debian,                     arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
-        - { tag: glibc-busybox,    base-image: 'busybox:glibc',            arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
-        - { tag: musl-busybox,     base-image: 'busybox:musl',             arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
-        - { tag: musl-distroless,  base-image: 'gcr.io/distroless/static', arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
-        - { tag: glibc-distroless, base-image: 'gcr.io/distroless/cc',     arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
-        - { tag: glibc,            base-image: scratch,                    arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: false}
-        - { tag: musl,             base-image: scratch,                    arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/download-artifact@master
-      with: { name: '${{ matrix.arch }}', path: target/release }
-    - name: Build and publish exact version
-      run: |-
-        export DOCKER_TAG=${GITHUB_REF##*/}-${{ matrix.tag }}
-        export NU_BINS=target/release/$( [ ${{ matrix.plugin }} = true ] && echo nu* || echo nu )
-        export PATCH=$([ ${{ matrix.use-patch }} = true ] && echo .${{ matrix.tag }} || echo '')
-        chmod +x $NU_BINS
-
-        echo ${DOCKER_PASSWORD} | docker login ${DOCKER_REGISTRY} -u ${DOCKER_USER} --password-stdin
-        docker-compose --file docker/docker-compose.package.yml build
-        docker-compose --file docker/docker-compose.package.yml push              # exact version
-      env:
-        BASE_IMAGE: ${{ matrix.base-image }}
-
-    #region semantics tagging
-    - name: Retag and push with suffixed version
-      run: |-
-        VERSION=${GITHUB_REF##*/}
-
-        latest_version=${VERSION%%%.*}-${{ matrix.tag }}
-        latest_feature=${VERSION%%.*}-${{ matrix.tag }}
-        latest_patch=${VERSION%.*}-${{ matrix.tag }}
-        exact_version=${VERSION}-${{ matrix.tag }}
-
-        tags=( ${latest_version} ${latest_feature} ${latest_patch} ${exact_version} )
-
-        for tag in ${tags[@]}; do
-          docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${tag}
-          docker push ${DOCKER_REGISTRY}/nu:${tag}
-        done
-
-        # latest version
-        docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${{ matrix.tag }}
-        docker push ${DOCKER_REGISTRY}/nu:${{ matrix.tag }}
-
-    - name: Retag and push debian as latest
-      if: matrix.tag == 'debian'
-      run: |-
-        VERSION=${GITHUB_REF##*/}
-
-        # ${latest features} ${latest patch} ${exact version}
-        tags=( ${VERSION%%.*} ${VERSION%.*} ${VERSION} )
-
-        for tag in ${tags[@]}; do
-          docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${tag}
-          docker push ${DOCKER_REGISTRY}/nu:${tag}
-        done
-
-        # latest version
-        docker tag ${DOCKER_REGISTRY}/nu:${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:latest
-        docker push ${DOCKER_REGISTRY}/nu:latest
-    #endregion semantics tagging

.github/workflows/release.yml

@@ -1,8 +1,9 @@
 name: Create Release Draft
 
 on:
+  workflow_dispatch:
   push:
-    tags: ['[0-9]+.[0-9]+.[0-9]+*']
+    tags: ["[0-9]+.[0-9]+.[0-9]+*"]
 
 jobs:
   linux:
@@ -28,6 +29,60 @@ jobs:
           command: build
           args: --release --all --features=extra
 
+      # - name: Strip binaries (nu)
+      #   run: strip target/release/nu
+
+      # - name: Strip binaries (nu_plugin_inc)
+      #   run: strip target/release/nu_plugin_inc
+
+      # - name: Strip binaries (nu_plugin_match)
+      #   run: strip target/release/nu_plugin_match
+
+      # - name: Strip binaries (nu_plugin_textview)
+      #   run: strip target/release/nu_plugin_textview
+
+      # - name: Strip binaries (nu_plugin_binaryview)
+      #   run: strip target/release/nu_plugin_binaryview
+
+      # - name: Strip binaries (nu_plugin_chart_bar)
+      #   run: strip target/release/nu_plugin_chart_bar
+
+      # - name: Strip binaries (nu_plugin_chart_line)
+      #   run: strip target/release/nu_plugin_chart_line
+
+      # - name: Strip binaries (nu_plugin_from_bson)
+      #   run: strip target/release/nu_plugin_from_bson
+
+      # - name: Strip binaries (nu_plugin_from_sqlite)
+      #   run: strip target/release/nu_plugin_from_sqlite
+
+      # - name: Strip binaries (nu_plugin_from_mp4)
+      #   run: strip target/release/nu_plugin_from_mp4
+
+      # - name: Strip binaries (nu_plugin_query_json)
+      #   run: strip target/release/nu_plugin_query_json
+
+      # - name: Strip binaries (nu_plugin_s3)
+      #   run: strip target/release/nu_plugin_s3
+
+      # - name: Strip binaries (nu_plugin_selector)
+      #   run: strip target/release/nu_plugin_selector
+
+      # - name: Strip binaries (nu_plugin_start)
+      #   run: strip target/release/nu_plugin_start
+
+      # - name: Strip binaries (nu_plugin_to_bson)
+      #   run: strip target/release/nu_plugin_to_bson
+
+      # - name: Strip binaries (nu_plugin_to_sqlite)
+      #   run: strip target/release/nu_plugin_to_sqlite
+
+      # - name: Strip binaries (nu_plugin_tree)
+      #   run: strip target/release/nu_plugin_tree
+
+      # - name: Strip binaries (nu_plugin_xpath)
+      #   run: strip target/release/nu_plugin_xpath
+
       - name: Create output directory
         run: mkdir output
 
@@ -70,6 +125,60 @@ jobs:
           command: build
           args: --release --all --features=extra
 
+      # - name: Strip binaries (nu)
+      #   run: strip target/release/nu
+
+      # - name: Strip binaries (nu_plugin_inc)
+      #   run: strip target/release/nu_plugin_inc
+
+      # - name: Strip binaries (nu_plugin_match)
+      #   run: strip target/release/nu_plugin_match
+
+      # - name: Strip binaries (nu_plugin_textview)
+      #   run: strip target/release/nu_plugin_textview
+
+      # - name: Strip binaries (nu_plugin_binaryview)
+      #   run: strip target/release/nu_plugin_binaryview
+
+      # - name: Strip binaries (nu_plugin_chart_bar)
+      #   run: strip target/release/nu_plugin_chart_bar
+
+      # - name: Strip binaries (nu_plugin_chart_line)
+      #   run: strip target/release/nu_plugin_chart_line
+
+      # - name: Strip binaries (nu_plugin_from_bson)
+      #   run: strip target/release/nu_plugin_from_bson
+
+      # - name: Strip binaries (nu_plugin_from_sqlite)
+      #   run: strip target/release/nu_plugin_from_sqlite
+
+      # - name: Strip binaries (nu_plugin_from_mp4)
+      #   run: strip target/release/nu_plugin_from_mp4
+
+      # - name: Strip binaries (nu_plugin_query_json)
+      #   run: strip target/release/nu_plugin_query_json
+
+      # - name: Strip binaries (nu_plugin_s3)
+      #   run: strip target/release/nu_plugin_s3
+
+      # - name: Strip binaries (nu_plugin_selector)
+      #   run: strip target/release/nu_plugin_selector
+
+      # - name: Strip binaries (nu_plugin_start)
+      #   run: strip target/release/nu_plugin_start
+
+      # - name: Strip binaries (nu_plugin_to_bson)
+      #   run: strip target/release/nu_plugin_to_bson
+
+      # - name: Strip binaries (nu_plugin_to_sqlite)
+      #   run: strip target/release/nu_plugin_to_sqlite
+
+      # - name: Strip binaries (nu_plugin_tree)
+      #   run: strip target/release/nu_plugin_tree
+
+      # - name: Strip binaries (nu_plugin_xpath)
+      #   run: strip target/release/nu_plugin_xpath
+
       - name: Create output directory
         run: mkdir output
 
@@ -114,6 +223,60 @@ jobs:
           command: build
           args: --release --all --features=extra
 
+      # - name: Strip binaries (nu.exe)
+      #   run: strip target/release/nu.exe
+
+      # - name: Strip binaries (nu_plugin_inc.exe)
+      #   run: strip target/release/nu_plugin_inc.exe
+
+      # - name: Strip binaries (nu_plugin_match.exe)
+      #   run: strip target/release/nu_plugin_match.exe
+
+      # - name: Strip binaries (nu_plugin_textview.exe)
+      #   run: strip target/release/nu_plugin_textview.exe
+
+      # - name: Strip binaries (nu_plugin_binaryview.exe)
+      #   run: strip target/release/nu_plugin_binaryview.exe
+
+      # - name: Strip binaries (nu_plugin_chart_bar.exe)
+      #   run: strip target/release/nu_plugin_chart_bar.exe
+
+      # - name: Strip binaries (nu_plugin_chart_line.exe)
+      #   run: strip target/release/nu_plugin_chart_line.exe
+
+      # - name: Strip binaries (nu_plugin_from_bson.exe)
+      #   run: strip target/release/nu_plugin_from_bson.exe
+
+      # - name: Strip binaries (nu_plugin_from_sqlite.exe)
+      #   run: strip target/release/nu_plugin_from_sqlite.exe
+
+      # - name: Strip binaries (nu_plugin_from_mp4.exe)
+      #   run: strip target/release/nu_plugin_from_mp4.exe
+
+      # - name: Strip binaries (nu_plugin_query_json.exe)
+      #   run: strip target/release/nu_plugin_query_json.exe
+
+      # - name: Strip binaries (nu_plugin_s3.exe)
+      #   run: strip target/release/nu_plugin_s3.exe
+
+      # - name: Strip binaries (nu_plugin_selector.exe)
+      #   run: strip target/release/nu_plugin_selector.exe
+
+      # - name: Strip binaries (nu_plugin_start.exe)
+      #   run: strip target/release/nu_plugin_start.exe
+
+      # - name: Strip binaries (nu_plugin_to_bson.exe)
+      #   run: strip target/release/nu_plugin_to_bson.exe
+
+      # - name: Strip binaries (nu_plugin_to_sqlite.exe)
+      #   run: strip target/release/nu_plugin_to_sqlite.exe
+
+      # - name: Strip binaries (nu_plugin_tree.exe)
+      #   run: strip target/release/nu_plugin_tree.exe
+
+      # - name: Strip binaries (nu_plugin_xpath.exe)
+      #   run: strip target/release/nu_plugin_xpath.exe
+
       - name: Create output directory
         run: mkdir output
 
@@ -274,7 +437,7 @@ jobs:
         with:
           name: windows-installer
           path: ./
-          
+
       - name: Upload Windows installer
         uses: actions/upload-release-asset@v1
         env:
@@ -283,4 +446,4 @@ jobs:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
           asset_path: ./nushell-windows.msi
           asset_name: ${{ steps.info.outputs.windowsdir }}.msi
-          asset_content_type: applictaion/x-msi
+          asset_content_type: application/x-msi

.github/workflows/stale.yml

@@ -0,0 +1,28 @@
+name: 'Close stale issues and PRs'
+#on: [workflow_dispatch]
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        with:
+          #debug-only: true
+          ascending: true
+          operations-per-run: 520
+          enable-statistics: true
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          close-issue-message: 'This issue has been marked stale for more than 100000 days without activity. Closing this issue, but if you find that the issue is still valid, please reopen.'
+          close-pr-message: 'This PR has been marked stale for more than 100 days without activity. Closing this PR, but if you are still working on it, please reopen.'
+          days-before-issue-stale: 90
+          days-before-pr-stale: 45
+          days-before-issue-close: 100000
+          days-before-pr-close: 100
+          exempt-issue-labels: 'exempt,keep'

.github/workflows/winget-submission.yml

@@ -0,0 +1,18 @@
+name: Submit Nushell package to Windows Package Manager Community Repository 
+
+on:
+  release:
+    types: [published]
+
+jobs:
+
+  winget:
+    name: Publish winget package
+    runs-on: windows-latest
+    steps:
+      - name: Submit package to Windows Package Manager Community Repository
+        run: |
+          iwr https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
+          $github = Get-Content '${{ github.event_path }}' | ConvertFrom-Json
+          $installerUrl = $github.release.assets | Where-Object -Property name -match 'windows.msi' | Select -ExpandProperty browser_download_url -First 1
+          .\wingetcreate.exe update Nushell.Nushell -s -v $github.release.tag_name -u $installerUrl -t ${{ secrets.NUSHELL_PAT }}

.gitpod.Dockerfile

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

Cargo.toml

@@ -10,7 +10,7 @@ license = "MIT"
 name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-version = "0.33.0"
+version = "0.41.0"
 
 [workspace]
 members = ["crates/*/"]
@@ -18,38 +18,34 @@ members = ["crates/*/"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-cli = { version="0.33.0", path="./crates/nu-cli", default-features=false }
-nu-command = { version="0.33.0", path="./crates/nu-command" }
-nu-completion = { version="0.33.0", path="./crates/nu-completion" }
-nu-data = { version="0.33.0", path="./crates/nu-data" }
-nu-engine = { version="0.33.0", path="./crates/nu-engine" }
-nu-errors = { version="0.33.0", path="./crates/nu-errors" }
-nu-parser = { version="0.33.0", path="./crates/nu-parser" }
-nu-path = { version="0.33.0", path="./crates/nu-path" }
-nu-plugin = { version="0.33.0", path="./crates/nu-plugin" }
-nu-protocol = { version="0.33.0", path="./crates/nu-protocol" }
-nu-source = { version="0.33.0", path="./crates/nu-source" }
-nu-value-ext = { version="0.33.0", path="./crates/nu-value-ext" }
+nu-cli = { version = "0.41.0", path="./crates/nu-cli", default-features=false }
+nu-command = { version = "0.41.0", path="./crates/nu-command" }
+nu-completion = { version = "0.41.0", path="./crates/nu-completion" }
+nu-data = { version = "0.41.0", path="./crates/nu-data" }
+nu-engine = { version = "0.41.0", path="./crates/nu-engine" }
+nu-errors = { version = "0.41.0", path="./crates/nu-errors" }
+nu-parser = { version = "0.41.0", path="./crates/nu-parser" }
+nu-path = { version = "0.41.0", path="./crates/nu-path" }
+nu-plugin = { version = "0.41.0", path="./crates/nu-plugin" }
+nu-protocol = { version = "0.41.0", path="./crates/nu-protocol" }
+nu-source = { version = "0.41.0", path="./crates/nu-source" }
+nu-value-ext = { version = "0.41.0", path="./crates/nu-value-ext" }
 
-nu_plugin_binaryview = { version="0.33.0", path="./crates/nu_plugin_binaryview", optional=true }
-nu_plugin_chart = { version="0.33.0", path="./crates/nu_plugin_chart", optional=true }
-nu_plugin_fetch = { version="0.33.0", path="./crates/nu_plugin_fetch", optional=true }
-nu_plugin_from_bson = { version="0.33.0", path="./crates/nu_plugin_from_bson", optional=true }
-nu_plugin_from_sqlite = { version="0.33.0", path="./crates/nu_plugin_from_sqlite", optional=true }
-nu_plugin_inc = { version="0.33.0", path="./crates/nu_plugin_inc", optional=true }
-nu_plugin_match = { version="0.33.0", path="./crates/nu_plugin_match", optional=true }
-nu_plugin_post = { version="0.33.0", path="./crates/nu_plugin_post", optional=true }
-nu_plugin_ps = { version="0.33.0", path="./crates/nu_plugin_ps", optional=true }
-nu_plugin_query_json = { version="0.33.0", path="./crates/nu_plugin_query_json", optional=true }
-nu_plugin_s3 = { version="0.33.0", path="./crates/nu_plugin_s3", optional=true }
-nu_plugin_selector = { version="0.33.0", path="./crates/nu_plugin_selector", optional=true }
-nu_plugin_start = { version="0.33.0", path="./crates/nu_plugin_start", optional=true }
-nu_plugin_sys = { version="0.33.0", path="./crates/nu_plugin_sys", optional=true }
-nu_plugin_textview = { version="0.33.0", path="./crates/nu_plugin_textview", optional=true }
-nu_plugin_to_bson = { version="0.33.0", path="./crates/nu_plugin_to_bson", optional=true }
-nu_plugin_to_sqlite = { version="0.33.0", path="./crates/nu_plugin_to_sqlite", optional=true }
-nu_plugin_tree = { version="0.33.0", path="./crates/nu_plugin_tree", optional=true }
-nu_plugin_xpath = { version="0.33.0", path="./crates/nu_plugin_xpath", optional=true }
+nu_plugin_binaryview = { version = "0.41.0", path="./crates/nu_plugin_binaryview", optional=true }
+nu_plugin_chart = { version = "0.41.0", path="./crates/nu_plugin_chart", optional=true }
+nu_plugin_from_bson = { version = "0.41.0", path="./crates/nu_plugin_from_bson", optional=true }
+nu_plugin_from_sqlite = { version = "0.41.0", path="./crates/nu_plugin_from_sqlite", optional=true }
+nu_plugin_inc = { version = "0.41.0", path="./crates/nu_plugin_inc", optional=true }
+nu_plugin_match = { version = "0.41.0", path="./crates/nu_plugin_match", optional=true }
+nu_plugin_query_json = { version = "0.41.0", path="./crates/nu_plugin_query_json", optional=true }
+nu_plugin_s3 = { version = "0.41.0", path="./crates/nu_plugin_s3", optional=true }
+nu_plugin_selector = { version = "0.41.0", path="./crates/nu_plugin_selector", optional=true }
+nu_plugin_start = { version = "0.41.0", path="./crates/nu_plugin_start", optional=true }
+nu_plugin_textview = { version = "0.41.0", path="./crates/nu_plugin_textview", optional=true }
+nu_plugin_to_bson = { version = "0.41.0", path="./crates/nu_plugin_to_bson", optional=true }
+nu_plugin_to_sqlite = { version = "0.41.0", path="./crates/nu_plugin_to_sqlite", optional=true }
+nu_plugin_tree = { version = "0.41.0", path="./crates/nu_plugin_tree", optional=true }
+nu_plugin_xpath = { version = "0.41.0", path="./crates/nu_plugin_xpath", optional=true }
 
 # Required to bootstrap the main binary
 ctrlc = { version="3.1.7", optional=true }
@@ -57,36 +53,33 @@ futures = { version="0.3.12", features=["compat", "io-compat"] }
 itertools = "0.10.0"
 
 [dev-dependencies]
-nu-test-support = { version="0.33.0", path="./crates/nu-test-support" }
-dunce = "1.0.1"
+nu-test-support = { version = "0.41.0", path="./crates/nu-test-support" }
 serial_test = "0.5.1"
 hamcrest2 = "0.3.0"
-
+rstest = "0.10.0"
 
 [build-dependencies]
 
 [features]
+fetch-support = ["nu-command/fetch", "nu-command/post"]
+sys-support = ["nu-command/sys", "nu-command/ps"]
 ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
-ptree-support = ["nu-cli/ptree", "nu-command/ptree"]
 rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
-term-support = ["nu-cli/term", "nu-command/term"]
-uuid-support = ["nu-cli/uuid_crate", "nu-command/uuid_crate"]
-which-support = ["nu-cli/which", "nu-command/which", "nu-engine/which"]
-executable-support = ["nu-completion/is_executable"]
+term-support = ["nu-command/term"]
+uuid-support = ["nu-command/uuid_crate"]
+which-support = ["nu-command/which", "nu-engine/which"]
 
 default = [
     "nu-cli/shadow-rs",
-    "sys",
-    "ps",
+    "sys-support",
     "ctrlc-support",
     "which-support",
     "term-support",
     "rustyline-support",
     "match",
-    "post",
-    "fetch",
+    "fetch-support",
     "zip-support",
-    "executable-support",
+    "dataframe",
 ]
 
 stable = ["default"]
@@ -95,9 +88,7 @@ extra = [
     "binaryview",
     "inc",
     "tree",
-    "ptree-support",
     "textview",
-    "clipboard-cli",
     "trash-support",
     "uuid-support",
     "start",
@@ -110,40 +101,29 @@ extra = [
     "query-json",
 ]
 
-wasi = ["inc", "match", "ptree-support", "match", "tree", "rustyline-support"]
-
-trace = ["nu-parser/trace"]
+wasi = ["inc", "match", "match", "tree", "rustyline-support"]
 
 # Stable (Default)
-fetch = ["nu_plugin_fetch"]
 inc = ["nu_plugin_inc"]
 match = ["nu_plugin_match"]
-post = ["nu_plugin_post"]
-ps = ["nu_plugin_ps"]
-sys = ["nu_plugin_sys"]
 textview = ["nu_plugin_textview"]
 
 # Extra
 binaryview = ["nu_plugin_binaryview"]
 bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
 chart = ["nu_plugin_chart"]
-clipboard-cli = ["nu-cli/clipboard-cli", "nu-command/clipboard-cli"]
 query-json = ["nu_plugin_query_json"]
 s3 = ["nu_plugin_s3"]
 selector = ["nu_plugin_selector"]
 sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
 start = ["nu_plugin_start"]
 trash-support = [
-    "nu-cli/trash-support",
     "nu-command/trash-support",
     "nu-engine/trash-support",
 ]
 tree = ["nu_plugin_tree"]
 xpath = ["nu_plugin_xpath"]
-zip-support = ["nu-cli/zip", "nu-command/zip"]
-
-#This is disabled in extra for now
-table-pager = ["nu-command/table-pager"]
+zip-support = ["nu-command/zip"]
 
 #dataframe feature for nushell
 dataframe = [
@@ -152,17 +132,11 @@ dataframe = [
     "nu-command/dataframe",
     "nu-value-ext/dataframe",
     "nu-data/dataframe",
-    "nu_plugin_post/dataframe",
     "nu_plugin_to_bson/dataframe",
 ]
 
-
 [profile.release]
-#strip = "symbols" #Couldn't get working +nightly
-codegen-units = 1 #Reduce parallel codegen units
-lto = true #Link Time Optimization
-# opt-level = 'z' #Optimize for size
-# debug = true
+opt-level = "s"  # Optimize for size.
 
 # Core plugins that ship with `cargo install nu` by default
 # Currently, Cargo limits us to installing only one binary
@@ -177,31 +151,11 @@ name = "nu_plugin_core_inc"
 path = "src/plugins/nu_plugin_core_inc.rs"
 required-features = ["inc"]
 
-[[bin]]
-name = "nu_plugin_core_ps"
-path = "src/plugins/nu_plugin_core_ps.rs"
-required-features = ["ps"]
-
-[[bin]]
-name = "nu_plugin_core_sys"
-path = "src/plugins/nu_plugin_core_sys.rs"
-required-features = ["sys"]
-
-[[bin]]
-name = "nu_plugin_core_fetch"
-path = "src/plugins/nu_plugin_core_fetch.rs"
-required-features = ["fetch"]
-
 [[bin]]
 name = "nu_plugin_core_match"
 path = "src/plugins/nu_plugin_core_match.rs"
 required-features = ["match"]
 
-[[bin]]
-name = "nu_plugin_core_post"
-path = "src/plugins/nu_plugin_core_post.rs"
-required-features = ["post"]
-
 # Extra plugins
 
 [[bin]]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 - 2021 Yehuda Katz, Jonathan Turner
+Copyright (c) 2019 - 2021 Nushell Project
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -68,7 +68,7 @@ cargo install nu
 To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):
 
 ```shell
-winget install nu
+winget install nushell
 ```
 
 You can also build Nu yourself with all the bells and whistles (be sure to have installed the [dependencies](https://www.nushell.sh/book/installation.html#dependencies) for your platform), once you have checked out this repo with git:
@@ -76,53 +76,6 @@ You can also build Nu yourself with all the bells and whistles (be sure to have
 ```shell
 cargo build --workspace --features=extra
 ```
-
-### Docker
-
-#### Quickstart
-
-Want to try Nu right away? Execute the following to get started.
-
-```shell
-docker run -it quay.io/nushell/nu:latest
-```
-
-#### Guide
-
-If you want to pull a pre-built container, you can browse tags for the [nushell organization](https://quay.io/organization/nushell)
-on Quay.io. Pulling a container would come down to:
-
-```shell
-docker pull quay.io/nushell/nu
-docker pull quay.io/nushell/nu-base
-```
-
-Both "nu-base" and "nu" provide the nu binary, however, nu-base also includes the source code at `/code`
-in the container and all dependencies.
-
-Optionally, you can also build the containers locally using the [dockerfiles provided](docker):
-To build the base image:
-
-```shell
-docker build -f docker/Dockerfile.nu-base -t nushell/nu-base .
-```
-
-And then to build the smaller container (using a Multistage build):
-
-```shell
-docker build -f docker/Dockerfile -t nushell/nu .
-```
-
-Either way, you can run either container as follows:
-
-```shell
-docker run -it nushell/nu-base
-docker run -it nushell/nu
-/> exit
-```
-
-The second container is a bit smaller if the size is important to you.
-
 ### Packaging status
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions)
@@ -237,8 +190,6 @@ Finally, we can use commands outside of Nu once we have the data we want:
 0.32.0
 ```
 
-Here we use the variable `$it` to refer to the value being piped to the external command.
-
 ### Configuration
 
 Nu has early support for configuring the shell. You can refer to the book for a list of [all supported variables](https://www.nushell.sh/book/configuration.html).
@@ -312,9 +263,15 @@ Nu is in heavy development and will naturally change as it matures and people us
 | Completions   |             |           |  X  |         |        | Completions for filepaths                                            |
 | Type-checking |             |           |  X  |         |        | Commands check basic types, but input/output isn't checked           |
 
-## Current Roadmap
+## Officially Supported By
 
-We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release and capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
+Please submit an issue or PR to be added to this list.
+
+###   Integrations
+-   [zoxide](https://github.com/ajeetdsouza/zoxide)
+-   [starship](https://github.com/starship/starship)
+###   Mentions
+-   [The Python Launcher for Unix](https://github.com/brettcannon/python-launcher#how-do-i-get-a-table-of-python-executables-in-nushell)
 
 ## Contributing
 

crates/README.md

@@ -10,4 +10,4 @@ Foundational libraries are split into two kinds of crates:
 Plugins are likewise also split into two types:
 
 * Core plugins - plugins that provide part of the default experience of Nu, including access to the system properties, processes, and web-connectivity features.
-* Extra plugins - these plugins run a wide range of differnt capabilities like working with different file types, charting, viewing binary data, and more.
+* Extra plugins - these plugins run a wide range of different capabilities like working with different file types, charting, viewing binary data, and more.

crates/nu-ansi-term/Cargo.toml

@@ -9,7 +9,7 @@ description = "Library for ANSI terminal colors and styles (bold, underline)"
 edition = "2018"
 license = "MIT"
 name = "nu-ansi-term"
-version = "0.33.0"
+version = "0.41.0"
 
 [lib]
 doctest = false
@@ -21,7 +21,6 @@ derive_serde_style = ["serde"]
 [dependencies]
 overload = "0.1.1"
 serde = { version="1.0.90", features=["derive"], optional=true }
-itertools = "0.10.0"
 
 # [dependencies.serde]
 # version = "1.0.90"

crates/nu-ansi-term/src/ansi.rs

@@ -93,7 +93,7 @@ pub static RESET: &str = "\x1B[0m";
 
 impl Color {
     fn write_foreground_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
+        match self {
             Color::Black => write!(f, "30"),
             Color::Red => write!(f, "31"),
             Color::Green => write!(f, "32"),
@@ -103,8 +103,8 @@ impl Color {
             Color::Magenta => write!(f, "35"),
             Color::Cyan => write!(f, "36"),
             Color::White => write!(f, "37"),
-            Color::Fixed(num) => write!(f, "38;5;{}", &num),
-            Color::Rgb(r, g, b) => write!(f, "38;2;{};{};{}", &r, &g, &b),
+            Color::Fixed(num) => write!(f, "38;5;{}", num),
+            Color::Rgb(r, g, b) => write!(f, "38;2;{};{};{}", r, g, b),
             Color::DarkGray => write!(f, "90"),
             Color::LightRed => write!(f, "91"),
             Color::LightGreen => write!(f, "92"),
@@ -118,7 +118,7 @@ impl Color {
     }
 
     fn write_background_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
+        match self {
             Color::Black => write!(f, "40"),
             Color::Red => write!(f, "41"),
             Color::Green => write!(f, "42"),
@@ -128,8 +128,8 @@ impl Color {
             Color::Magenta => write!(f, "45"),
             Color::Cyan => write!(f, "46"),
             Color::White => write!(f, "47"),
-            Color::Fixed(num) => write!(f, "48;5;{}", &num),
-            Color::Rgb(r, g, b) => write!(f, "48;2;{};{};{}", &r, &g, &b),
+            Color::Fixed(num) => write!(f, "48;5;{}", num),
+            Color::Rgb(r, g, b) => write!(f, "48;2;{};{};{}", r, g, b),
             Color::DarkGray => write!(f, "100"),
             Color::LightRed => write!(f, "101"),
             Color::LightGreen => write!(f, "102"),

crates/nu-ansi-term/src/display.rs

@@ -297,7 +297,7 @@ mod tests {
     fn no_control_codes_for_plain() {
         let one = Style::default().paint("one");
         let two = Style::default().paint("two");
-        let output = format!("{}", AnsiStrings(&[one, two]));
-        assert_eq!(&*output, "onetwo");
+        let output = AnsiStrings(&[one, two]).to_string();
+        assert_eq!(output, "onetwo");
     }
 }

crates/nu-ansi-term/src/style.rs

@@ -602,18 +602,18 @@ mod serde_json_tests {
 
     #[test]
     fn color_deserialization() {
-        let colors = &[
+        let colors = [
             Color::Red,
             Color::Blue,
             Color::Rgb(123, 123, 123),
             Color::Fixed(255),
         ];
 
-        for color in colors.iter() {
+        for color in colors {
             let serialized = serde_json::to_string(&color).unwrap();
             let deserialized: Color = serde_json::from_str(&serialized).unwrap();
 
-            assert_eq!(color, &deserialized);
+            assert_eq!(color, deserialized);
         }
     }
 

crates/nu-ansi-term/src/util.rs

@@ -75,6 +75,6 @@ mod test {
         assert_eq!(unstyled_len(&a), 18);
 
         let l2 = [Black.paint("st"), Red.paint("-second"), White.paint("-t")];
-        assert_eq!(sub_string(3, 11, &a).as_slice(), &l2);
+        assert_eq!(sub_string(3, 11, &a), l2);
     }
 }

crates/nu-cli/Cargo.toml

@@ -1,130 +1,43 @@
 [package]
 authors = ["The Nu Project Contributors"]
-build = "build.rs"
 description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
 name = "nu-cli"
-version = "0.33.0"
+version = "0.41.0"
+build = "build.rs"
 
 [lib]
 doctest = false
 
 [dependencies]
-nu-completion = { version="0.33.0", path="../nu-completion" }
-nu-command = { version="0.33.0", path="../nu-command" }
-nu-data = { version="0.33.0", path="../nu-data" }
-nu-engine = { version="0.33.0", path="../nu-engine" }
-nu-errors = { version="0.33.0", path="../nu-errors" }
-nu-json = { version="0.33.0", path="../nu-json" }
-nu-parser = { version="0.33.0", path="../nu-parser" }
-nu-plugin = { version="0.33.0", path="../nu-plugin" }
-nu-protocol = { version="0.33.0", path="../nu-protocol" }
-nu-source = { version="0.33.0", path="../nu-source" }
-nu-stream = { version="0.33.0", path="../nu-stream" }
-nu-table = { version="0.33.0", path="../nu-table" }
-nu-test-support = { version="0.33.0", path="../nu-test-support" }
-nu-value-ext = { version="0.33.0", path="../nu-value-ext" }
-nu-ansi-term = { version="0.33.0", path="../nu-ansi-term" }
-nu-pretty-hex = { version="0.33.0", path="../nu-pretty-hex" }
+nu-completion = { version = "0.41.0", path="../nu-completion" }
+nu-command = { version = "0.41.0", path="../nu-command" }
+nu-data = { version = "0.41.0", path="../nu-data" }
+nu-engine = { version = "0.41.0", path="../nu-engine" }
+nu-errors = { version = "0.41.0", path="../nu-errors" }
+nu-parser = { version = "0.41.0", path="../nu-parser" }
+nu-protocol = { version = "0.41.0", path="../nu-protocol" }
+nu-source = { version = "0.41.0", path="../nu-source" }
+nu-stream = { version = "0.41.0", path="../nu-stream" }
+nu-ansi-term = { version = "0.41.0", path="../nu-ansi-term" }
+nu-path = { version = "0.41.0", path="../nu-path" }
 
-Inflector = "0.11"
-arboard = { version="1.1.0", optional=true }
-async-recursion = "0.3.2"
-async-trait = "0.1.42"
-base64 = "0.13.0"
-bigdecimal = { version="0.2.0", features=["serde"] }
-byte-unit = "4.0.9"
-bytes = "1.0.1"
-calamine = "0.17.0"
-chrono = { version="0.4.19", features=["serde"] }
-chrono-tz = "0.5.3"
-codespan-reporting = "0.11.0"
-csv = "1.1.5"
-ctrlc = { version="3.1.7", optional=true }
-derive-new = "0.5.8"
-directories-next = "2.0.0"
-dirs-next = "2.0.0"
-dtparse = "1.2.0"
-dunce = "1.0.1"
-eml-parser = "0.1.0"
-encoding_rs = "0.8.28"
-filesize = "0.2.0"
-fs_extra = "1.2.0"
-futures = { version="0.3.12", features=["compat", "io-compat"] }
-futures-util = "0.3.12"
-futures_codec = "0.4.1"
-getset = "0.1.1"
-glob = "0.3.0"
-htmlescape = "0.3.1"
-ical = "0.7.0"
-indexmap = { version="1.6.1", features=["serde-1"] }
+indexmap ="1.6.1"
 log = "0.4.14"
 pretty_env_logger = "0.4.0"
-meval = "0.2.0"
-num-bigint = { version="0.3.1", features=["serde"] }
-num-format = { version="0.4.0", features=["with-num-bigint"] }
-num-traits = "0.2.14"
-parking_lot = "0.11.1"
-pin-utils = "0.1.0"
-ptree = { version="0.3.1", optional=true }
-query_interface = "0.3.5"
-quick-xml = "0.21.0"
-rand = "0.8.3"
-rayon = "1.5.0"
-regex = "1.4.3"
-roxmltree = "0.14.0"
-rust-embed = "5.9.0"
-rustyline = { version="8.1.0", optional=true }
-serde = { version="1.0.123", features=["derive"] }
-serde_bytes = "0.11.5"
-serde_ini = "0.2.0"
-serde_json = "1.0.61"
-serde_urlencoded = "0.7.0"
-serde_yaml = "0.8.16"
-sha2 = "0.9.3"
 strip-ansi-escapes = "0.1.0"
-sxd-document = "0.3.2"
-sxd-xpath = "0.4.2"
-tempfile = "3.2.0"
-term = { version="0.7.0", optional=true }
-term_size = "0.3.2"
-termcolor = "1.1.2"
-titlecase = "1.1.0"
-toml = "0.5.8"
-trash = { version="1.3.0", optional=true }
-unicode-segmentation = "1.7.1"
-url = "2.1.1"
-uuid_crate = { package="uuid", version="0.8.2", features=["v4"], optional=true }
-which = { version="4.0.2", optional=true }
-zip = { version="0.5.9", optional=true }
-shadow-rs = { version="0.5", default-features=false, optional=true }
-
-[target.'cfg(unix)'.dependencies]
-umask = "1.0.0"
-users = "0.11.0"
-
-# TODO this will be possible with new dependency resolver
-#   (currently on nightly behind -Zfeatures=itarget):
-#   https://github.com/rust-lang/cargo/issues/7914
-#[target.'cfg(not(windows))'.dependencies]
-#num-format = {version = "0.4", features = ["with-system-locale"]}
-
-[dependencies.rusqlite]
-features = ["bundled", "blob"]
-optional = true
-version = "0.25.3"
+rustyline = { version="9.0.0", optional=true }
+ctrlc = { version="3.1.7", optional=true }
+shadow-rs = { version = "0.8.1", default-features = false, optional = true }
+serde = { version="1.0.123", features=["derive"] }
+serde_yaml = "0.8.16"
+lazy_static = "1.4.0"
 
 [build-dependencies]
-shadow-rs = "0.5"
-
-[dev-dependencies]
-quickcheck = "1.0.3"
-quickcheck_macros = "1.0.0"
+shadow-rs = "0.8.1"
 
 [features]
 default = ["shadow-rs"]
-clipboard-cli = ["arboard"]
 rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
 stable = []
-trash-support = ["trash"]

crates/nu-cli/src/app.rs

@@ -1,10 +1,10 @@
 mod logger;
 mod options;
 mod options_parser;
+pub mod stopwatch;
 
-pub use options::{CliOptions, NuScript, Options};
-use options_parser::{NuParser, OptionsParser};
-
+use self::stopwatch::Stopwatch;
+use lazy_static::lazy_static;
 use nu_command::{commands::NuSignature as Nu, utils::test_bins as binaries};
 use nu_engine::{get_full_help, EvaluationContext};
 use nu_errors::ShellError;
@@ -12,6 +12,18 @@ use nu_protocol::hir::{Call, Expression, SpannedExpression, Synthetic};
 use nu_protocol::{Primitive, UntaggedValue};
 use nu_source::{Span, Tag};
 use nu_stream::InputStream;
+pub use options::{CliOptions, NuScript, Options};
+use options_parser::{NuParser, OptionsParser};
+use std::sync::Mutex;
+
+lazy_static! {
+    pub static ref STOPWATCH: Mutex<Stopwatch> = {
+        let mut sw = Stopwatch::default();
+        sw.start();
+        sw.stop();
+        Mutex::new(sw)
+    };
+}
 
 pub struct App {
     parser: Box<dyn OptionsParser>,
@@ -32,6 +44,14 @@ impl App {
     }
 
     pub fn main(&self, argv: &[String]) -> Result<(), ShellError> {
+        if self.perf() {
+            // start the stopwatch running
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
         let argv = quote_positionals(argv).join(" ");
 
         if let Err(cause) = self.parse(&argv) {
@@ -52,6 +72,21 @@ impl App {
 
             consume(context, stream)?;
 
+            if self.perf() {
+                // stop the stopwatch since we're exiting
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .stop();
+                eprintln!(
+                    "help {:?}",
+                    STOPWATCH
+                        .lock()
+                        .expect("unable to lock the stopwatch")
+                        .elapsed()
+                );
+            }
+
             std::process::exit(0);
         }
 
@@ -93,6 +128,22 @@ impl App {
             };
 
             consume(context, stream)?;
+
+            if self.perf() {
+                // stop the stopwatch since we're exiting
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .stop();
+                eprintln!(
+                    "version {:?}",
+                    STOPWATCH
+                        .lock()
+                        .expect("unable to lock the stopwatch")
+                        .elapsed()
+                );
+            }
+
             std::process::exit(0);
         }
 
@@ -113,21 +164,29 @@ impl App {
         }
 
         let mut opts = CliOptions::new();
-
         opts.config = self.config().map(std::ffi::OsString::from);
         opts.stdin = self.takes_stdin();
         opts.save_history = self.save_history();
+        opts.perf = self.perf();
 
         use logger::{configure, debug_filters, logger, trace_filters};
 
         logger(|builder| {
-            configure(&self, builder)?;
-            trace_filters(&self, builder)?;
-            debug_filters(&self, builder)?;
+            configure(self, builder)?;
+            trace_filters(self, builder)?;
+            debug_filters(self, builder)?;
 
             Ok(())
         })?;
 
+        if self.perf() {
+            // start a new split
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start()
+        }
+
         if let Some(commands) = self.commands() {
             let commands = commands?;
             let script = NuScript::code(&commands)?;
@@ -136,6 +195,21 @@ impl App {
             return crate::run_script_file(context, opts);
         }
 
+        if self.perf() {
+            // start a new spit
+            eprintln!(
+                "commands using -c at launch: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
         if let Some(scripts) = self.scripts() {
             let mut source_files = vec![];
             for script in scripts {
@@ -162,12 +236,38 @@ impl App {
             return Ok(());
         }
 
+        if self.perf() {
+            // start a new split
+            eprintln!(
+                "script file(s) passed in: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
         let context = crate::create_default_context(true)?;
 
         if !self.skip_plugins() {
             let _ = crate::register_plugins(&context);
         }
 
+        if self.perf() {
+            // start a new split
+            eprintln!(
+                "plugins registered: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+        }
+
         #[cfg(feature = "rustyline-support")]
         {
             crate::cli(context, opts)?;
@@ -189,6 +289,13 @@ impl App {
         })
     }
 
+    pub fn perf(&self) -> bool {
+        self.options
+            .get("perf")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
     pub fn help(&self) -> bool {
         self.options
             .get("help")
@@ -298,7 +405,7 @@ impl App {
     }
 
     pub fn parse(&self, args: &str) -> Result<(), ShellError> {
-        self.parser.parse(&args).map(|options| {
+        self.parser.parse(args).map(|options| {
             self.options.swap(&options);
         })
     }
@@ -401,14 +508,9 @@ mod tests {
 
     #[test]
     fn can_use_loglevels() -> Result<(), ShellError> {
-        for level in &["error", "warn", "info", "debug", "trace"] {
+        for level in ["error", "warn", "info", "debug", "trace"] {
             let ui = cli_app();
-            let args = format!("nu --loglevel={}", *level);
-            ui.parse(&args)?;
-            assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
-
-            let ui = cli_app();
-            let args = format!("nu -l {}", *level);
+            let args = format!("nu --loglevel={}", level);
             ui.parse(&args)?;
             assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
         }
@@ -423,6 +525,17 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn can_be_login() -> Result<(), ShellError> {
+        let ui = cli_app();
+        ui.parse("nu -l")?;
+
+        let ui = cli_app();
+        ui.parse("nu --login")?;
+
+        Ok(())
+    }
+
     #[test]
     fn can_be_passed_nu_scripts() -> Result<(), ShellError> {
         let ui = cli_app();
@@ -434,11 +547,11 @@ mod tests {
 
     #[test]
     fn can_use_test_binaries() -> Result<(), ShellError> {
-        for binarie_name in &[
+        for binarie_name in [
             "echo_env", "cococo", "iecho", "fail", "nonu", "chop", "repeater", "meow",
         ] {
             let ui = cli_app();
-            let args = format!("nu --testbin={}", *binarie_name);
+            let args = format!("nu --testbin={}", binarie_name);
             ui.parse(&args)?;
             assert_eq!(ui.testbin().unwrap(), Ok(binarie_name.to_string()));
         }

crates/nu-cli/src/app/options.rs

@@ -10,6 +10,7 @@ pub struct CliOptions {
     pub stdin: bool,
     pub scripts: Vec<NuScript>,
     pub save_history: bool,
+    pub perf: bool,
 }
 
 impl Default for CliOptions {
@@ -25,6 +26,7 @@ impl CliOptions {
             stdin: false,
             scripts: vec![],
             save_history: true,
+            perf: false,
         }
     }
 }
@@ -42,7 +44,7 @@ impl Options {
     }
 
     pub fn get(&self, key: &str) -> Option<Value> {
-        self.inner.borrow().get(key).map(Clone::clone)
+        self.inner.borrow().get(key).cloned()
     }
 
     pub fn put(&self, key: &str, value: Value) {

crates/nu-cli/src/app/options_parser.rs

@@ -39,7 +39,7 @@ impl OptionsParser for NuParser {
 
     fn parse(&self, input: &str) -> Result<Options, ShellError> {
         let options = Options::default();
-        let (lite_result, _err) = nu_parser::lex(input, 0);
+        let (lite_result, _err) = nu_parser::lex(input, 0, nu_parser::NewlineMode::Normal);
         let (lite_result, _err) = nu_parser::parse_block(lite_result);
 
         let (parsed, err) = nu_parser::classify_block(&lite_result, &self.context.scope);
@@ -67,51 +67,40 @@ impl OptionsParser for NuParser {
                             }
                         };
 
-                        let value =
-                            value
-                                .map(|v| match k.as_ref() {
-                                    "testbin" => {
-                                        if let Ok(name) = v.as_string() {
-                                            if testbins().iter().any(|n| name == *n) {
-                                                Some(v)
-                                            } else {
-                                                Some(
-                                                    UntaggedValue::Error(
-                                                        ShellError::untagged_runtime_error(
-                                                            format!("{} is not supported.", name),
-                                                        ),
-                                                    )
-                                                    .into_value(v.tag),
-                                                )
-                                            }
-                                        } else {
-                                            Some(v)
-                                        }
+                        let value = value.map(|v| match k.as_ref() {
+                            "testbin" => {
+                                if let Ok(name) = v.as_string() {
+                                    if testbins().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
                                     }
-                                    "loglevel" => {
-                                        if let Ok(name) = v.as_string() {
-                                            if loglevels().iter().any(|n| name == *n) {
-                                                Some(v)
-                                            } else {
-                                                Some(
-                                                    UntaggedValue::Error(
-                                                        ShellError::untagged_runtime_error(
-                                                            format!("{} is not supported.", name),
-                                                        ),
-                                                    )
-                                                    .into_value(v.tag),
-                                                )
-                                            }
-                                        } else {
-                                            Some(v)
-                                        }
+                                } else {
+                                    v
+                                }
+                            }
+                            "loglevel" => {
+                                if let Ok(name) = v.as_string() {
+                                    if loglevels().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
                                     }
-                                    _ => Some(v),
-                                })
-                                .flatten();
+                                } else {
+                                    v
+                                }
+                            }
+                            _ => v,
+                        });
 
                         if let Some(value) = value {
-                            options.put(&k, value);
+                            options.put(k, value);
                         }
                     });
                 }

crates/nu-cli/src/app/stopwatch.rs

@@ -0,0 +1,118 @@
+#![allow(dead_code)]
+use std::default::Default;
+use std::fmt;
+use std::time::{Duration, Instant};
+
+#[derive(Clone, Copy)]
+pub struct Stopwatch {
+    /// The time the stopwatch was started last, if ever.
+    start_time: Option<Instant>,
+    /// The time the stopwatch was split last, if ever.
+    split_time: Option<Instant>,
+    /// The time elapsed while the stopwatch was running (between start() and stop()).
+    elapsed: Duration,
+}
+
+impl Default for Stopwatch {
+    fn default() -> Stopwatch {
+        Stopwatch {
+            start_time: None,
+            split_time: None,
+            elapsed: Duration::from_secs(0),
+        }
+    }
+}
+
+impl fmt::Display for Stopwatch {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        return write!(f, "{}ms", self.elapsed_ms());
+    }
+}
+
+impl Stopwatch {
+    /// Returns a new stopwatch.
+    pub fn new() -> Stopwatch {
+        let sw: Stopwatch = Default::default();
+        sw
+    }
+
+    /// Returns a new stopwatch which will immediately be started.
+    pub fn start_new() -> Stopwatch {
+        let mut sw = Stopwatch::new();
+        sw.start();
+        sw
+    }
+
+    /// Starts the stopwatch.
+    pub fn start(&mut self) {
+        self.start_time = Some(Instant::now());
+    }
+
+    /// Stops the stopwatch.
+    pub fn stop(&mut self) {
+        self.elapsed = self.elapsed();
+        self.start_time = None;
+        self.split_time = None;
+    }
+
+    /// Resets all counters and stops the stopwatch.
+    pub fn reset(&mut self) {
+        self.elapsed = Duration::from_secs(0);
+        self.start_time = None;
+        self.split_time = None;
+    }
+
+    /// Resets and starts the stopwatch again.
+    pub fn restart(&mut self) {
+        self.reset();
+        self.start();
+    }
+
+    /// Returns whether the stopwatch is running.
+    pub fn is_running(&self) -> bool {
+        self.start_time.is_some()
+    }
+
+    /// Returns the elapsed time since the start of the stopwatch.
+    pub fn elapsed(&self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(t1) => t1.elapsed() + self.elapsed,
+            // stopwatch is not running
+            None => self.elapsed,
+        }
+    }
+
+    /// Returns the elapsed time since the start of the stopwatch in milliseconds.
+    pub fn elapsed_ms(&self) -> i64 {
+        let dur = self.elapsed();
+        (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64
+    }
+
+    /// Returns the elapsed time since last split or start/restart.
+    ///
+    /// If the stopwatch is in stopped state this will always return a zero Duration.
+    pub fn elapsed_split(&mut self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(start) => {
+                let res = match self.split_time {
+                    Some(split) => split.elapsed(),
+                    None => start.elapsed(),
+                };
+                self.split_time = Some(Instant::now());
+                res
+            }
+            // stopwatch is not running
+            None => Duration::from_secs(0),
+        }
+    }
+
+    /// Returns the elapsed time since last split or start/restart in milliseconds.
+    ///
+    /// If the stopwatch is in stopped state this will always return zero.
+    pub fn elapsed_split_ms(&mut self) -> i64 {
+        let dur = self.elapsed_split();
+        (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64
+    }
+}

crates/nu-cli/src/cli.rs

@@ -1,3 +1,4 @@
+use crate::app::STOPWATCH;
 use crate::line_editor::configure_ctrl_c;
 use nu_ansi_term::Color;
 use nu_engine::{maybe_print_errors, run_block, script::run_script_standalone, EvaluationContext};
@@ -23,6 +24,7 @@ use rustyline::{self, error::ReadlineError};
 
 use nu_errors::ShellError;
 use nu_parser::ParserScope;
+use nu_path::expand_tilde;
 use nu_protocol::{hir::ExternalRedirection, ConfigPath, UntaggedValue, Value};
 
 use log::trace;
@@ -30,9 +32,12 @@ use std::error::Error;
 use std::iter::Iterator;
 use std::path::PathBuf;
 
+// Name of environment variable where the prompt could be stored
+#[cfg(feature = "rustyline-support")]
+const PROMPT_COMMAND: &str = "PROMPT_COMMAND";
+
 pub fn search_paths() -> Vec<std::path::PathBuf> {
     use std::env;
-
     let mut search_paths = Vec::new();
 
     // Automatically add path `nu` is in as a search path
@@ -50,7 +55,7 @@ pub fn search_paths() -> Vec<std::path::PathBuf> {
         {
             for pipeline in pipelines {
                 if let Ok(plugin_dir) = pipeline.as_string() {
-                    search_paths.push(PathBuf::from(plugin_dir));
+                    search_paths.push(expand_tilde(plugin_dir));
                 }
             }
         }
@@ -82,6 +87,66 @@ pub fn run_script_file(
     Ok(())
 }
 
+#[cfg(feature = "rustyline-support")]
+fn default_prompt_string(cwd: &str) -> String {
+    format!(
+        "{}{}{}{}{}{}> ",
+        Color::Green.bold().prefix().to_string(),
+        cwd,
+        nu_ansi_term::ansi::RESET,
+        Color::Cyan.bold().prefix().to_string(),
+        current_branch(),
+        nu_ansi_term::ansi::RESET
+    )
+}
+
+#[cfg(feature = "rustyline-support")]
+fn evaluate_prompt_string(prompt_line: &str, context: &EvaluationContext, cwd: &str) -> String {
+    context.scope.enter_scope();
+    let (prompt_block, err) = nu_parser::parse(prompt_line, 0, &context.scope);
+
+    if err.is_some() {
+        context.scope.exit_scope();
+        default_prompt_string(cwd)
+    } else {
+        let run_result = run_block(
+            &prompt_block,
+            context,
+            InputStream::empty(),
+            ExternalRedirection::Stdout,
+        );
+        context.scope.exit_scope();
+
+        match run_result {
+            Ok(result) => match result.collect_string(Tag::unknown()) {
+                Ok(string_result) => {
+                    let errors = context.get_errors();
+                    maybe_print_errors(context, Text::from(prompt_line));
+                    context.clear_errors();
+
+                    if !errors.is_empty() {
+                        "> ".into()
+                    } else {
+                        string_result.item
+                    }
+                }
+                Err(e) => {
+                    context.host().lock().print_err(e, &Text::from(prompt_line));
+                    context.clear_errors();
+
+                    "> ".into()
+                }
+            },
+            Err(e) => {
+                context.host().lock().print_err(e, &Text::from(prompt_line));
+                context.clear_errors();
+
+                "> ".into()
+            }
+        }
+    }
+}
+
 #[cfg(feature = "rustyline-support")]
 pub fn cli(
     context: EvaluationContext,
@@ -97,16 +162,30 @@ pub fn cli(
     } else {
         load_global_cfg(&context);
     }
+
     // Store cmd duration in an env var
     context.scope.add_env_var(
         "CMD_DURATION_MS",
-        format!("{}", startup_commands_start_time.elapsed().as_millis()),
-    );
-    trace!(
-        "startup commands took {:?}",
-        startup_commands_start_time.elapsed()
+        startup_commands_start_time
+            .elapsed()
+            .as_millis()
+            .to_string(),
     );
 
+    if options.perf {
+        eprintln!(
+            "config loaded: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
     //Configure rustyline
     let mut rl = default_rustyline_editor_configuration();
     let history_path = if let Some(cfg) = &context.configs().lock().global_config {
@@ -118,11 +197,39 @@ pub fn cli(
         nu_data::config::path::default_history_path()
     };
 
+    if options.perf {
+        eprintln!(
+            "rustyline configuration: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
     // Don't load history if it's not necessary
     if options.save_history {
         let _ = rl.load_history(&history_path);
     }
 
+    if options.perf {
+        eprintln!(
+            "history load: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
     //set vars from cfg if present
     let (skip_welcome_message, prompt) = if let Some(cfg) = &context.configs().lock().global_config
     {
@@ -136,6 +243,20 @@ pub fn cli(
         (false, None)
     };
 
+    if options.perf {
+        eprintln!(
+            "load custom prompt: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
     //Check whether dir we start in contains local cfg file and if so load it.
     load_local_cfg_if_present(&context);
 
@@ -159,6 +280,20 @@ pub fn cli(
 
     let mut ctrlcbreak = false;
 
+    if options.perf {
+        eprintln!(
+            "timing stopped. starting run loop: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .stop();
+    }
+
     loop {
         if context.ctrl_c().load(Ordering::SeqCst) {
             context.ctrl_c().store(false, Ordering::SeqCst);
@@ -167,72 +302,17 @@ pub fn cli(
 
         let cwd = context.shell_manager().path();
 
-        let colored_prompt = {
-            if let Some(prompt) = &prompt {
-                let prompt_line = prompt.as_string()?;
-
-                context.scope.enter_scope();
-                let (prompt_block, err) = nu_parser::parse(&prompt_line, 0, &context.scope);
-
-                if err.is_some() {
-                    context.scope.exit_scope();
-
-                    format!(
-                        "{}{}{}{}{}{}> ",
-                        Color::Green.bold().prefix().to_string(),
-                        cwd,
-                        nu_ansi_term::ansi::RESET,
-                        Color::Cyan.bold().prefix().to_string(),
-                        current_branch(),
-                        nu_ansi_term::ansi::RESET
-                    )
+        // Check if the PROMPT_COMMAND env variable is set. This env variable
+        // contains nu code that is used to overwrite the prompt
+        let colored_prompt = match context.scope.get_env(PROMPT_COMMAND) {
+            Some(env_prompt) => evaluate_prompt_string(&env_prompt, &context, &cwd),
+            None => {
+                if let Some(prompt) = &prompt {
+                    let prompt_line = prompt.as_string()?;
+                    evaluate_prompt_string(&prompt_line, &context, &cwd)
                 } else {
-                    let run_result = run_block(
-                        &prompt_block,
-                        &context,
-                        InputStream::empty(),
-                        ExternalRedirection::Stdout,
-                    );
-                    context.scope.exit_scope();
-
-                    match run_result {
-                        Ok(result) => match result.collect_string(Tag::unknown()) {
-                            Ok(string_result) => {
-                                let errors = context.get_errors();
-                                maybe_print_errors(&context, Text::from(prompt_line));
-                                context.clear_errors();
-
-                                if !errors.is_empty() {
-                                    "> ".to_string()
-                                } else {
-                                    string_result.item
-                                }
-                            }
-                            Err(e) => {
-                                context.host().lock().print_err(e, &Text::from(prompt_line));
-                                context.clear_errors();
-
-                                "> ".to_string()
-                            }
-                        },
-                        Err(e) => {
-                            context.host().lock().print_err(e, &Text::from(prompt_line));
-                            context.clear_errors();
-
-                            "> ".to_string()
-                        }
-                    }
+                    default_prompt_string(&cwd)
                 }
-            } else {
-                format!(
-                    "{}{}{}{}{}{}> ",
-                    Color::Green.bold().prefix().to_string(),
-                    cwd,
-                    nu_ansi_term::ansi::RESET,
-                    Color::Cyan.bold().prefix().to_string(),
-                    current_branch(),
-                    nu_ansi_term::ansi::RESET
-                )
             }
         };
 
@@ -277,7 +357,7 @@ pub fn cli(
         // Store cmd duration in an env var
         context.scope.add_env_var(
             "CMD_DURATION_MS",
-            format!("{}", cmd_start_time.elapsed().as_millis()),
+            cmd_start_time.elapsed().as_millis().to_string(),
         );
 
         match line {
@@ -292,7 +372,7 @@ pub fn cli(
             LineResult::ClearHistory => {
                 if options.save_history {
                     rl.clear_history();
-                    let _ = rl.append_history(&history_path);
+                    std::fs::remove_file(&history_path)?;
                 }
             }
 
@@ -321,8 +401,7 @@ pub fn cli(
                     .lock()
                     .global_config
                     .as_ref()
-                    .map(|cfg| cfg.var("ctrlc_exit"))
-                    .flatten()
+                    .and_then(|cfg| cfg.var("ctrlc_exit"))
                     .map(|ctrl_c| ctrl_c.is_true())
                     .unwrap_or(false); // default behavior is to allow CTRL-C spamming similar to other shells
 
@@ -364,6 +443,7 @@ pub fn cli(
     Ok(())
 }
 
+#[cfg(feature = "rustyline-support")]
 pub fn load_local_cfg_if_present(context: &EvaluationContext) {
     trace!("Loading local cfg if present");
     match config::loadable_cfg_exists_in_dir(PathBuf::from(context.shell_manager().path())) {
@@ -456,19 +536,3 @@ fn current_branch() -> String {
         "".to_string()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use nu_engine::EvaluationContext;
-
-    #[quickcheck]
-    fn quickcheck_parse(data: String) -> bool {
-        let (tokens, err) = nu_parser::lex(&data, 0);
-        let (lite_block, err2) = nu_parser::parse_block(tokens);
-        if err.is_none() && err2.is_none() {
-            let context = EvaluationContext::basic();
-            let _ = nu_parser::classify_block(&lite_block, &context.scope);
-        }
-        true
-    }
-}

crates/nu-cli/src/keybinding.rs

@@ -410,7 +410,7 @@ pub enum CharSearch {
 }
 
 /// The set of modifier keys that were triggered along with a key press.
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub enum NuModifiers {
     /// Control modifier
@@ -442,7 +442,7 @@ pub enum NuModifiers {
 /// The number of times one command should be repeated.
 pub type RepeatCount = usize;
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Keybinding {
     key: KeyCode,
     modifiers: Option<NuModifiers>,
@@ -460,9 +460,10 @@ pub(crate) fn load_keybindings(
     // Silently fail if there is no file there
     if let Ok(contents) = contents {
         let keybindings: Keybindings = serde_yaml::from_str(&contents)?;
-        // eprint!("{}{}{}", keybindings.key, keybindings.mo);
-        for keybinding in keybindings.into_iter() {
+        // eprintln!("{:#?}", keybindings);
+        for keybinding in keybindings {
             let (k, b) = convert_keybinding(keybinding);
+            // eprintln!("{:?} {:?}", k, b);
 
             rl.bind_sequence(k, b);
         }

crates/nu-cli/src/lib.rs

@@ -1,10 +1,4 @@
-#[cfg(test)]
-extern crate quickcheck;
-#[cfg(test)]
-#[macro_use(quickcheck)]
-extern crate quickcheck_macros;
-
-mod app;
+pub mod app;
 mod cli;
 #[cfg(feature = "rustyline-support")]
 mod keybinding;
@@ -18,16 +12,4 @@ pub use crate::cli::cli;
 pub use crate::app::App;
 pub use crate::cli::{parse_and_eval, register_plugins, run_script_file};
 
-pub use nu_command::{
-    commands::NuSignature as Nu, commands::Version as NuVersion, create_default_context,
-};
-pub use nu_data::config;
-pub use nu_data::dict::TaggedListBuilder;
-pub use nu_data::primitive;
-pub use nu_data::value;
-pub use nu_stream::{ActionStream, InputStream, InterruptibleStream};
-pub use nu_value_ext::ValueExt;
-pub use num_traits::cast::ToPrimitive;
-
-// TODO: Temporary redirect
-pub use nu_protocol::{did_you_mean, TaggedDictBuilder};
+pub use nu_command::create_default_context;

crates/nu-cli/src/line_editor.rs

@@ -76,6 +76,8 @@ pub fn default_rustyline_editor_configuration() -> Editor<Helper> {
     let config = Config::builder()
         .check_cursor_position(true)
         .color_mode(ColorMode::Forced)
+        .history_ignore_dups(false)
+        .max_history_size(10_000)
         .build();
     let mut rl: Editor<_> = Editor::with_config(config);
 
@@ -247,7 +249,7 @@ pub fn rustyline_hinter(
 ) -> Option<rustyline::hint::HistoryHinter> {
     if let Some(line_editor_vars) = config.var("line_editor") {
         for (idx, value) in line_editor_vars.row_entries() {
-            if idx == "show_hints" && value.expect_string() == "false" {
+            if idx == "show_hints" && value.as_bool() == Ok(false) {
                 return None;
             }
         }

crates/nu-cli/src/shell.rs

@@ -27,12 +27,31 @@ impl Helper {
     }
 }
 
+use nu_protocol::{SignatureRegistry, VariableRegistry};
 struct CompletionContext<'a>(&'a EvaluationContext);
 
 impl<'a> nu_completion::CompletionContext for CompletionContext<'a> {
-    fn signature_registry(&self) -> &dyn nu_parser::ParserScope {
+    fn signature_registry(&self) -> &dyn SignatureRegistry {
         &self.0.scope
     }
+
+    fn scope(&self) -> &dyn nu_parser::ParserScope {
+        &self.0.scope
+    }
+
+    fn source(&self) -> &EvaluationContext {
+        self.as_ref()
+    }
+
+    fn variable_registry(&self) -> &dyn VariableRegistry {
+        self.0
+    }
+}
+
+impl<'a> AsRef<EvaluationContext> for CompletionContext<'a> {
+    fn as_ref(&self) -> &EvaluationContext {
+        self.0
+    }
 }
 
 pub struct CompletionSuggestion(nu_completion::Suggestion);
@@ -71,7 +90,10 @@ impl rustyline::completion::Completer for Helper {
 impl rustyline::hint::Hinter for Helper {
     type Hint = String;
     fn hint(&self, line: &str, pos: usize, ctx: &rustyline::Context<'_>) -> Option<String> {
-        self.hinter.as_ref().and_then(|h| h.hint(line, pos, ctx))
+        match &self.hinter {
+            Some(the_hinter) => the_hinter.hint(line, pos, ctx),
+            None => Some("".to_string()),
+        }
     }
 }
 
@@ -130,7 +152,7 @@ impl rustyline::validate::Validator for NuValidator {
     ) -> rustyline::Result<rustyline::validate::ValidationResult> {
         let src = ctx.input();
 
-        let (tokens, err) = nu_parser::lex(src, 0);
+        let (tokens, err) = nu_parser::lex(src, 0, nu_parser::NewlineMode::Normal);
         if let Some(err) = err {
             if let nu_errors::ParseErrorReason::Eof { .. } = err.reason() {
                 return Ok(rustyline::validate::ValidationResult::Incomplete);

crates/nu-command/Cargo.toml

@@ -5,105 +5,93 @@ description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
 name = "nu-command"
-version = "0.33.0"
+version = "0.41.0"
 
 [lib]
 doctest = false
 
 [dependencies]
-nu-data = { version="0.33.0", path="../nu-data" }
-nu-engine = { version="0.33.0", path="../nu-engine" }
-nu-errors = { version="0.33.0", path="../nu-errors" }
-nu-json = { version="0.33.0", path="../nu-json" }
-nu-path = { version="0.33.0", path="../nu-path" }
-nu-parser = { version="0.33.0", path="../nu-parser" }
-nu-plugin = { version="0.33.0", path="../nu-plugin" }
-nu-protocol = { version="0.33.0", path="../nu-protocol" }
-nu-source = { version="0.33.0", path="../nu-source" }
-nu-stream = { version="0.33.0", path="../nu-stream" }
-nu-table = { version="0.33.0", path="../nu-table" }
-nu-test-support = { version="0.33.0", path="../nu-test-support" }
-nu-value-ext = { version="0.33.0", path="../nu-value-ext" }
-nu-ansi-term = { version="0.33.0", path="../nu-ansi-term" }
-nu-pretty-hex = { version="0.33.0", path="../nu-pretty-hex" }
+nu-data = { version = "0.41.0", path="../nu-data" }
+nu-engine = { version = "0.41.0", path="../nu-engine" }
+nu-errors = { version = "0.41.0", path="../nu-errors" }
+nu-json = { version = "0.41.0", path="../nu-json" }
+nu-path = { version = "0.41.0", path="../nu-path" }
+nu-parser = { version = "0.41.0", path="../nu-parser" }
+nu-plugin = { version = "0.41.0", path="../nu-plugin" }
+nu-protocol = { version = "0.41.0", path="../nu-protocol" }
+nu-serde = { version = "0.41.0", path="../nu-serde" }
+nu-source = { version = "0.41.0", path="../nu-source" }
+nu-stream = { version = "0.41.0", path="../nu-stream" }
+nu-table = { version = "0.41.0", path="../nu-table" }
+nu-test-support = { version = "0.41.0", path="../nu-test-support" }
+nu-value-ext = { version = "0.41.0", path="../nu-value-ext" }
+nu-ansi-term = { version = "0.41.0", path="../nu-ansi-term" }
+nu-pretty-hex = { version = "0.41.0", path="../nu-pretty-hex" }
 
+url = "2.2.1"
+mime = "0.3.16"
 Inflector = "0.11"
-arboard = { version="1.1.0", optional=true }
 base64 = "0.13.0"
-bigdecimal = { version="0.2.0", features=["serde"] }
-byte-unit = "4.0.9"
-bytes = "1.0.1"
-calamine = "0.17.0"
+bigdecimal = { version = "0.3.0", features = ["serde"] }
+calamine = "0.18.0"
 chrono = { version="0.4.19", features=["serde"] }
 chrono-tz = "0.5.3"
-codespan-reporting = "0.11.0"
 crossterm = { version="0.19.0", optional=true }
 csv = "1.1.3"
 ctrlc = { version="3.1.7", optional=true }
 derive-new = "0.5.8"
-directories-next = "2.0.0"
 dirs-next = "2.0.0"
 dtparse = "1.2.0"
-dunce = "1.0.1"
 eml-parser = "0.1.0"
 encoding_rs = "0.8.28"
 filesize = "0.2.0"
-fs_extra = "1.2.0"
 futures = { version="0.3.12", features=["compat", "io-compat"] }
-getset = "0.1.1"
 glob = "0.3.0"
 htmlescape = "0.3.1"
 ical = "0.7.0"
-indexmap = { version="1.6.1", features=["serde-1"] }
+indexmap = { version="1.7", features=["serde-1"] }
 itertools = "0.10.0"
 lazy_static = "1.*"
 log = "0.4.14"
-md5 = "0.7.0"
+md-5 = "0.9.1"
 meval = "0.2.0"
-minus = { version="3.3.0", optional=true, features=["async_std_lib", "search"] }
-num-bigint = { version="0.3.1", features=["serde"] }
+num-bigint = { version="0.4.3", features=["serde"] }
 num-format = { version="0.4.0", features=["with-num-bigint"] }
 num-traits = "0.2.14"
 parking_lot = "0.11.1"
-pin-utils = "0.1.0"
-ptree = { version="0.3.1", optional=true }
-query_interface = "0.3.5"
-quick-xml = "0.21.0"
-rand = "0.7.3"
-rayon = "1.5.0"
+quick-xml = "0.22"
+rand = "0.8"
 regex = "1.4.3"
+reqwest = {version = "0.11", optional = true }
 roxmltree = "0.14.0"
 rust-embed = "5.9.0"
-rustyline = { version="8.1.0", optional=true }
+rustyline = { version="9.0.0", optional=true }
 serde = { version="1.0.123", features=["derive"] }
-serde_bytes = "0.11.5"
 serde_ini = "0.2.0"
 serde_json = "1.0.61"
 serde_urlencoded = "0.7.0"
 serde_yaml = "0.8.16"
 sha2 = "0.9.3"
 strip-ansi-escapes = "0.1.0"
-sxd-document = "0.3.2"
-sxd-xpath = "0.4.2"
-tempfile = "3.2.0"
+sysinfo = { version = "0.21.1", optional = true }
+thiserror = "1.0.26"
 term = { version="0.7.0", optional=true }
 term_size = "0.3.2"
-termcolor = "1.1.2"
 titlecase = "1.1.0"
+tokio = { version = "1", features = ["rt-multi-thread"], optional = true }
 toml = "0.5.8"
-trash = { version="1.3.0", optional=true }
-unicode-segmentation = "1.7.1"
-url = "2.2.0"
+trash = { version = "2.0.2", optional = true }
+unicode-segmentation = "1.8"
 uuid_crate = { package="uuid", version="0.8.2", features=["v4"], optional=true }
 which = { version="4.1.0", optional=true }
 zip = { version="0.5.9", optional=true }
+digest = "0.9.0"
 
 [dependencies.polars]
-git = "https://github.com/pola-rs/polars"
-rev = "f60d86bc0921bd42635e8a33e7aad28ebe62dc3e"
-version = "0.14.2"
+version = "0.17.0"
 optional = true
-features = ["parquet", "json", "random", "pivot", "strings", "is_in"]
+default-features = false
+features = ["docs", "zip_with", "csv-file", "temporal", "performant", "pretty_fmt", "dtype-slim", "parquet", "json", "random", "pivot", "strings", "is_in", "cum_agg", "rolling_window"]
 
 [target.'cfg(unix)'.dependencies]
 umask = "1.0.0"
@@ -112,16 +100,11 @@ users = "0.11.0"
 # TODO this will be possible with new dependency resolver
 #   (currently on nightly behind -Zfeatures=itarget):
 #   https://github.com/rust-lang/cargo/issues/7914
-#[target.'cfg(not(windows))'.dependencies]
-#num-format = {version = "0.4", features = ["with-system-locale"]}
-
-[dependencies.rusqlite]
-features = ["bundled", "blob"]
-optional = true
-version = "0.25.3"
+# [target.'cfg(not(windows))'.dependencies]
+# num-format = { version = "0.4", features = ["with-system-locale"] }
 
 [build-dependencies]
-shadow-rs = "0.5"
+shadow-rs = "0.8.1"
 
 [dev-dependencies]
 quickcheck = "1.0.3"
@@ -129,9 +112,11 @@ quickcheck_macros = "1.0.0"
 hamcrest2 = "0.3.0"
 
 [features]
-clipboard-cli = ["arboard"]
 rustyline-support = ["rustyline"]
 stable = []
 trash-support = ["trash"]
-table-pager = ["minus", "crossterm"]
 dataframe = ["nu-protocol/dataframe", "polars"]
+fetch = ["reqwest", "tokio"]
+post = ["reqwest", "tokio"]
+sys = ["sysinfo"]
+ps = ["sysinfo"]

crates/nu-command/src/classified/dynamic.rs

@@ -1,7 +0,0 @@
-use derive_new::new;
-use nu_protocol::hir;
-
-#[derive(new, Debug)]
-pub(crate) struct Command {
-    pub(crate) args: hir::Call,
-}

crates/nu-command/src/classified/external.rs

@@ -1,10 +1,15 @@
 use crate::prelude::*;
+use lazy_static::lazy_static;
 use nu_engine::{evaluate_baseline_expr, BufCodecReader};
 use nu_engine::{MaybeTextCodec, StringOrBinary};
 use nu_test_support::NATIVE_PATH_ENV_VAR;
 use parking_lot::Mutex;
+use regex::Regex;
 
+#[allow(unused)]
+use std::env;
 use std::io::Write;
+use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use std::sync::mpsc;
 use std::{borrow::Cow, io::BufReader};
@@ -17,6 +22,9 @@ use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
 use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
 use nu_source::Tag;
 
+#[cfg(feature = "which")]
+use which::which_in;
+
 pub(crate) fn run_external_command(
     command: ExternalCommand,
     context: &mut EvaluationContext,
@@ -38,20 +46,16 @@ pub(crate) fn run_external_command(
 }
 
 #[allow(unused)]
-fn trim_double_quotes(input: &str) -> String {
+fn trim_enclosing_quotes(input: &str) -> String {
     let mut chars = input.chars();
 
     match (chars.next(), chars.next_back()) {
         (Some('"'), Some('"')) => chars.collect(),
+        (Some('\''), Some('\'')) => chars.collect(),
         _ => input.to_string(),
     }
 }
 
-#[allow(unused)]
-fn escape_where_needed(input: &str) -> String {
-    input.split(' ').join("\\ ").split('\'').join("\\'")
-}
-
 fn run_with_stdin(
     command: ExternalCommand,
     context: &mut EvaluationContext,
@@ -104,20 +108,14 @@ fn run_with_stdin(
     let process_args = command_args
         .iter()
         .map(|(arg, _is_literal)| {
-            let arg = nu_path::expand_tilde_string(Cow::Borrowed(arg));
+            let arg = nu_path::expand_tilde(arg).to_string_lossy().to_string();
 
             #[cfg(not(windows))]
             {
                 if !_is_literal {
-                    let escaped = escape_double_quotes(&arg);
-                    add_double_quotes(&escaped)
+                    arg
                 } else {
-                    let trimmed = trim_double_quotes(&arg);
-                    if trimmed != arg {
-                        escape_where_needed(&trimmed)
-                    } else {
-                        trimmed
-                    }
+                    trim_enclosing_quotes(&arg)
                 }
             }
             #[cfg(windows)]
@@ -125,7 +123,7 @@ fn run_with_stdin(
                 if let Some(unquoted) = remove_quotes(&arg) {
                     unquoted.to_string()
                 } else {
-                    arg.to_string()
+                    arg
                 }
             }
         })
@@ -141,6 +139,99 @@ fn run_with_stdin(
     )
 }
 
+/// Spawn a direct exe
+#[allow(unused)]
+fn spawn_exe(full_path: PathBuf, args: &[String]) -> Command {
+    let mut process = Command::new(full_path);
+    for arg in args {
+        process.arg(&arg);
+    }
+    process
+}
+
+/// Spawn a cmd command with `cmd /c args...`
+fn spawn_cmd_command(command: &ExternalCommand, args: &[String]) -> Command {
+    let mut process = Command::new("cmd");
+    process.arg("/c");
+    process.arg(&command.name);
+    for arg in args {
+        // Clean the args before we use them:
+        // https://stackoverflow.com/questions/1200235/how-to-pass-a-quoted-pipe-character-to-cmd-exe
+        // cmd.exe needs to have a caret to escape a pipe
+        let arg = arg.replace("|", "^|");
+        process.arg(&arg);
+    }
+    process
+}
+
+fn has_unsafe_shell_characters(arg: &str) -> bool {
+    lazy_static! {
+        static ref RE: Regex = Regex::new(r"[^\w@%+=:,./-]").expect("regex to be valid");
+    }
+
+    RE.is_match(arg)
+}
+
+fn shell_arg_escape(arg: &str) -> String {
+    match arg {
+        "" => String::from("''"),
+        s if !has_unsafe_shell_characters(s) => String::from(s),
+        _ => {
+            let single_quotes_escaped = arg.split('\'').join("'\"'\"'");
+            format!("'{}'", single_quotes_escaped)
+        }
+    }
+}
+
+/// Spawn a sh command with `sh -c args...`
+fn spawn_sh_command(command: &ExternalCommand, args: &[String]) -> Command {
+    let joined_and_escaped_arguments = args.iter().map(|arg| shell_arg_escape(arg)).join(" ");
+    let cmd_with_args = vec![command.name.clone(), joined_and_escaped_arguments].join(" ");
+    let mut process = Command::new("sh");
+    process.arg("-c").arg(cmd_with_args);
+    process
+}
+
+/// a function to spawn any external command
+#[allow(unused)] // for minimal builds cwd is unused
+fn spawn_any(command: &ExternalCommand, args: &[String], cwd: &str) -> Command {
+    // resolve the executable name if it is spawnable directly
+    #[cfg(feature = "which")]
+    // TODO add more available paths to `env::var_os("PATH")`?
+    if let Result::Ok(full_path) = which_in(&command.name, env::var_os("PATH"), cwd) {
+        if let Some(extension) = full_path.extension() {
+            #[cfg(windows)]
+            if extension.eq_ignore_ascii_case("exe") {
+                // if exe spawn it directly
+                return spawn_exe(full_path, args);
+            } else {
+                // TODO implement special care for various executable types such as .bat, .ps1, .cmd, etc
+                // https://github.com/mklement0/Native/blob/e0e0b8785cad39a73053e35084d1f60d87fbac58/Native.psm1#L749
+                // otherwise shell out to cmd
+                return spawn_cmd_command(command, args);
+            }
+            #[cfg(not(windows))]
+            if !["sh", "bash"]
+                .iter()
+                .any(|ext| extension.eq_ignore_ascii_case(ext))
+            {
+                // if exe spawn it directly
+                return spawn_exe(full_path, args);
+            } else {
+                // otherwise shell out to sh
+                return spawn_sh_command(command, args);
+            }
+        }
+    }
+    // in all the other cases shell out
+    if cfg!(windows) {
+        spawn_cmd_command(command, args)
+    } else {
+        // TODO what happens if that os doesn't support spawning sh?
+        spawn_sh_command(command, args)
+    }
+}
+
 fn spawn(
     command: &ExternalCommand,
     path: &str,
@@ -151,31 +242,7 @@ fn spawn(
 ) -> Result<InputStream, ShellError> {
     let command = command.clone();
 
-    let mut process = {
-        #[cfg(windows)]
-        {
-            let mut process = Command::new("cmd");
-            process.arg("/c");
-            process.arg(&command.name);
-            for arg in args {
-                // Clean the args before we use them:
-                // https://stackoverflow.com/questions/1200235/how-to-pass-a-quoted-pipe-character-to-cmd-exe
-                // cmd.exe needs to have a caret to escape a pipe
-                let arg = arg.replace("|", "^|");
-                process.arg(&arg);
-            }
-            process
-        }
-
-        #[cfg(not(windows))]
-        {
-            let cmd_with_args = vec![command.name.clone(), args.join(" ")].join(" ");
-            let mut process = Command::new("sh");
-            process.arg("-c").arg(cmd_with_args);
-            process
-        }
-    };
-
+    let mut process = spawn_any(&command, args, path);
     process.current_dir(path);
     trace!(target: "nu::run::external", "cwd = {:?}", &path);
 
@@ -454,7 +521,7 @@ fn spawn(
             Ok(stream.into_input_stream())
         }
         Err(e) => Err(ShellError::labeled_error(
-            format!("{}", e),
+            e.to_string(),
             "failed to spawn",
             &command.name_tag,
         )),

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

@@ -1,5 +1 @@
-mod dynamic;
 pub(crate) mod external;
-
-#[allow(unused_imports)]
-pub(crate) use dynamic::Command as DynamicCommand;

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

@@ -22,6 +22,7 @@ impl WholeStreamCommand for Histogram {
                 None,
             )
             .rest(
+                "rest",
                 SyntaxShape::ColumnPath,
                 "column name to give the histogram's frequency column",
             )

crates/nu-command/src/commands/config/set.rs

@@ -38,7 +38,7 @@ impl WholeStreamCommand for SubCommand {
             },
             Example {
                 description: "Set coloring options",
-                example: "config set color_config [[header_align header_bold]; [left $true]]",
+                example: "config set color_config [[header_align header_color]; [left white_bold]]",
                 result: None,
             },
             Example {

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

@@ -12,23 +12,11 @@ impl WholeStreamCommand for SubCommand {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("into binary")
-            .rest(
-                SyntaxShape::ColumnPath,
-                "column paths to convert to binary (for table input)",
-            )
-            .named(
-                "skip",
-                SyntaxShape::Int,
-                "skip x number of bytes",
-                Some('s'),
-            )
-            .named(
-                "bytes",
-                SyntaxShape::Int,
-                "show y number of bytes",
-                Some('b'),
-            )
+        Signature::build("into binary").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "column paths to convert to binary (for table input)",
+        )
     }
 
     fn usage(&self) -> &str {
@@ -53,43 +41,21 @@ impl WholeStreamCommand for SubCommand {
                 )
                 .into()]),
             },
-            Example {
-                description: "convert string to a nushell binary primitive",
-                example:
-                    "echo 'This is a string that is exactly 52 characters long.' | into binary --skip 10",
-                result: Some(vec![UntaggedValue::binary(
-                    "string that is exactly 52 characters long."
-                        .to_string()
-                        .as_bytes()
-                        .to_vec(),
-                )
-                .into()]),
-            },
-            Example {
-                description: "convert string to a nushell binary primitive",
-                example:
-                    "echo 'This is a string that is exactly 52 characters long.' | into binary --skip 10 --bytes 10",
-                result: Some(vec![UntaggedValue::binary(
-                    "string tha"
-                        .to_string()
-                        .as_bytes()
-                        .to_vec(),
-                )
-                .into()]),
-            },
             Example {
                 description: "convert a number to a nushell binary primitive",
                 example: "echo 1 | into binary",
-                result: Some(vec![
-                    UntaggedValue::binary(i64::from(1).to_le_bytes().to_vec()).into()
-                ]),
+                result: Some(vec![UntaggedValue::binary(
+                    i64::from(1).to_le_bytes().to_vec(),
+                )
+                .into()]),
             },
             Example {
                 description: "convert a boolean to a nushell binary primitive",
                 example: "echo $true | into binary",
-                result: Some(vec![
-                    UntaggedValue::binary(i64::from(1).to_le_bytes().to_vec()).into()
-                ]),
+                result: Some(vec![UntaggedValue::binary(
+                    i64::from(1).to_le_bytes().to_vec(),
+                )
+                .into()]),
             },
             Example {
                 description: "convert a filesize to a nushell binary primitive",
@@ -113,23 +79,19 @@ impl WholeStreamCommand for SubCommand {
 }
 
 fn into_binary(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let skip: Option<Value> = args.get_flag("skip")?;
-    let bytes: Option<Value> = args.get_flag("bytes")?;
     let column_paths: Vec<ColumnPath> = args.rest(0)?;
 
     Ok(args
         .input
         .map(move |v| {
             if column_paths.is_empty() {
-                action(&v, v.tag(), &skip, &bytes)
+                action(&v, v.tag())
             } else {
                 let mut ret = v;
                 for path in &column_paths {
-                    let skip_clone = skip.clone();
-                    let bytes_clone = bytes.clone();
                     ret = ret.swap_data_by_column_path(
                         path,
-                        Box::new(move |old| action(old, old.tag(), &skip_clone, &bytes_clone)),
+                        Box::new(move |old| action(old, old.tag())),
                     )?;
                 }
 
@@ -141,54 +103,26 @@ fn into_binary(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 fn int_to_endian(n: i64) -> Vec<u8> {
     if cfg!(target_endian = "little") {
-        // eprintln!("Little Endian");
         n.to_le_bytes().to_vec()
     } else {
-        // eprintln!("Big Endian");
         n.to_be_bytes().to_vec()
     }
 }
 
 fn bigint_to_endian(n: &BigInt) -> Vec<u8> {
     if cfg!(target_endian = "little") {
-        // eprintln!("Little Endian");
         n.to_bytes_le().1
     } else {
-        // eprintln!("Big Endian");
         n.to_bytes_be().1
     }
 }
 
-pub fn action(
-    input: &Value,
-    tag: impl Into<Tag>,
-    skip: &Option<Value>,
-    bytes: &Option<Value>,
-) -> Result<Value, ShellError> {
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
     let tag = tag.into();
-    let skip_bytes = match skip {
-        Some(s) => s.as_usize().unwrap_or(0),
-        None => 0usize,
-    };
-
-    let num_bytes = match bytes {
-        Some(b) => b.as_usize().unwrap_or(0),
-        None => 0usize,
-    };
 
     match &input.value {
         UntaggedValue::Primitive(prim) => Ok(UntaggedValue::binary(match prim {
-            Primitive::Binary(b) => {
-                if num_bytes == 0usize {
-                    b.to_vec().into_iter().skip(skip_bytes).collect()
-                } else {
-                    b.to_vec()
-                        .into_iter()
-                        .skip(skip_bytes)
-                        .take(num_bytes)
-                        .collect()
-                }
-            }
+            Primitive::Binary(b) => b.to_vec(),
             Primitive::Int(n_ref) => int_to_endian(*n_ref),
             Primitive::BigInt(n_ref) => bigint_to_endian(n_ref),
             Primitive::Decimal(dec) => match dec.to_bigint() {
@@ -207,25 +141,7 @@ pub fn action(
                     ));
                 }
             },
-            Primitive::String(a_string) => {
-                // a_string.as_bytes().to_vec()
-                if num_bytes == 0usize {
-                    a_string
-                        .as_bytes()
-                        .to_vec()
-                        .into_iter()
-                        .skip(skip_bytes)
-                        .collect()
-                } else {
-                    a_string
-                        .as_bytes()
-                        .to_vec()
-                        .into_iter()
-                        .skip(skip_bytes)
-                        .take(num_bytes)
-                        .collect()
-                }
-            }
+            Primitive::String(a_string) => a_string.as_bytes().to_vec(),
             Primitive::Boolean(a_bool) => match a_bool {
                 false => int_to_endian(0),
                 true => int_to_endian(1),

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

@@ -0,0 +1,118 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into column_path"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into column_path").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "values to convert to column_path",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to column path"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_filepath(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to column_path in table",
+                example: "echo [[name]; ['/dev/null'] ['C:\\Program Files'] ['../../Cargo.toml']] | into column_path name",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::column_path("/dev/null", Span::unknown()).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::column_path("C:\\Program Files", Span::unknown()).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::column_path("../../Cargo.toml", Span::unknown()).into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to column_path",
+                example: "echo 'Cargo.toml' | into column_path",
+                result: Some(vec![UntaggedValue::column_path("Cargo.toml", Span::unknown()).into()]),
+            },
+        ]
+    }
+}
+
+fn into_filepath(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::column_path(
+            match prim {
+                Primitive::String(a_string) => a_string,
+                _ => {
+                    return Err(ShellError::unimplemented(
+                        "'into column_path' for non-string primitives",
+                    ))
+                }
+            },
+            Span::unknown(),
+        )
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into column_path COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into column_path' for unsupported type",
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

@@ -0,0 +1,127 @@
+use std::path::PathBuf;
+
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into path"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into path").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "column paths to convert to filepath (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to filepath"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_filepath(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to filepath in table",
+                example: "echo [[name]; ['/dev/null'] ['C:\\Program Files'] ['../../Cargo.toml']] | into path name",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("/dev/null").into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("C:\\Program Files").into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("../../Cargo.toml").into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to filepath",
+                example: "echo 'Cargo.toml' | into path",
+                result: Some(vec![UntaggedValue::filepath("Cargo.toml").into()]),
+            },
+        ]
+    }
+}
+
+fn into_filepath(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::filepath(match prim {
+            Primitive::String(a_string) => match filepath_from_string(a_string, &tag) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(e);
+                }
+            },
+            Primitive::FilePath(a_filepath) => a_filepath.clone(),
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into path' for non-string primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into path COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into path' for unsupported type",
+        )),
+    }
+}
+
+fn filepath_from_string(a_string: &str, _tag: &Tag) -> Result<PathBuf, ShellError> {
+    Ok(PathBuf::from(a_string))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

@@ -0,0 +1,182 @@
+use std::convert::TryInto;
+
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+use num_bigint::ToBigInt;
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into filesize"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into filesize").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "column paths to convert to filesize (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to filesize"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_filesize(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to filesize in table",
+                example: "echo [[bytes]; ['5'] [3.2] [4] [2kb]] | into filesize bytes",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(5).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(3).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(4).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(2000).into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to filesize",
+                example: "echo '2' | into filesize",
+                result: Some(vec![UntaggedValue::filesize(2).into()]),
+            },
+            Example {
+                description: "Convert decimal to filesize",
+                example: "echo 8.3 | into filesize",
+                result: Some(vec![UntaggedValue::filesize(8).into()]),
+            },
+            Example {
+                description: "Convert int to filesize",
+                example: "echo 5 | into filesize",
+                result: Some(vec![UntaggedValue::filesize(5).into()]),
+            },
+            Example {
+                description: "Convert file size to filesize",
+                example: "echo 4KB | into filesize",
+                result: Some(vec![UntaggedValue::filesize(4000).into()]),
+            },
+        ]
+    }
+}
+
+fn into_filesize(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::filesize(match prim {
+            Primitive::String(a_string) => match int_from_string(a_string.trim(), &tag) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(e);
+                }
+            },
+            Primitive::Decimal(dec) => match dec.to_bigint() {
+                Some(n) => match n.to_u64() {
+                    Some(i) => i,
+                    None => {
+                        return Err(ShellError::unimplemented(
+                            "failed to convert decimal to filesize",
+                        ));
+                    }
+                },
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert decimal to filesize",
+                    ));
+                }
+            },
+            Primitive::Int(n_ref) => (*n_ref).try_into().map_err(|_| {
+                ShellError::unimplemented("cannot convert negative integer to filesize")
+            })?,
+            Primitive::Filesize(a_filesize) => *a_filesize,
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into filesize' for non-numeric primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into filesize COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into filesize' for unsupported type",
+        )),
+    }
+}
+
+fn int_from_string(a_string: &str, tag: &Tag) -> Result<u64, ShellError> {
+    match a_string.parse::<u64>() {
+        Ok(n) => Ok(n),
+        Err(_) => match a_string.parse::<f64>() {
+            Ok(f) => match f.to_u64() {
+                Some(i) => Ok(i),
+                None => Err(ShellError::labeled_error(
+                    "Could not convert string value to filesize",
+                    "original value",
+                    tag.clone(),
+                )),
+            },
+            Err(_) => Err(ShellError::labeled_error(
+                "Could not convert string value to filesize",
+                "original value",
+                tag.clone(),
+            )),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

@@ -13,6 +13,7 @@ impl WholeStreamCommand for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into int").rest(
+            "rest",
             SyntaxShape::ColumnPath,
             "column paths to convert to int (for table input)",
         )

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

@@ -1,9 +1,15 @@
 mod binary;
+mod column_path;
 mod command;
+mod filepath;
+mod filesize;
 mod int;
 pub mod string;
 
+pub use self::filesize::SubCommand as IntoFilesize;
 pub use binary::SubCommand as IntoBinary;
+pub use column_path::SubCommand as IntoColumnPath;
 pub use command::Command as Into;
+pub use filepath::SubCommand as IntoFilepath;
 pub use int::SubCommand as IntoInt;
 pub use string::SubCommand as IntoString;

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

@@ -20,6 +20,7 @@ impl WholeStreamCommand for SubCommand {
     fn signature(&self) -> Signature {
         Signature::build("into string")
             .rest(
+                "rest",
                 SyntaxShape::ColumnPath,
                 "column paths to convert to string (for table input)",
             )
@@ -158,7 +159,7 @@ pub fn action(
 }
 
 fn format_int(int: i64) -> String {
-    format!("{}", int)
+    int.to_string()
 
     // TODO once platform-specific dependencies are stable (see Cargo.toml)
     // #[cfg(windows)]
@@ -175,7 +176,7 @@ fn format_int(int: i64) -> String {
 }
 
 fn format_bigint(int: &BigInt) -> String {
-    format!("{}", int)
+    int.to_string()
 
     // TODO once platform-specific dependencies are stable (see Cargo.toml)
     // #[cfg(windows)]
@@ -229,7 +230,7 @@ fn format_decimal(mut decimal: BigDecimal, digits: Option<u64>, group_digits: bo
     let format_default_loc = |int_part: BigInt| {
         let loc = Locale::en;
         //TODO: when num_format is available for recent bigint, replace this with the locale-based format
-        let (int_str, sep) = (format!("{}", int_part), String::from(loc.decimal()));
+        let (int_str, sep) = (int_part.to_string(), String::from(loc.decimal()));
 
         format!("{}{}{}", int_str, sep, dec_str)
     };

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

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 
 use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape};
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
 
 pub struct Alias;
 
@@ -15,7 +15,7 @@ impl WholeStreamCommand for Alias {
         Signature::build("alias")
             .required("name", SyntaxShape::String, "the name of the alias")
             .required("equals", SyntaxShape::String, "the equals sign")
-            .rest(SyntaxShape::Any, "the expansion for the alias")
+            .rest("rest", SyntaxShape::Any, "the expansion for the alias")
     }
 
     fn usage(&self) -> &str {
@@ -35,6 +35,18 @@ impl WholeStreamCommand for Alias {
     }
 }
 
-pub fn alias(_: CommandArgs) -> Result<OutputStream, ShellError> {
+pub fn alias(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    // TODO: is there a better way of checking whether no arguments were passed?
+    if args.nth(0).is_none() {
+        let aliases = UntaggedValue::string(
+            &args
+                .scope()
+                .get_aliases()
+                .iter()
+                .map(|val| format!("{} = '{}'", val.0, val.1.iter().map(|x| &x.item).join(" ")))
+                .join("\n"),
+        );
+        return Ok(OutputStream::one(aliases));
+    }
     Ok(OutputStream::empty())
 }

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

@@ -31,7 +31,7 @@ pub fn describe(args: CommandArgs) -> Result<ActionStream, ShellError> {
     Ok(args
         .input
         .map(|row| {
-            let name = value::format_type(&row, 100);
+            let name = value::plain_type(&row, 100);
             ReturnSuccess::value(
                 UntaggedValue::string(name).into_value(Tag::unknown_anchor(row.tag.span)),
             )

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

@@ -27,7 +27,7 @@ impl WholeStreamCommand for Do {
                 "ignore errors as the block runs",
                 Some('i'),
             )
-            .rest(SyntaxShape::Any, "the parameter(s) for the block")
+            .rest("rest", SyntaxShape::Any, "the parameter(s) for the block")
     }
 
     fn usage(&self) -> &str {

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

@@ -12,7 +12,7 @@ impl WholeStreamCommand for Echo {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")
+        Signature::build("echo").rest("rest", SyntaxShape::Any, "the values to echo")
     }
 
     fn usage(&self) -> &str {

crates/nu-command/src/commands/core_commands/error/make.rs

@@ -0,0 +1,109 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, Signature, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "error make"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("error make")
+    }
+
+    fn usage(&self) -> &str {
+        "Create an error."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let input = args.input;
+
+        Ok(input
+            .map(|value| {
+                make_error(&value)
+                    .map(|err| UntaggedValue::Error(err).into_value(value.tag()))
+                    .unwrap_or_else(|| {
+                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                            "Creating error value not supported.",
+                        ))
+                        .into_value(value.tag())
+                    })
+            })
+            .into_output_stream())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Creates a labeled error",
+            example: r#"[
+  [          msg,                 labels,                      span];
+  ["The message", "Helpful message here", ([[start, end]; [0, 141]])]
+] | error make"#,
+            result: None,
+        }]
+    }
+}
+
+fn make_error(value: &Value) -> Option<ShellError> {
+    if let Value {
+        value: UntaggedValue::Row(dict),
+        ..
+    } = value
+    {
+        let msg = dict.get_data_by_key("msg".spanned_unknown());
+
+        let labels =
+            dict.get_data_by_key("labels".spanned_unknown())
+                .and_then(|table| match &table.value {
+                    UntaggedValue::Table(_) => table
+                        .table_entries()
+                        .map(|value| value.as_string().ok())
+                        .collect(),
+                    UntaggedValue::Primitive(Primitive::String(label)) => {
+                        Some(vec![label.to_string()])
+                    }
+                    _ => None,
+                });
+
+        let _anchor = dict.get_data_by_key("tag".spanned_unknown());
+        let span = dict.get_data_by_key("span".spanned_unknown());
+
+        if msg.is_none() || labels.is_none() || span.is_none() {
+            return None;
+        }
+
+        let msg = msg.and_then(|msg| msg.as_string().ok());
+
+        if let Some(labels) = labels {
+            if labels.is_empty() {
+                return None;
+            }
+
+            return Some(ShellError::labeled_error(
+                msg.expect("Message will always be present."),
+                &labels[0],
+                span.map(|data| match data {
+                    Value {
+                        value: UntaggedValue::Row(vals),
+                        ..
+                    } => match (vals.entries.get("start"), vals.entries.get("end")) {
+                        (Some(start), Some(end)) => {
+                            let start = start.as_usize().ok().unwrap_or(0);
+                            let end = end.as_usize().ok().unwrap_or(0);
+
+                            Span::new(start, end)
+                        }
+                        (_, _) => Span::unknown(),
+                    },
+                    _ => Span::unknown(),
+                })
+                .unwrap_or_else(Span::unknown),
+            ));
+        }
+    }
+
+    None
+}

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

@@ -0,0 +1,3 @@
+mod make;
+
+pub use make::SubCommand as ErrorMake;

crates/nu-command/src/commands/core_commands/find.rs

@@ -0,0 +1,110 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Find;
+
+impl WholeStreamCommand for Find {
+    fn name(&self) -> &str {
+        "find"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("find").rest("rest", SyntaxShape::String, "search term")
+    }
+
+    fn usage(&self) -> &str {
+        "Find text in the output of a previous command"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        find(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Search pipeline output for multiple terms",
+                example: r#"ls | find toml md sh"#,
+                result: None,
+            },
+            Example {
+                description: "Search strings for term(s)",
+                example: r#"echo Cargo.toml | find toml"#,
+                result: Some(vec![Value::from("Cargo.toml")]),
+            },
+            Example {
+                description: "Search a number list for term(s)",
+                example: r#"[1 2 3 4 5] | find 5"#,
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Search string list for term(s)",
+                example: r#"[moe larry curly] | find l"#,
+                result: Some(vec![Value::from("larry"), Value::from("curly")]),
+            },
+        ]
+    }
+}
+
+fn row_contains(row: &Dictionary, search_terms: Vec<String>) -> bool {
+    for term in search_terms {
+        for (k, v) in &row.entries {
+            let key = k.to_string().trim().to_lowercase();
+            let value = v.convert_to_string().trim().to_lowercase();
+            if key.contains(&term) || value.contains(&term) {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+fn find(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let rest: Vec<Value> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .filter(move |row| match &row.value {
+            UntaggedValue::Row(row) => {
+                let sterms: Vec<String> = rest
+                    .iter()
+                    .map(|t| t.convert_to_string().trim().to_lowercase())
+                    .collect();
+                row_contains(row, sterms)
+            }
+            UntaggedValue::Primitive(_p) => {
+                // eprint!("prim {}", p.type_name());
+                let sterms: Vec<String> = rest
+                    .iter()
+                    .map(|t| t.convert_to_string().trim().to_lowercase())
+                    .collect();
+
+                let prim_string = &row.convert_to_string().trim().to_lowercase();
+                for term in sterms {
+                    if prim_string.contains(&term) {
+                        return true;
+                    }
+                }
+
+                false
+            }
+            _ => false,
+        })
+        .into_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Find;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Find {})
+    }
+}

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

@@ -1,14 +1,12 @@
 use crate::prelude::*;
 use crate::TaggedListBuilder;
-use nu_engine::documentation::generate_docs;
-use nu_engine::{Command, WholeStreamCommand};
+use nu_engine::{documentation::generate_docs, Command, WholeStreamCommand};
 use nu_errors::ShellError;
 use nu_protocol::{
-    NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder,
-    UntaggedValue, Value,
+    Dictionary, NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape,
+    TaggedDictBuilder, UntaggedValue, Value,
 };
-use nu_source::Tag;
-use nu_source::{SpannedItem, Tagged};
+use nu_source::{SpannedItem, Tag, Tagged};
 use nu_value_ext::ValueExt;
 
 pub struct Help;
@@ -19,7 +17,18 @@ impl WholeStreamCommand for Help {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("help").rest(SyntaxShape::String, "the name of command to get help on")
+        Signature::build("help")
+            .rest(
+                "rest",
+                SyntaxShape::String,
+                "the name of command to get help on",
+            )
+            .named(
+                "find",
+                SyntaxShape::String,
+                "string to find in command usage",
+                Some('f'),
+            )
     }
 
     fn usage(&self) -> &str {
@@ -29,14 +38,81 @@ impl WholeStreamCommand for Help {
     fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
         help(args)
     }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "show all commands and sub-commands",
+                example: "help commands",
+                result: None,
+            },
+            Example {
+                description: "generate documentation",
+                example: "help generate_docs",
+                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 usage",
+                example: "help --find char",
+                result: None,
+            },
+        ]
+    }
 }
 
 fn help(args: CommandArgs) -> Result<ActionStream, ShellError> {
     let name = args.call_info.name_tag.clone();
     let scope = args.scope().clone();
-
+    let find: Option<Tagged<String>> = args.get_flag("find")?;
     let rest: Vec<Tagged<String>> = args.rest(0)?;
 
+    if let Some(f) = find {
+        let search_string = f.item;
+        let full_commands = scope.get_commands_info();
+        let mut found_cmds_vec = Vec::new();
+
+        for (key, cmd) in full_commands {
+            let mut indexmap = IndexMap::new();
+
+            let c = cmd.usage().to_string();
+            let e = cmd.extra_usage().to_string();
+            if key.to_lowercase().contains(&search_string)
+                || c.to_lowercase().contains(&search_string)
+                || e.to_lowercase().contains(&search_string)
+            {
+                indexmap.insert(
+                    "name".to_string(),
+                    UntaggedValue::string(key).into_value(&name),
+                );
+
+                indexmap.insert(
+                    "usage".to_string(),
+                    UntaggedValue::string(cmd.usage().to_string()).into_value(&name),
+                );
+
+                indexmap.insert(
+                    "extra_usage".to_string(),
+                    UntaggedValue::string(cmd.extra_usage().to_string()).into_value(&name),
+                );
+
+                found_cmds_vec
+                    .push(UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&name));
+            }
+        }
+
+        return Ok(found_cmds_vec.into_iter().into_action_stream());
+    }
+
     if !rest.is_empty() {
         if rest[0].item == "commands" {
             let mut sorted_names = scope.get_command_names();
@@ -44,11 +120,11 @@ fn help(args: CommandArgs) -> Result<ActionStream, ShellError> {
 
             let (mut subcommand_names, command_names) = sorted_names
                 .into_iter()
-                // Internal only commands shouldn't be displayed
+                // private only commands shouldn't be displayed
                 .filter(|cmd_name| {
                     scope
                         .get_command(cmd_name)
-                        .filter(|command| !command.is_internal())
+                        .filter(|command| !command.is_private())
                         .is_some()
                 })
                 .partition::<Vec<_>, _>(|cmd_name| cmd_name.contains(' '));
@@ -226,7 +302,7 @@ pub fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
     let tag = tag.into();
     let mut sig = TaggedListBuilder::new(&tag);
 
-    for arg in signature.positional.iter() {
+    for arg in &signature.positional {
         let is_required = matches!(arg.0, PositionalType::Mandatory(_, _));
 
         sig.push_value(for_spec(arg.0.name(), "argument", is_required, &tag));
@@ -237,7 +313,7 @@ pub fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
         sig.push_value(for_spec("rest", "argument", is_required, &tag));
     }
 
-    for (name, ty) in signature.named.iter() {
+    for (name, ty) in &signature.named {
         match ty.0 {
             NamedType::Mandatory(_, _) => sig.push_value(for_spec(name, "flag", true, &tag)),
             NamedType::Optional(_, _) => sig.push_value(for_spec(name, "flag", false, &tag)),

crates/nu-command/src/commands/core_commands/if_.rs

@@ -100,18 +100,15 @@ fn if_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
     context.scope.add_vars(&condition.captured.entries);
 
     //FIXME: should we use the scope that's brought in as well?
-    let condition = evaluate_baseline_expr(cond, &*context);
-    match condition {
+    let condition = evaluate_baseline_expr(cond, &context);
+    let result = match condition {
         Ok(condition) => match condition.as_bool() {
             Ok(b) => {
-                let result = if b {
-                    run_block(&then_case.block, &*context, input, external_redirection)
+                if b {
+                    run_block(&then_case.block, &context, input, external_redirection)
                 } else {
-                    run_block(&else_case.block, &*context, input, external_redirection)
-                };
-                context.scope.exit_scope();
-
-                result
+                    run_block(&else_case.block, &context, input, external_redirection)
+                }
             }
             Err(e) => Ok(OutputStream::from_stream(
                 vec![UntaggedValue::Error(e).into_untagged_value()].into_iter(),
@@ -120,13 +117,16 @@ fn if_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
         Err(e) => Ok(OutputStream::from_stream(
             vec![UntaggedValue::Error(e).into_untagged_value()].into_iter(),
         )),
-    }
+    };
+    context.scope.exit_scope();
+    result
 }
 
 #[cfg(test)]
 mod tests {
     use super::If;
     use super::ShellError;
+    use nu_test_support::nu;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
@@ -134,4 +134,21 @@ mod tests {
 
         test_examples(If {})
     }
+
+    #[test]
+    fn if_doesnt_leak_on_error() {
+        let actual = nu!(
+            ".",
+            r#"
+                def test-leak [] {
+                    let var = "hello"
+                    if 0 == "" {echo ok} {echo not}
+                }
+                test-leak
+                echo $var
+            "#
+        );
+
+        assert!(actual.err.contains("unknown variable"));
+    }
 }

crates/nu-command/src/commands/core_commands/let_.rs

@@ -63,7 +63,7 @@ pub fn letcmd(args: CommandArgs) -> Result<ActionStream, ShellError> {
         .expect("Internal error: type checker should require args");
 
     let var_name = positional[0].var_name()?;
-    let rhs_raw = evaluate_baseline_expr(&positional[2], &ctx)?;
+    let rhs_raw = evaluate_baseline_expr(&positional[2], ctx)?;
     let tag: Tag = positional[2].span.into();
 
     let rhs: CapturedBlock = FromValue::from_value(&rhs_raw)?;
@@ -98,7 +98,7 @@ pub fn letcmd(args: CommandArgs) -> Result<ActionStream, ShellError> {
     };
 
     ctx.scope.enter_scope();
-    let value = evaluate_baseline_expr(expr, &ctx);
+    let value = evaluate_baseline_expr(expr, ctx);
     ctx.scope.exit_scope();
 
     let value = value?;

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

@@ -4,6 +4,8 @@ mod def;
 mod describe;
 mod do_;
 pub(crate) mod echo;
+mod error;
+mod find;
 mod help;
 mod history;
 mod if_;
@@ -13,6 +15,8 @@ mod nu_plugin;
 mod nu_signature;
 mod source;
 mod tags;
+mod tutor;
+mod unalias;
 mod version;
 
 pub use self::nu_plugin::SubCommand as NuPlugin;
@@ -25,6 +29,8 @@ pub use def::Def;
 pub use describe::Describe;
 pub use do_::Do;
 pub use echo::Echo;
+pub use error::*;
+pub use find::Find;
 pub use help::Help;
 pub use history::History;
 pub use if_::If;
@@ -32,4 +38,6 @@ pub use ignore::Ignore;
 pub use let_::Let;
 pub use source::Source;
 pub use tags::Tags;
+pub use tutor::Tutor;
+pub use unalias::Unalias;
 pub use version::{version, Version};

crates/nu-command/src/commands/core_commands/nu_plugin.rs

@@ -4,7 +4,7 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 
 use nu_errors::ShellError;
-use nu_path::canonicalize;
+use nu_path::canonicalize_with;
 use nu_protocol::{CommandAction, ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
 use nu_source::Tagged;
 
@@ -56,7 +56,7 @@ impl WholeStreamCommand for SubCommand {
             tag,
         }) = load_path
         {
-            let path = canonicalize(shell_manager.path(), load_path).map_err(|_| {
+            let path = canonicalize_with(load_path, shell_manager.path()).map_err(|_| {
                 ShellError::labeled_error(
                     "Cannot load plugins from directory",
                     "directory not found",

crates/nu-command/src/commands/core_commands/nu_signature.rs

@@ -14,6 +14,8 @@ impl WholeStreamCommand for Command {
             .switch("stdin", "redirect stdin", None)
             .switch("skip-plugins", "do not load plugins", None)
             .switch("no-history", "don't save history", None)
+            .switch("perf", "show startup performance metrics", None)
+            .switch("login", "start Nu as if it was a login shell", Some('l'))
             .named(
                 "commands",
                 SyntaxShape::String,
@@ -32,7 +34,7 @@ impl WholeStreamCommand for Command {
                 "loglevel",
                 SyntaxShape::String,
                 "LEVEL: error, warn, info, debug, trace",
-                Some('l'),
+                None,
             )
             .named(
                 "config-file",
@@ -40,7 +42,7 @@ impl WholeStreamCommand for Command {
                 "custom configuration source file",
                 None,
             )
-            .rest(SyntaxShape::String, "source file(s) to run")
+            .rest("rest", SyntaxShape::String, "source file(s) to run")
     }
 
     fn usage(&self) -> &str {

crates/nu-command/src/commands/core_commands/source.rs

@@ -2,11 +2,11 @@ use crate::prelude::*;
 use nu_engine::{script, WholeStreamCommand};
 
 use nu_errors::ShellError;
-use nu_path::expand_path;
+use nu_path::{canonicalize, canonicalize_with};
 use nu_protocol::{Signature, SyntaxShape};
 use nu_source::Tagged;
 
-use std::{borrow::Cow, path::Path};
+use std::path::Path;
 
 pub struct Source;
 
@@ -32,7 +32,7 @@ impl WholeStreamCommand for Source {
         "Runs a script file in the current context."
     }
 
-    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         source(args)
     }
 
@@ -41,31 +41,83 @@ impl WholeStreamCommand for Source {
     }
 }
 
-pub fn source(args: CommandArgs) -> Result<ActionStream, ShellError> {
+pub fn source(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let ctx = &args.context;
     let filename: Tagged<String> = args.req(0)?;
 
+    let source_file = Path::new(&filename.item);
+
     // Note: this is a special case for setting the context from a command
     // In this case, if we don't set it now, we'll lose the scope that this
     // variable should be set into.
-    let contents = std::fs::read_to_string(&expand_path(Cow::Borrowed(Path::new(&filename.item))));
+
+    let lib_dirs = &ctx
+        .configs()
+        .lock()
+        .global_config
+        .as_ref()
+        .map(|configuration| match configuration.var("lib_dirs") {
+            Some(paths) => paths
+                .table_entries()
+                .cloned()
+                .map(|path| path.as_string())
+                .collect(),
+            None => vec![],
+        });
+
+    if let Some(dir) = lib_dirs {
+        for lib_path in dir {
+            match lib_path {
+                Ok(name) => {
+                    let path = if let Ok(p) = canonicalize_with(&source_file, name) {
+                        p
+                    } else {
+                        continue;
+                    };
+
+                    if let Ok(contents) = std::fs::read_to_string(path) {
+                        let result = script::run_script_standalone(contents, true, ctx, false);
+
+                        if let Err(err) = result {
+                            ctx.error(err);
+                        }
+                        return Ok(OutputStream::empty());
+                    }
+                }
+                Err(reason) => {
+                    ctx.error(reason.clone());
+                }
+            }
+        }
+    }
+
+    let path = canonicalize(source_file).map_err(|e| {
+        ShellError::labeled_error(
+            format!("Can't load source file. Reason: {}", e.to_string()),
+            "Can't load this file",
+            filename.span(),
+        )
+    })?;
+
+    let contents = std::fs::read_to_string(path);
+
     match contents {
         Ok(contents) => {
-            let result = script::run_script_standalone(contents, true, &ctx, false);
+            let result = script::run_script_standalone(contents, true, ctx, false);
 
             if let Err(err) = result {
                 ctx.error(err);
             }
-            Ok(ActionStream::empty())
+            Ok(OutputStream::empty())
         }
-        Err(_) => {
+        Err(e) => {
             ctx.error(ShellError::labeled_error(
-                "Can't load file to source",
-                "can't load file",
+                format!("Can't load source file. Reason: {}", e.to_string()),
+                "Can't load this file",
                 filename.span(),
             ));
 
-            Ok(ActionStream::empty())
+            Ok(OutputStream::empty())
         }
     }
 }

crates/nu-command/src/commands/core_commands/tags.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{Signature, TaggedDictBuilder, UntaggedValue};
+use nu_protocol::{Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value};
 
 pub struct Tags;
 
@@ -18,37 +18,64 @@ impl WholeStreamCommand for Tags {
         "Read the tags (metadata) for values."
     }
 
-    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         Ok(tags(args))
     }
 }
 
-fn tags(args: CommandArgs) -> ActionStream {
-    args.input
-        .map(move |v| {
-            let mut tags = TaggedDictBuilder::new(v.tag());
-            {
-                let anchor = v.anchor();
-                let span = v.tag.span;
-                let mut dict = TaggedDictBuilder::new(v.tag());
-                dict.insert_untagged("start", UntaggedValue::int(span.start() as i64));
-                dict.insert_untagged("end", UntaggedValue::int(span.end() as i64));
-                tags.insert_value("span", dict.into_value());
+fn build_tag_table(tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+    let span = tag.span;
 
-                match anchor {
-                    Some(AnchorLocation::File(source)) => {
-                        tags.insert_untagged("anchor", UntaggedValue::string(source));
-                    }
-                    Some(AnchorLocation::Url(source)) => {
-                        tags.insert_untagged("anchor", UntaggedValue::string(source));
-                    }
-                    _ => {}
-                }
+    TaggedDictBuilder::build(tag.clone(), |tags| {
+        if let Some(anchor) = anchor_as_value(&tag) {
+            tags.insert_value("anchor", anchor);
+        }
+
+        tags.insert_value(
+            "span",
+            TaggedDictBuilder::build(tag.clone(), |span_dict| {
+                span_dict.insert_untagged("start", UntaggedValue::int(span.start() as i64));
+                span_dict.insert_untagged("end", UntaggedValue::int(span.end() as i64));
+            }),
+        );
+    })
+}
+
+fn tags(args: CommandArgs) -> OutputStream {
+    if args.input.is_empty() {
+        OutputStream::one(build_tag_table(&args.name_tag()))
+    } else {
+        args.input
+            .map(move |v| build_tag_table(v.tag()))
+            .into_output_stream()
+    }
+}
+
+fn anchor_as_value(tag: &Tag) -> Option<Value> {
+    let anchor = tag.anchor.as_ref();
+
+    anchor.as_ref()?;
+
+    Some(TaggedDictBuilder::build(tag, |table| {
+        let value = match anchor {
+            Some(AnchorLocation::File(path)) => {
+                Some(("file", UntaggedValue::from(path.to_string())))
             }
+            Some(AnchorLocation::Url(destination)) => {
+                Some(("url", UntaggedValue::from(destination.to_string())))
+            }
+            Some(AnchorLocation::Source(text)) => Some((
+                "source",
+                UntaggedValue::Primitive(Primitive::String(text.to_string())),
+            )),
+            None => None,
+        };
 
-            tags.into_value()
-        })
-        .into_action_stream()
+        if let Some((key, value)) = value {
+            table.insert_untagged(key, value);
+        }
+    }))
 }
 
 #[cfg(test)]

crates/nu-command/src/commands/core_commands/tutor.rs

@@ -0,0 +1,407 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+
+pub struct Tutor;
+
+impl WholeStreamCommand for Tutor {
+    fn name(&self) -> &str {
+        "tutor"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("tutor")
+            .optional(
+                "search",
+                SyntaxShape::String,
+                "item to search for, or 'list' to list available tutorials",
+            )
+            .named(
+                "find",
+                SyntaxShape::String,
+                "Search tutorial for a phrase",
+                Some('f'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Run the tutorial. To begin, run: tutor"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        tutor(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Begin the tutorial",
+                example: "tutor begin",
+                result: None,
+            },
+            Example {
+                description: "Search a tutorial by phrase",
+                example: "tutor -f \"$in\"",
+                result: None,
+            },
+        ]
+    }
+}
+
+fn tutor(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.name_tag();
+    let scope = args.scope().clone();
+
+    let search: Option<String> = args.opt(0).unwrap_or(None);
+    let find: Option<String> = args.get_flag("find")?;
+
+    let search_space = [
+        (vec!["begin"], begin_tutor()),
+        (
+            vec!["table", "tables", "row", "rows", "column", "columns"],
+            table_tutor(),
+        ),
+        (vec!["cell", "cells"], cell_tutor()),
+        (
+            vec![
+                "expr",
+                "exprs",
+                "expressions",
+                "subexpression",
+                "subexpressions",
+                "sub-expression",
+                "sub-expressions",
+            ],
+            expression_tutor(),
+        ),
+        (vec!["echo"], echo_tutor()),
+        (vec!["each", "iteration", "iter"], each_tutor()),
+        (
+            vec!["var", "vars", "variable", "variables"],
+            variable_tutor(),
+        ),
+        (vec!["block", "blocks"], block_tutor()),
+        (vec!["shorthand", "shorthands"], shorthand_tutor()),
+    ];
+
+    if let Some(find) = find {
+        let mut results = vec![];
+        for search_group in search_space {
+            if search_group.1.contains(&find) {
+                results.push(search_group.0[0].to_string())
+            }
+        }
+
+        let message = format!("You can find '{}' in the following topics:\n{}\n\nYou can learn about a topic using `tutor` followed by the name of the topic.\nFor example: `tutor table` to open the table topic.\n\n",
+            find,
+            results.into_iter().map(|x| format!("- {}", x)).join("\n")
+        );
+
+        return Ok(display(tag, &scope, &message));
+    } else if let Some(search) = search {
+        for search_group in search_space {
+            if search_group.0.contains(&search.as_str()) {
+                return Ok(display(tag, &scope, search_group.1));
+            }
+        }
+    }
+    Ok(display(tag, &scope, default_tutor()))
+}
+
+fn default_tutor() -> &'static str {
+    r#"
+Welcome to the Nushell tutorial!
+
+With the `tutor` command, you'll be able to learn a lot about how Nushell
+works along with many fun tips and tricks to speed up everyday tasks.
+
+To get started, you can use `tutor begin`.
+
+"#
+}
+
+fn begin_tutor() -> &'static str {
+    r#"
+Nushell is a structured shell and programming language. One way to begin
+using it is to try a few of the commands.
+
+The first command to try is `ls`. The `ls` command will show you a list
+of the files in the current directory. Notice that these files are shown
+as a table. Each column of this table not only tells us what is being
+shown, but also gives us a way to work with the data.
+
+You can combine the `ls` command with other commands using the pipeline
+symbol '|'. This allows data to flow from one command to the next.
+
+For example, if we only wanted the name column, we could do:
+```
+ls | select name
+```
+Notice that we still get a table, but this time it only has one column:
+the name column.
+
+You can continue to learn more about tables by running:
+```
+tutor tables
+```
+If at any point, you'd like to restart this tutorial, you can run:
+```
+tutor begin
+```
+"#
+}
+
+fn table_tutor() -> &'static str {
+    r#"
+The most common form of data in Nushell is the table. Tables contain rows and
+columns of data. In each cell of the table, there is data that you can access
+using Nushell commands.
+
+To get the 3rd row in the table, you can use the `nth` command:
+```
+ls | nth 2
+```
+This will get the 3rd (note that `nth` is zero-based) row in the table created
+by the `ls` command. You can use `nth` on any table created by other commands
+as well.
+
+You can also access the column of data in one of two ways. If you want
+to keep the column as part of a new table, you can use `select`.
+```
+ls | select name
+```
+This runs `ls` and returns only the "name" column of the table.
+
+If, instead, you'd like to get access to the values inside of the column, you
+can use the `get` command.
+```
+ls | get name
+```
+This allows us to get to the list of strings that are the filenames rather
+than having a full table. In some cases, this can make the names easier to 
+work with.
+
+You can continue to learn more about working with cells of the table by
+running:
+```
+tutor cells
+```
+"#
+}
+
+fn cell_tutor() -> &'static str {
+    r#"
+Working with cells of data in the table is a key part of working with data in
+Nushell. Because of this, there is a rich list of commands to work with cells
+as well as handy shorthands for accessing cells.
+
+Cells can hold simple values like strings and numbers, or more complex values
+like lists and tables.
+
+To reach a cell of data from a table, you can combine a row operation and a
+column operation.
+```
+ls | nth 4 | get name
+```
+You can combine these operations into one step using a shortcut.
+```
+(ls).4.name
+```
+Names/strings represent columns names and numbers represent row numbers.
+
+The `(ls)` is a form of expression. You can continue to learn more about
+expressions by running:
+```
+tutor expressions
+```
+You can also learn about these cell shorthands by running:
+```
+tutor shorthands
+```
+"#
+}
+
+fn expression_tutor() -> &'static str {
+    r#"
+Expressions give you the power to mix calls to commands with math. The
+simplest expression is a single value like a string or number.
+```
+3
+```
+Expressions can also include math operations like addition or division.
+```
+10 / 2
+```
+Normally, an expression is one type of operation: math or commands. You can
+mix these types by using subexpressions. Subexpressions are just like
+expressions, but they're wrapped in parentheses `()`.
+```
+10 * (3 + 4)
+```
+Here we use parentheses to create a higher math precedence in the math 
+expression.
+```
+echo (2 + 3)
+```
+You can continue to learn more about the `echo` command by running:
+```
+tutor echo
+```
+"#
+}
+
+fn echo_tutor() -> &'static str {
+    r#"
+The `echo` command in Nushell is a powerful tool for not only seeing values,
+but also for creating new ones.
+```
+echo "Hello"
+```
+You can echo output. This output, if it's not redirected using a "|" pipeline
+will be displayed to the screen.
+```
+echo 1..10
+```
+You can also use echo to work with individual values of a range. In this
+example, `echo` will create the values from 1 to 10 as a list.
+```
+echo 1 2 3 4 5
+```
+You can also create lists of values by passing `echo` multiple arguments.
+This can be helpful if you want to later processes these values.
+
+The `echo` command can pair well with the `each` command which can run
+code on each row, or item, of input.
+
+You can continue to learn more about the `each` command by running:
+```
+tutor each
+```
+"#
+}
+
+fn each_tutor() -> &'static str {
+    r#"
+The `each` command gives us a way of working with each individual row or
+element of a list one at a time. It reads these in from the pipeline and
+runs a block on each element. A block is a group of pipelines.
+```
+echo 1 2 3 | each { $it + 10}
+```
+This example iterates over each element sent by `echo`, giving us three new
+values that are the original value + 10. Here, the `$it` is a variable that
+is the name given to the block's parameter by default.
+
+You can learn more about blocks by running:
+```
+tutor blocks
+```
+You can also learn more about variables by running:
+```
+tutor variables
+```
+"#
+}
+
+fn variable_tutor() -> &'static str {
+    r#"
+Variables are an important way to store values to be used later. To create a
+variable, you can use the `let` keyword. The `let` command will create a
+variable and then assign it a value in one step.
+```
+let $x = 3
+```
+Once created, we can refer to this variable by name.
+```
+$x
+```
+Nushell also comes with built-in variables. The `$nu` variable is a reserved
+variable that contains a lot of information about the currently running
+instance of Nushell. The `$it` variable is the name given to block parameters
+if you don't specify one. And `$in` is the variable that allows you to work
+with all of the data coming in from the pipeline in one place.
+
+"#
+}
+
+fn block_tutor() -> &'static str {
+    r#"
+Blocks are a special form of expression that hold code to be run at a later
+time. Often, you'll see blocks as one of the arguments given to commands
+like `each` and `if`.
+```
+ls | each {|x| $x.name}
+```
+The above will create a list of the filenames in the directory.
+```
+if $true { echo "it's true" } { echo "it's not true" }
+```
+This `if` call will run the first block if the expression is true, or the
+second block if the expression is false.
+
+"#
+}
+
+fn shorthand_tutor() -> &'static str {
+    r#"
+You can access cells in a table using a shorthand notation sometimes called a
+"column path" or "cell path". These paths allow you to go from a table to
+rows, columns, or cells inside of the table.
+
+Shorthand paths are made from rows numbers, column names, or both. You can use
+them on any variable or subexpression.
+```
+$nu.cwd
+```
+The above accesses the built-in `$nu` variable, gets its table, and then uses
+the shorthand path to retrieve only the cell data inside the "cwd" column.
+```
+(ls).name.4
+```
+This will retrieve the cell data in the "name" column on the 5th row (note: 
+row numbers are zero-based).
+
+Rows and columns don't need to come in any specific order. You can get the
+same value using:
+```
+(ls).4.name
+```
+"#
+}
+
+fn display(tag: Tag, scope: &Scope, help: &str) -> OutputStream {
+    let help = help.split('`');
+
+    let mut build = String::new();
+    let mut code_mode = false;
+    let palette = nu_engine::DefaultPalette {};
+
+    for item in help {
+        if code_mode {
+            code_mode = false;
+
+            //TODO: support no-color mode
+            let colored_example = nu_engine::Painter::paint_string(item, scope, &palette);
+            build.push_str(&colored_example);
+        } else {
+            code_mode = true;
+            build.push_str(item);
+        }
+    }
+
+    OutputStream::one(UntaggedValue::string(build).into_value(tag))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::Tutor;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Tutor {})
+    }
+}

crates/nu-command/src/commands/core_commands/unalias.rs

@@ -0,0 +1,37 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+
+pub struct Unalias;
+
+impl WholeStreamCommand for Unalias {
+    fn name(&self) -> &str {
+        "unalias"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("unalias").required("name", SyntaxShape::String, "the name of the alias")
+    }
+
+    fn usage(&self) -> &str {
+        "Removes an alias"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        unalias(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Remove the 'v' alias",
+            example: "unalias v",
+            result: None,
+        }]
+    }
+}
+
+pub fn unalias(_: CommandArgs) -> Result<OutputStream, ShellError> {
+    Ok(OutputStream::empty())
+}

crates/nu-command/src/commands/core_commands/version.rs

@@ -184,16 +184,13 @@ pub fn version(args: CommandArgs) -> Result<OutputStream, ShellError> {
 fn features_enabled() -> Vec<String> {
     let mut names = vec!["default".to_string()];
 
+    // NOTE: There should be another way to know
+    // features on.
     #[cfg(feature = "ctrlc")]
     {
         names.push("ctrlc".to_string());
     }
 
-    #[cfg(feature = "ptree")]
-    {
-        names.push("ptree".to_string());
-    }
-
     // #[cfg(feature = "rich-benchmark")]
     // {
     //     names.push("rich-benchmark".to_string());
@@ -224,16 +221,21 @@ fn features_enabled() -> Vec<String> {
         names.push("zip".to_string());
     }
 
-    #[cfg(feature = "clipboard-cli")]
-    {
-        names.push("clipboard-cli".to_string());
-    }
-
     #[cfg(feature = "trash-support")]
     {
         names.push("trash".to_string());
     }
 
+    #[cfg(feature = "dataframe")]
+    {
+        names.push("dataframe".to_string());
+    }
+
+    #[cfg(feature = "table-pager")]
+    {
+        names.push("table-pager".to_string());
+    }
+
     // #[cfg(feature = "binaryview")]
     // {
     //     names.push("binaryview".to_string());

crates/nu-command/src/commands/dataframe/aggregate.rs

@@ -2,16 +2,11 @@ use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::{NuDataFrame, PolarsData},
-    Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+    dataframe::{Column, FrameStruct, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
 };
 use nu_source::Tagged;
-use polars::{
-    frame::groupby::GroupBy,
-    prelude::{DataType, PolarsError, Series},
-};
-
-use super::utils::convert_columns;
+use polars::{frame::groupby::GroupBy, prelude::PolarsError};
 
 enum Operation {
     Mean,
@@ -84,23 +79,23 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Performs an aggregation operation on a dataframe or groupby object"
+        "[DataFrame, GroupBy, Series] Performs an aggregation operation on a dataframe, groupby or series object"
     }
 
     fn signature(&self) -> Signature {
         Signature::build("dataframe aggregate")
             .required("operation", SyntaxShape::String, "aggregate operation")
-            .optional(
-                "selection",
-                SyntaxShape::Table,
-                "columns to perform aggregation",
-            )
             .named(
                 "quantile",
                 SyntaxShape::Number,
                 "quantile value for quantile operation",
                 Some('q'),
             )
+            .switch(
+                "explicit",
+                "returns explicit names for groupby aggregations",
+                Some('e'),
+            )
     }
 
     fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
@@ -112,18 +107,41 @@ impl WholeStreamCommand for DataFrame {
             Example {
                 description: "Aggregate sum by grouping by column a and summing on col b",
                 example:
-                    "[[a b]; [one 1] [one 2]] | dataframe to-df | dataframe group-by [a] | dataframe aggregate sum",
-                result: None,
+                    "[[a b]; [one 1] [one 2]] | dataframe to-df | dataframe group-by a | dataframe aggregate sum",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new("a".to_string(), vec![UntaggedValue::string("one").into()]),
+                        Column::new("b".to_string(), vec![UntaggedValue::int(3).into()]),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
             Example {
                 description: "Aggregate sum in dataframe columns",
                 example: "[[a b]; [4 1] [5 2]] | dataframe to-df | dataframe aggregate sum",
-                result: None,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new("a".to_string(), vec![UntaggedValue::int(9).into()]),
+                        Column::new("b".to_string(), vec![UntaggedValue::int(3).into()]),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
             Example {
                 description: "Aggregate sum in series",
-                example: "[4 1 5 6] | dataframe to-series | dataframe aggregate sum",
-                result: None,
+                example: "[4 1 5 6] | dataframe to-df | dataframe aggregate sum",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new("0".to_string(), vec![UntaggedValue::int(16).into()]),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
         ]
     }
@@ -136,57 +154,34 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let operation: Tagged<String> = args.req(0)?;
     let op = Operation::from_tagged(&operation, quantile)?;
 
-    // Extracting the selection columns of the columns to perform the aggregation
-    let agg_cols: Option<Vec<Value>> = args.opt(1)?;
-    let (selection, agg_span) = match agg_cols {
-        Some(cols) => {
-            let (agg_string, agg_span) = convert_columns(&cols, &tag)?;
-            (Some(agg_string), agg_span)
-        }
-        None => (None, Span::unknown()),
-    };
-
     let value = args.input.next().ok_or_else(|| {
         ShellError::labeled_error("Empty stream", "No value found in the stream", &tag)
     })?;
 
     match value.value {
-        UntaggedValue::DataFrame(PolarsData::GroupBy(nu_groupby)) => {
+        UntaggedValue::FrameStruct(FrameStruct::GroupBy(nu_groupby)) => {
             let groupby = nu_groupby.to_groupby()?;
 
-            let groupby = match &selection {
-                Some(cols) => groupby.select(cols),
-                None => groupby,
-            };
-
-            let res = perform_groupby_aggregation(groupby, op, &operation.tag, &agg_span)?;
+            let res = perform_groupby_aggregation(
+                groupby,
+                op,
+                &operation.tag,
+                &tag.span,
+                args.has_flag("explicit"),
+            )?;
 
             Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
         }
-        UntaggedValue::DataFrame(PolarsData::EagerDataFrame(df)) => {
+        UntaggedValue::DataFrame(df) => {
             let df = df.as_ref();
 
-            let res = match &selection {
-                Some(cols) => {
-                    let df = df
-                        .select(cols)
-                        .map_err(|e| parse_polars_error::<&str>(&e, &agg_span, None))?;
-
-                    perform_dataframe_aggregation(&df, op, &operation.tag)
-                }
-                None => perform_dataframe_aggregation(&df, op, &operation.tag),
-            }?;
+            let res = perform_dataframe_aggregation(df, op, &operation.tag)?;
 
             Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
         }
-        UntaggedValue::DataFrame(PolarsData::Series(series)) => {
-            let value = perform_series_aggregation(series.as_ref(), op, &operation.tag)?;
-
-            Ok(OutputStream::one(value))
-        }
         _ => Err(ShellError::labeled_error(
-            "No groupby or dataframe",
-            "no groupby or found in input stream",
+            "No groupby, dataframe or series in stream",
+            "no groupby, dataframe or series found in input stream",
             &value.tag.span,
         )),
     }
@@ -197,8 +192,9 @@ fn perform_groupby_aggregation(
     operation: Operation,
     operation_tag: &Tag,
     agg_span: &Span,
+    explicit: bool,
 ) -> Result<polars::prelude::DataFrame, ShellError> {
-    match operation {
+    let mut res = match operation {
         Operation::Mean => groupby.mean(),
         Operation::Sum => groupby.sum(),
         Operation::Min => groupby.min(),
@@ -219,7 +215,42 @@ fn perform_groupby_aggregation(
         };
 
         parse_polars_error::<&str>(&e, span, None)
-    })
+    })?;
+
+    if !explicit {
+        let col_names = res
+            .get_column_names()
+            .iter()
+            .map(|name| name.to_string())
+            .collect::<Vec<String>>();
+
+        for col in col_names {
+            let from = match operation {
+                Operation::Mean => "_mean",
+                Operation::Sum => "_sum",
+                Operation::Min => "_min",
+                Operation::Max => "_max",
+                Operation::First => "_first",
+                Operation::Last => "_last",
+                Operation::Nunique => "_n_unique",
+                Operation::Quantile(_) => "_quantile",
+                Operation::Median => "_median",
+                Operation::Var => "_agg_var",
+                Operation::Std => "_agg_std",
+                Operation::Count => "_count",
+            };
+
+            let new_col = match col.find(from) {
+                Some(index) => &col[..index],
+                None => &col[..],
+            };
+
+            res.rename(&col, new_col)
+                .expect("Column is always there. Looping with known names");
+        }
+    }
+
+    Ok(res)
 }
 
 fn perform_dataframe_aggregation(
@@ -248,162 +279,15 @@ fn perform_dataframe_aggregation(
     }
 }
 
-fn perform_series_aggregation(
-    series: &Series,
-    operation: Operation,
-    operation_tag: &Tag,
-) -> Result<Value, ShellError> {
-    match operation {
-        Operation::Mean => {
-            let res = match series.mean() {
-                Some(val) => UntaggedValue::Primitive(val.into()),
-                None => UntaggedValue::Primitive(0.into()),
-            };
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
 
-            let value = Value {
-                value: res,
-                tag: operation_tag.clone(),
-            };
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
 
-            let mut data = TaggedDictBuilder::new(operation_tag.clone());
-            data.insert_value("mean", value);
-
-            Ok(data.into_value())
-        }
-        Operation::Median => {
-            let res = match series.median() {
-                Some(val) => UntaggedValue::Primitive(val.into()),
-                None => UntaggedValue::Primitive(0.into()),
-            };
-
-            let value = Value {
-                value: res,
-                tag: operation_tag.clone(),
-            };
-
-            let mut data = TaggedDictBuilder::new(operation_tag.clone());
-            data.insert_value("median", value);
-
-            Ok(data.into_value())
-        }
-        Operation::Sum => {
-            let untagged = match series.dtype() {
-                DataType::Int8
-                | DataType::Int16
-                | DataType::Int32
-                | DataType::Int64
-                | DataType::UInt8
-                | DataType::UInt16
-                | DataType::UInt32
-                | DataType::UInt64 => {
-                    let res: i64 = series.sum().unwrap_or(0);
-                    Ok(UntaggedValue::Primitive(res.into()))
-                }
-                DataType::Float32 | DataType::Float64 => {
-                    let res: f64 = series.sum().unwrap_or(0.0);
-                    Ok(UntaggedValue::Primitive(res.into()))
-                }
-                _ => Err(ShellError::labeled_error(
-                    "Not valid type",
-                    format!(
-                        "this operation can not be performed with series of type {}",
-                        series.dtype()
-                    ),
-                    &operation_tag.span,
-                )),
-            }?;
-
-            let value = Value {
-                value: untagged,
-                tag: operation_tag.clone(),
-            };
-
-            let mut data = TaggedDictBuilder::new(operation_tag.clone());
-            data.insert_value("sum", value);
-
-            Ok(data.into_value())
-        }
-        Operation::Max => {
-            let untagged = match series.dtype() {
-                DataType::Int8
-                | DataType::Int16
-                | DataType::Int32
-                | DataType::Int64
-                | DataType::UInt8
-                | DataType::UInt16
-                | DataType::UInt32
-                | DataType::UInt64 => {
-                    let res: i64 = series.max().unwrap_or(0);
-                    Ok(UntaggedValue::Primitive(res.into()))
-                }
-                DataType::Float32 | DataType::Float64 => {
-                    let res: f64 = series.max().unwrap_or(0.0);
-                    Ok(UntaggedValue::Primitive(res.into()))
-                }
-                _ => Err(ShellError::labeled_error(
-                    "Not valid type",
-                    format!(
-                        "this operation can not be performed with series of type {}",
-                        series.dtype()
-                    ),
-                    &operation_tag.span,
-                )),
-            }?;
-
-            let value = Value {
-                value: untagged,
-                tag: operation_tag.clone(),
-            };
-
-            let mut data = TaggedDictBuilder::new(operation_tag.clone());
-            data.insert_value("max", value);
-
-            Ok(data.into_value())
-        }
-        Operation::Min => {
-            let untagged = match series.dtype() {
-                DataType::Int8
-                | DataType::Int16
-                | DataType::Int32
-                | DataType::Int64
-                | DataType::UInt8
-                | DataType::UInt16
-                | DataType::UInt32
-                | DataType::UInt64 => {
-                    let res: i64 = series.min().unwrap_or(0);
-                    Ok(UntaggedValue::Primitive(res.into()))
-                }
-                DataType::Float32 | DataType::Float64 => {
-                    let res: f64 = series.min().unwrap_or(0.0);
-                    Ok(UntaggedValue::Primitive(res.into()))
-                }
-                _ => Err(ShellError::labeled_error(
-                    "Not valid type",
-                    format!(
-                        "this operation can not be performed with series of type {}",
-                        series.dtype()
-                    ),
-                    &operation_tag.span,
-                )),
-            }?;
-
-            let value = Value {
-                value: untagged,
-                tag: operation_tag.clone(),
-            };
-
-            let mut data = TaggedDictBuilder::new(operation_tag.clone());
-            data.insert_value("min", value);
-
-            Ok(data.into_value())
-        }
-
-        _ => Err(ShellError::labeled_error_with_secondary(
-            "Not valid operation",
-            "operation not valid for series",
-            &operation_tag.span,
-            "Perhaps you want: mean, median, sum, max, min",
-            &operation_tag.span,
-        )),
+        test_examples(DataFrame {})
     }
 }

crates/nu-command/src/commands/dataframe/append.rs

@@ -0,0 +1,138 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Axis, Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe append"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Appends a new dataframe"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe append")
+            .required_named(
+                "other",
+                SyntaxShape::Any,
+                "dataframe to be appended",
+                Some('o'),
+            )
+            .required_named(
+                "axis",
+                SyntaxShape::String,
+                "row or col axis orientation",
+                Some('a'),
+            )
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Appends a dataframe as new columns",
+                example: r#"let a = ([[a b]; [1 2] [3 4]] | dataframe to-df);
+    $a | dataframe append -o $a -a row"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                        ),
+                        Column::new(
+                            "a_x".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                        ),
+                        Column::new(
+                            "b_x".to_string(),
+                            vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+            Example {
+                description: "Appends a dataframe merging at the end of columns",
+                example: r#"let a = ([[a b]; [1 2] [3 4]] | dataframe to-df);
+    $a | dataframe append -o $a -a col"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(3).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(3).into(),
+                            ],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![
+                                UntaggedValue::int(2).into(),
+                                UntaggedValue::int(4).into(),
+                                UntaggedValue::int(2).into(),
+                                UntaggedValue::int(4).into(),
+                            ],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+        ]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let other: Value = args.req_named("other")?;
+    let axis: Tagged<String> = args.req_named("axis")?;
+
+    let axis = Axis::try_from_str(&axis.item, &axis.tag.span)?;
+
+    let df_other = match other.value {
+        UntaggedValue::DataFrame(df) => Ok(df),
+        _ => Err(ShellError::labeled_error(
+            "Incorrect type",
+            "can only append a dataframe to a dataframe",
+            other.tag.span,
+        )),
+    }?;
+
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let df_new = df.append_df(&df_other, axis, &tag.span)?;
+    Ok(OutputStream::one(df_new.into_value(tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/column.rs

@@ -2,8 +2,8 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::{NuDataFrame, NuSeries},
-    Signature, SyntaxShape,
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
 };
 
 use nu_source::Tagged;
@@ -17,7 +17,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Returns the selected column as Series"
+        "[DataFrame] Returns the selected column as Series"
     }
 
     fn signature(&self) -> Signature {
@@ -32,7 +32,15 @@ impl WholeStreamCommand for DataFrame {
         vec![Example {
             description: "Returns the selected column as series",
             example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe column a",
-            result: None,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "a".to_string(),
+                    vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -41,15 +49,26 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
     let column: Tagged<String> = args.req(0)?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let res = df
         .as_ref()
-        .column(column.item.as_ref())
+        .column(&column.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &column.tag.span, None))?;
 
-    Ok(OutputStream::one(NuSeries::series_to_value(
-        res.clone(),
-        tag,
-    )))
+    let df = NuDataFrame::try_from_series(vec![res.clone()], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/describe.rs

@@ -0,0 +1,232 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
+use polars::{
+    chunked_array::ChunkedArray,
+    prelude::{
+        AnyValue, DataFrame as PolarsDF, DataType, Float64Type, IntoSeries, NewChunkedArray,
+        Series, Utf8Type,
+    },
+};
+
+use super::utils::parse_polars_error;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe describe"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Describes dataframes numeric columns"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe describe")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Describes dataframe",
+            example: "[[a b]; [1 1] [1 1]] | dataframe to-df | dataframe describe",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "descriptor".to_string(),
+                        vec![
+                            UntaggedValue::string("count").into(),
+                            UntaggedValue::string("sum").into(),
+                            UntaggedValue::string("mean").into(),
+                            UntaggedValue::string("median").into(),
+                            UntaggedValue::string("std").into(),
+                            UntaggedValue::string("min").into(),
+                            UntaggedValue::string("25%").into(),
+                            UntaggedValue::string("50%").into(),
+                            UntaggedValue::string("75%").into(),
+                            UntaggedValue::string("max").into(),
+                        ],
+                    ),
+                    Column::new(
+                        "a (i64)".to_string(),
+                        vec![
+                            UntaggedValue::decimal_from_float(2.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(2.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(0.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                        ],
+                    ),
+                    Column::new(
+                        "b (i64)".to_string(),
+                        vec![
+                            UntaggedValue::decimal_from_float(2.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(2.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(0.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                            UntaggedValue::decimal_from_float(1.0, Span::default()).into(),
+                        ],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let names = ChunkedArray::<Utf8Type>::new_from_opt_slice(
+        "descriptor",
+        &[
+            Some("count"),
+            Some("sum"),
+            Some("mean"),
+            Some("median"),
+            Some("std"),
+            Some("min"),
+            Some("25%"),
+            Some("50%"),
+            Some("75%"),
+            Some("max"),
+        ],
+    )
+    .into_series();
+
+    let head = std::iter::once(names);
+
+    let tail = df.as_ref().get_columns().iter().map(|col| {
+        let count = col.len() as f64;
+
+        let sum = match col.sum_as_series().cast(&DataType::Float64) {
+            Ok(ca) => match ca.get(0) {
+                AnyValue::Float64(v) => Some(v),
+                _ => None,
+            },
+            Err(_) => None,
+        };
+
+        let mean = match col.mean_as_series().get(0) {
+            AnyValue::Float64(v) => Some(v),
+            _ => None,
+        };
+
+        let median = match col.median_as_series().get(0) {
+            AnyValue::Float64(v) => Some(v),
+            _ => None,
+        };
+
+        let std = match col.std_as_series().get(0) {
+            AnyValue::Float64(v) => Some(v),
+            _ => None,
+        };
+
+        let min = match col.min_as_series().cast(&DataType::Float64) {
+            Ok(ca) => match ca.get(0) {
+                AnyValue::Float64(v) => Some(v),
+                _ => None,
+            },
+            Err(_) => None,
+        };
+
+        let q_25 = match col.quantile_as_series(0.25) {
+            Ok(ca) => match ca.cast(&DataType::Float64) {
+                Ok(ca) => match ca.get(0) {
+                    AnyValue::Float64(v) => Some(v),
+                    _ => None,
+                },
+                Err(_) => None,
+            },
+            Err(_) => None,
+        };
+
+        let q_50 = match col.quantile_as_series(0.50) {
+            Ok(ca) => match ca.cast(&DataType::Float64) {
+                Ok(ca) => match ca.get(0) {
+                    AnyValue::Float64(v) => Some(v),
+                    _ => None,
+                },
+                Err(_) => None,
+            },
+            Err(_) => None,
+        };
+
+        let q_75 = match col.quantile_as_series(0.75) {
+            Ok(ca) => match ca.cast(&DataType::Float64) {
+                Ok(ca) => match ca.get(0) {
+                    AnyValue::Float64(v) => Some(v),
+                    _ => None,
+                },
+                Err(_) => None,
+            },
+            Err(_) => None,
+        };
+
+        let max = match col.max_as_series().cast(&DataType::Float64) {
+            Ok(ca) => match ca.get(0) {
+                AnyValue::Float64(v) => Some(v),
+                _ => None,
+            },
+            Err(_) => None,
+        };
+
+        let name = format!("{} ({})", col.name(), col.dtype());
+        ChunkedArray::<Float64Type>::new_from_opt_slice(
+            &name,
+            &[
+                Some(count),
+                sum,
+                mean,
+                median,
+                std,
+                min,
+                q_25,
+                q_50,
+                q_75,
+                max,
+            ],
+        )
+        .into_series()
+    });
+
+    let res = head.chain(tail).collect::<Vec<Series>>();
+    let df = PolarsDF::new(res).map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
+    let df = NuDataFrame::dataframe_to_value(df, tag);
+    Ok(OutputStream::one(df))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/drop.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuDataFrame, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
 
 use super::utils::{convert_columns, parse_polars_error};
 
@@ -13,13 +16,13 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Creates a new dataframe by dropping the selected columns"
+        "[DataFrame] Creates a new dataframe by dropping the selected columns"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("dataframe drop").required(
-            "columns",
-            SyntaxShape::Table,
+        Signature::build("dataframe drop").rest(
+            "rest",
+            SyntaxShape::Any,
             "column names to be dropped",
         )
     }
@@ -31,8 +34,16 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "drop column a",
-            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe drop [a]",
-            result: None,
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe drop a",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "b".to_string(),
+                    vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -40,10 +51,10 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let columns: Vec<Value> = args.req(0)?;
+    let columns: Vec<Value> = args.rest(0)?;
     let (col_string, col_span) = convert_columns(&columns, &tag)?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let new_df = match col_string.get(0) {
         Some(col) => df
@@ -67,3 +78,16 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/drop_duplicates.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuDataFrame, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
 
 use super::utils::{convert_columns, parse_polars_error};
 
@@ -13,7 +16,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Drops duplicate values in dataframe"
+        "[DataFrame] Drops duplicate values in dataframe"
     }
 
     fn signature(&self) -> Signature {
@@ -34,7 +37,21 @@ impl WholeStreamCommand for DataFrame {
         vec![Example {
             description: "drop duplicates",
             example: "[[a b]; [1 2] [3 4] [1 2]] | dataframe to-df | dataframe drop-duplicates",
-            result: None,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "a".to_string(),
+                        vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                    ),
+                    Column::new(
+                        "b".to_string(),
+                        vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -52,7 +69,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         None => (None, Span::unknown()),
     };
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let subset_slice = subset.as_ref().map(|cols| &cols[..]);
 
@@ -63,3 +80,16 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/drop_nulls.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::{NuDataFrame, NuSeries, PolarsData},
+    dataframe::{Column, NuDataFrame},
     Signature, SyntaxShape, UntaggedValue, Value,
 };
 
@@ -16,7 +16,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Drops null values in dataframe"
+        "[DataFrame, Series] Drops null values in dataframe"
     }
 
     fn signature(&self) -> Signature {
@@ -36,17 +36,47 @@ impl WholeStreamCommand for DataFrame {
             Example {
                 description: "drop null values in dataframe",
                 example: r#"let df = ([[a b]; [1 2] [3 0] [1 2]] | dataframe to-df);
-let res = ($df.b / $df.b);
-let df = ($df | dataframe with-column $res as res);
-$df | dataframe drop-nulls
-"#,
-                result: None,
+    let res = ($df.b / $df.b);
+    let df = ($df | dataframe with-column $res --name res);
+    $df | dataframe drop-nulls"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(1).into()],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![UntaggedValue::int(2).into(), UntaggedValue::int(2).into()],
+                        ),
+                        Column::new(
+                            "res".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(1).into()],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
             Example {
                 description: "drop null values in dataframe",
-                example: r#"let s = ([1 2 0 0 3 4] | dataframe to-series);
-($s / $s) | dataframe drop-nulls"#,
-                result: None,
+                example: r#"let s = ([1 2 0 0 3 4] | dataframe to-df);
+    ($s / $s) | dataframe drop-nulls"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![Column::new(
+                        "div_0_0".to_string(),
+                        vec![
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(1).into(),
+                        ],
+                    )],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
         ]
     }
@@ -60,7 +90,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     })?;
 
     match value.value {
-        UntaggedValue::DataFrame(PolarsData::EagerDataFrame(df)) => {
+        UntaggedValue::DataFrame(df) => {
             // Extracting the selection columns of the columns to perform the aggregation
             let columns: Option<Vec<Value>> = args.opt(0)?;
             let (subset, col_span) = match columns {
@@ -80,10 +110,6 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
             Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
         }
-        UntaggedValue::DataFrame(PolarsData::Series(series)) => {
-            let res = series.as_ref().drop_nulls();
-            Ok(OutputStream::one(NuSeries::series_to_value(res, tag)))
-        }
         _ => Err(ShellError::labeled_error(
             "Incorrect type",
             "drop nulls cannot be done with this value",
@@ -91,3 +117,16 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         )),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/dtypes.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuDataFrame, Signature, TaggedDictBuilder};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue, Value,
+};
 
 pub struct DataFrame;
 
@@ -11,7 +14,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Show dataframe data types"
+        "[DataFrame] Show dataframe data types"
     }
 
     fn signature(&self) -> Signature {
@@ -26,7 +29,27 @@ impl WholeStreamCommand for DataFrame {
         vec![Example {
             description: "drop column a",
             example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe dtypes",
-            result: None,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "column".to_string(),
+                        vec![
+                            UntaggedValue::string("a").into(),
+                            UntaggedValue::string("b").into(),
+                        ],
+                    ),
+                    Column::new(
+                        "dtype".to_string(),
+                        vec![
+                            UntaggedValue::string("i64").into(),
+                            UntaggedValue::string("i64").into(),
+                        ],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -35,26 +58,49 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
-    let col_names = df
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let mut dtypes: Vec<Value> = Vec::new();
+    let names: Vec<Value> = df
         .as_ref()
         .get_column_names()
         .iter()
-        .map(|v| v.to_string())
-        .collect::<Vec<String>>();
+        .map(|v| {
+            let dtype = df
+                .as_ref()
+                .column(v)
+                .expect("using name from list of names from dataframe")
+                .dtype();
 
-    let values = df
-        .as_ref()
-        .dtypes()
-        .into_iter()
-        .zip(col_names.into_iter())
-        .map(move |(dtype, name)| {
-            let mut data = TaggedDictBuilder::new(tag.clone());
-            data.insert_value("column", name.as_ref());
-            data.insert_value("dtype", format!("{}", dtype));
+            let dtype_str = dtype.to_string();
+            dtypes.push(Value {
+                value: dtype_str.into(),
+                tag: Tag::default(),
+            });
 
-            data.into_value()
-        });
+            Value {
+                value: v.to_string().into(),
+                tag: Tag::default(),
+            }
+        })
+        .collect();
 
-    Ok(OutputStream::from_stream(values))
+    let names_col = Column::new("column".to_string(), names);
+    let dtypes_col = Column::new("dtype".to_string(), dtypes);
+
+    let df = NuDataFrame::try_from_columns(vec![names_col, dtypes_col], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/dummies.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::{NuDataFrame, PolarsData},
+    dataframe::{Column, NuDataFrame},
     Signature, UntaggedValue,
 };
 
@@ -16,7 +16,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Creates a new dataframe with dummy variables"
+        "[DataFrame] Creates a new dataframe with dummy variables"
     }
 
     fn signature(&self) -> Signature {
@@ -32,12 +32,70 @@ impl WholeStreamCommand for DataFrame {
             Example {
                 description: "Create new dataframe with dummy variables from a dataframe",
                 example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe to-dummies",
-                result: None,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a_1".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(0).into()],
+                        ),
+                        Column::new(
+                            "a_3".to_string(),
+                            vec![UntaggedValue::int(0).into(), UntaggedValue::int(1).into()],
+                        ),
+                        Column::new(
+                            "b_2".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(0).into()],
+                        ),
+                        Column::new(
+                            "b_4".to_string(),
+                            vec![UntaggedValue::int(0).into(), UntaggedValue::int(1).into()],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
             Example {
                 description: "Create new dataframe with dummy variables from a series",
-                example: "[1 2 2 3 3] | dataframe to-series | dataframe to-dummies",
-                result: None,
+                example: "[1 2 2 3 3] | dataframe to-df | dataframe to-dummies",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "0_1".to_string(),
+                            vec![
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                            ],
+                        ),
+                        Column::new(
+                            "0_2".to_string(),
+                            vec![
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                            ],
+                        ),
+                        Column::new(
+                            "0_3".to_string(),
+                            vec![
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(1).into(),
+                            ],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
         ]
     }
@@ -51,7 +109,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     })?;
 
     match value.value {
-        UntaggedValue::DataFrame(PolarsData::EagerDataFrame(df)) => {
+        UntaggedValue::DataFrame(df) => {
             let res = df.as_ref().to_dummies().map_err(|e| {
                 parse_polars_error(
                     &e,
@@ -62,17 +120,6 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
             Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
         }
-        UntaggedValue::DataFrame(PolarsData::Series(series)) => {
-            let res = series.as_ref().to_dummies().map_err(|e| {
-                parse_polars_error(
-                    &e,
-                    &tag.span,
-                    Some("The only allowed column types for dummies are String or Int"),
-                )
-            })?;
-
-            Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
-        }
         _ => Err(ShellError::labeled_error(
             "Incorrect type",
             "dummies cannot be done with this value",
@@ -80,3 +127,16 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         )),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/filter.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::{NuDataFrame, PolarsData},
+    dataframe::{Column, NuDataFrame},
     Signature, SyntaxShape, UntaggedValue, Value,
 };
 
@@ -11,17 +11,19 @@ pub struct DataFrame;
 
 impl WholeStreamCommand for DataFrame {
     fn name(&self) -> &str {
-        "dataframe filter"
+        "dataframe filter-with"
     }
 
     fn usage(&self) -> &str {
-        "Filters dataframe using a mask as reference"
+        "[DataFrame] Filters dataframe using a mask as reference"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("dataframe filter")
-            .required("with", SyntaxShape::String, "the word 'with'")
-            .required("mask", SyntaxShape::Any, "boolean mask used to filter data")
+        Signature::build("dataframe filter-with").required(
+            "mask",
+            SyntaxShape::Any,
+            "boolean mask used to filter data",
+        )
     }
 
     fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
@@ -32,14 +34,22 @@ impl WholeStreamCommand for DataFrame {
         vec![
             Example {
                 description: "Filter dataframe using a bool mask",
-                example: r#"let mask = ([$true $false] | dataframe to-series);
-[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe filter with $mask"#,
-                result: None,
+                example: r#"let mask = ([$true $false] | dataframe to-df);
+    [[a b]; [1 2] [3 4]] | dataframe to-df | dataframe filter-with $mask"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new("a".to_string(), vec![UntaggedValue::int(1).into()]),
+                        Column::new("b".to_string(), vec![UntaggedValue::int(2).into()]),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
             Example {
                 description: "Filter dataframe by creating a mask from operation",
-                example: r#"let mask = (([5 6] | dataframe to-series) > 5);
-[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe filter with $mask"#,
+                example: r#"let mask = (([5 6] | dataframe to-df) > 5);
+    [[a b]; [1 2] [3 4]] | dataframe to-df | dataframe filter-with $mask"#,
                 result: None,
             },
         ]
@@ -48,32 +58,45 @@ impl WholeStreamCommand for DataFrame {
 
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
-    let value: Value = args.req(1)?;
+    let value: Value = args.req(0)?;
 
     let series_span = value.tag.span;
-    let series = match value.value {
-        UntaggedValue::DataFrame(PolarsData::Series(series)) => Ok(series),
+    let df = match value.value {
+        UntaggedValue::DataFrame(df) => Ok(df),
         _ => Err(ShellError::labeled_error(
             "Incorrect type",
             "can only add a series to a dataframe",
             value.tag.span,
         )),
     }?;
-
-    let casted = series.as_ref().bool().map_err(|e| {
+    let series = df.as_series(&series_span)?;
+    let casted = series.bool().map_err(|e| {
         parse_polars_error(
             &e,
-            &&series_span,
+            &series_span,
             Some("Perhaps you want to use a series with booleans as mask"),
         )
     })?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let res = df
         .as_ref()
-        .filter(&casted)
-        .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
+        .filter(casted)
+        .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
 
     Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/first.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuDataFrame, Signature, SyntaxShape};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
+};
 
 use nu_source::Tagged;
 
@@ -9,11 +12,11 @@ pub struct DataFrame;
 
 impl WholeStreamCommand for DataFrame {
     fn name(&self) -> &str {
-        "dataframe head"
+        "dataframe first"
     }
 
     fn usage(&self) -> &str {
-        "Creates new dataframe with head rows"
+        "[DataFrame] Creates new dataframe with first rows"
     }
 
     fn signature(&self) -> Signature {
@@ -31,8 +34,16 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Create new dataframe with head rows",
-            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe head",
-            result: None,
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe first 1",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new("a".to_string(), vec![UntaggedValue::int(1).into()]),
+                    Column::new("b".to_string(), vec![UntaggedValue::int(2).into()]),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -46,8 +57,21 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         None => 5,
     };
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
     let res = df.as_ref().head(Some(rows));
 
     Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/get.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuDataFrame, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
 
 use super::utils::{convert_columns, parse_polars_error};
 pub struct DataFrame;
@@ -12,13 +15,13 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Creates dataframe with the selected columns"
+        "[DataFrame] Creates dataframe with the selected columns"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("dataframe get").required(
-            "columns",
-            SyntaxShape::Table,
+        Signature::build("dataframe get").rest(
+            "rest",
+            SyntaxShape::Any,
             "column names to sort dataframe",
         )
     }
@@ -30,19 +33,27 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Creates dataframe with selected columns",
-            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe get [a]",
-            result: None,
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe get a",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "a".to_string(),
+                    vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
 
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
-    let columns: Vec<Value> = args.req(0)?;
+    let columns: Vec<Value> = args.rest(0)?;
 
     let (col_string, col_span) = convert_columns(&columns, &tag)?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let res = df
         .as_ref()
@@ -51,3 +62,16 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/groupby.rs

@@ -2,7 +2,7 @@ use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::{NuDataFrame, NuGroupBy, PolarsData},
+    dataframe::{FrameStruct, NuDataFrame, NuGroupBy},
     Signature, SyntaxShape, UntaggedValue, Value,
 };
 
@@ -16,15 +16,11 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Creates a groupby object that can be used for other aggregations"
+        "[DataFrame] Creates a groupby object that can be used for other aggregations"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("dataframe group-by").required(
-            "by columns",
-            SyntaxShape::Table,
-            "groupby columns",
-        )
+        Signature::build("dataframe group-by").rest("rest", SyntaxShape::Any, "groupby columns")
     }
 
     fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
@@ -34,7 +30,7 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Grouping by column a",
-            example: "[[a b]; [one 1] [one 2]] | dataframe to-df | dataframe group-by [a]",
+            example: "[[a b]; [one 1] [one 2]] | dataframe to-df | dataframe group-by a",
             result: None,
         }]
     }
@@ -44,10 +40,10 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
     // Extracting the names of the columns to perform the groupby
-    let by_columns: Vec<Value> = args.req(0)?;
+    let by_columns: Vec<Value> = args.rest(0)?;
     let (columns_string, col_span) = convert_columns(&by_columns, &tag)?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     // This is the expensive part of the groupby; to create the
     // groups that will be used for grouping the data in the
@@ -61,7 +57,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let groups = groupby.get_groups().to_vec();
     let groupby = Value {
         tag,
-        value: UntaggedValue::DataFrame(PolarsData::GroupBy(NuGroupBy::new(
+        value: UntaggedValue::FrameStruct(FrameStruct::GroupBy(NuGroupBy::new(
             NuDataFrame::new(df.as_ref().clone()),
             columns_string,
             groups,

crates/nu-command/src/commands/dataframe/join.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::{NuDataFrame, PolarsData},
+    dataframe::{Column, NuDataFrame},
     Signature, SyntaxShape, UntaggedValue, Value,
 };
 
@@ -20,21 +20,23 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Joins a dataframe using columns as reference"
+        "[DataFrame] Joins a dataframe using columns as reference"
     }
 
     fn signature(&self) -> Signature {
         Signature::build("dataframe join")
             .required("dataframe", SyntaxShape::Any, "right dataframe to join")
-            .required(
-                "l_columns",
+            .required_named(
+                "left",
                 SyntaxShape::Table,
                 "left column names to perform join",
+                Some('l'),
             )
-            .required(
-                "r_columns",
+            .required_named(
+                "right",
                 SyntaxShape::Table,
                 "right column names to perform join",
+                Some('r'),
             )
             .named(
                 "type",
@@ -42,6 +44,12 @@ impl WholeStreamCommand for DataFrame {
                 "type of join. Inner by default",
                 Some('t'),
             )
+            .named(
+                "suffix",
+                SyntaxShape::String,
+                "suffix for the columns of the right dataframe",
+                Some('s'),
+            )
     }
 
     fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
@@ -49,19 +57,50 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "inner join dataframe",
-                example: "echo [[a b]; [1 2] [3 4]] | dataframe to-df | dataframe join $right [a] [a]",
-                result: None,
-            },
-            Example {
-                description: "right join dataframe",
-                example:
-                    "[[a b]; [1 2] [3 4] [5 6]] | dataframe to-df | dataframe join $right [b] [b] -t right",
-                result: None,
-            },
-        ]
+        vec![Example {
+            description: "inner join dataframe",
+            example: r#"let right = ([[a b c]; [1 2 5] [3 4 5] [5 6 6]] | dataframe to-df);
+    $right | dataframe join $right -l [a b] -r [a b]"#,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "a".to_string(),
+                        vec![
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(3).into(),
+                            UntaggedValue::int(5).into(),
+                        ],
+                    ),
+                    Column::new(
+                        "b".to_string(),
+                        vec![
+                            UntaggedValue::int(2).into(),
+                            UntaggedValue::int(4).into(),
+                            UntaggedValue::int(6).into(),
+                        ],
+                    ),
+                    Column::new(
+                        "c".to_string(),
+                        vec![
+                            UntaggedValue::int(5).into(),
+                            UntaggedValue::int(5).into(),
+                            UntaggedValue::int(6).into(),
+                        ],
+                    ),
+                    Column::new(
+                        "c_right".to_string(),
+                        vec![
+                            UntaggedValue::int(5).into(),
+                            UntaggedValue::int(5).into(),
+                            UntaggedValue::int(6).into(),
+                        ],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
     }
 }
 
@@ -69,8 +108,9 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
     let r_df: Value = args.req(0)?;
-    let l_col: Vec<Value> = args.req(1)?;
-    let r_col: Vec<Value> = args.req(2)?;
+    let l_col: Vec<Value> = args.req_named("left")?;
+    let r_col: Vec<Value> = args.req_named("right")?;
+    let r_suffix: Option<Tagged<String>> = args.get_flag("suffix")?;
     let join_type_op: Option<Tagged<String>> = args.get_flag("type")?;
 
     let join_type = match join_type_op {
@@ -91,16 +131,19 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         },
     };
 
+    let suffix = r_suffix.map(|s| s.item);
+
     let (l_col_string, l_col_span) = convert_columns(&l_col, &tag)?;
     let (r_col_string, r_col_span) = convert_columns(&r_col, &tag)?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let res = match r_df.value {
-        UntaggedValue::DataFrame(PolarsData::EagerDataFrame(r_df)) => {
+        UntaggedValue::DataFrame(r_df) => {
             // Checking the column types before performing the join
             check_column_datatypes(
                 df.as_ref(),
+                r_df.as_ref(),
                 &l_col_string,
                 &l_col_span,
                 &r_col_string,
@@ -108,7 +151,13 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
             )?;
 
             df.as_ref()
-                .join(r_df.as_ref(), &l_col_string, &r_col_string, join_type)
+                .join(
+                    r_df.as_ref(),
+                    &l_col_string,
+                    &r_col_string,
+                    join_type,
+                    suffix,
+                )
                 .map_err(|e| parse_polars_error::<&str>(&e, &l_col_span, None))
         }
         _ => Err(ShellError::labeled_error(
@@ -122,7 +171,8 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 }
 
 fn check_column_datatypes<T: AsRef<str>>(
-    df: &polars::prelude::DataFrame,
+    df_l: &polars::prelude::DataFrame,
+    df_r: &polars::prelude::DataFrame,
     l_cols: &[T],
     l_col_span: &Span,
     r_cols: &[T],
@@ -142,14 +192,14 @@ fn check_column_datatypes<T: AsRef<str>>(
         ));
     }
 
-    for (l, r) in l_cols.iter().zip(r_cols.iter()) {
-        let l_series = df
+    for (l, r) in l_cols.iter().zip(r_cols) {
+        let l_series = df_l
             .column(l.as_ref())
-            .map_err(|e| parse_polars_error::<&str>(&e, &l_col_span, None))?;
+            .map_err(|e| parse_polars_error::<&str>(&e, l_col_span, None))?;
 
-        let r_series = df
+        let r_series = df_r
             .column(r.as_ref())
-            .map_err(|e| parse_polars_error::<&str>(&e, &r_col_span, None))?;
+            .map_err(|e| parse_polars_error::<&str>(&e, r_col_span, None))?;
 
         if l_series.dtype() != r_series.dtype() {
             return Err(ShellError::labeled_error_with_secondary(
@@ -168,3 +218,16 @@ fn check_column_datatypes<T: AsRef<str>>(
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/last.rs

@@ -0,0 +1,77 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
+};
+
+use nu_source::Tagged;
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe last"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Creates new dataframe with tail rows"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe last").optional(
+            "n_rows",
+            SyntaxShape::Number,
+            "Number of rows for tail",
+        )
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Create new dataframe with last rows",
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe last 1",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new("a".to_string(), vec![UntaggedValue::int(3).into()]),
+                    Column::new("b".to_string(), vec![UntaggedValue::int(4).into()]),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let rows: Option<Tagged<usize>> = args.opt(0)?;
+
+    let rows = match rows {
+        Some(val) => val.item,
+        None => 5,
+    };
+
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let res = df.as_ref().tail(Some(rows));
+
+    Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/list.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::PolarsData, Signature, TaggedDictBuilder, UntaggedValue};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue, Value,
+};
 
 pub struct DataFrame;
 
@@ -19,46 +22,94 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        let values = args
+        let data = args
             .context
             .scope
             .get_vars()
             .into_iter()
             .filter_map(|(name, value)| {
-                if let UntaggedValue::DataFrame(PolarsData::EagerDataFrame(df)) = &value.value {
-                    let mut data = TaggedDictBuilder::new(value.tag.clone());
+                if let UntaggedValue::DataFrame(df) = &value.value {
+                    let rows = Value {
+                        value: (df.as_ref().height() as i64).into(),
+                        tag: Tag::default(),
+                    };
 
-                    let rows = df.as_ref().height();
-                    let cols = df.as_ref().width();
+                    let cols = Value {
+                        value: (df.as_ref().width() as i64).into(),
+                        tag: Tag::default(),
+                    };
 
-                    data.insert_value("name", name.as_ref());
-                    data.insert_value("rows", format!("{}", rows));
-                    data.insert_value("columns", format!("{}", cols));
+                    let location = match value.tag.anchor {
+                        Some(AnchorLocation::File(name)) => name,
+                        Some(AnchorLocation::Url(name)) => name,
+                        Some(AnchorLocation::Source(text)) => text.slice(0..text.end).text,
+                        None => "stream".to_string(),
+                    };
 
-                    match value.tag.anchor {
-                        Some(AnchorLocation::File(name)) => data.insert_value("location", name),
-                        Some(AnchorLocation::Url(name)) => data.insert_value("location", name),
-                        Some(AnchorLocation::Source(text)) => {
-                            let loc_name = text.slice(0..text.end);
-                            data.insert_value("location", loc_name.text)
-                        }
-                        None => data.insert_value("location", "stream"),
-                    }
+                    let location = Value {
+                        value: location.into(),
+                        tag: Tag::default(),
+                    };
 
-                    Some(data.into_value())
+                    let name = Value {
+                        value: name.into(),
+                        tag: Tag::default(),
+                    };
+
+                    Some((name, rows, cols, location))
                 } else {
                     None
                 }
             });
 
-        Ok(OutputStream::from_stream(values))
+        let mut name = Column::new_empty("name".to_string());
+        let mut rows = Column::new_empty("rows".to_string());
+        let mut cols = Column::new_empty("columns".to_string());
+        let mut location = Column::new_empty("location".to_string());
+
+        for tuple in data {
+            name.push(tuple.0);
+            rows.push(tuple.1);
+            cols.push(tuple.2);
+            location.push(tuple.3);
+        }
+
+        let tag = args.call_info.name_tag;
+        let df = NuDataFrame::try_from_columns(vec![name, rows, cols, location], &tag.span)?;
+        Ok(OutputStream::one(df.into_value(tag)))
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Lists loaded dataframes in current scope",
-            example: "dataframe list",
-            result: None,
+            example: "let a = ([[a b];[1 2] [3 4]] | dataframe to-df); dataframe list",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new("name".to_string(), vec![UntaggedValue::string("$a").into()]),
+                    Column::new("rows".to_string(), vec![UntaggedValue::int(2).into()]),
+                    Column::new("columns".to_string(), vec![UntaggedValue::int(2).into()]),
+                    Column::new(
+                        "location".to_string(),
+                        vec![UntaggedValue::string("stream").into()],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/melt.rs

@@ -1,7 +1,11 @@
 use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuDataFrame, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
 
 use super::utils::convert_columns;
 
@@ -13,16 +17,34 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Unpivot a DataFrame from wide to long format"
+        "[DataFrame] Unpivot a DataFrame from wide to long format"
     }
 
     fn signature(&self) -> Signature {
         Signature::build("dataframe melt")
-            .required("id_columns", SyntaxShape::Table, "Id columns for melting")
-            .required(
-                "value_columns",
+            .required_named(
+                "columns",
                 SyntaxShape::Table,
-                "columns used as value columns",
+                "column names for melting",
+                Some('c'),
+            )
+            .required_named(
+                "values",
+                SyntaxShape::Table,
+                "column names used as value columns",
+                Some('v'),
+            )
+            .named(
+                "variable_name",
+                SyntaxShape::String,
+                "optional name for variable column",
+                Some('r'),
+            )
+            .named(
+                "value_name",
+                SyntaxShape::String,
+                "optional name for value column",
+                Some('l'),
             )
     }
 
@@ -33,8 +55,59 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "melt dataframe",
-            example: "[[a b]; [a 2] [b 4] [a 6]] | dataframe to-df | dataframe melt [a] [b]",
-            result: None,
+            example:
+                "[[a b c d]; [x 1 4 a] [y 2 5 b] [z 3 6 c]] | dataframe to-df | dataframe melt -c [b c] -v [a d]",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "b".to_string(),
+                        vec![
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(2).into(),
+                            UntaggedValue::int(3).into(),
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(2).into(),
+                            UntaggedValue::int(3).into(),
+                        ],
+                    ),
+                    Column::new(
+                        "c".to_string(),
+                        vec![
+                            UntaggedValue::int(4).into(),
+                            UntaggedValue::int(5).into(),
+                            UntaggedValue::int(6).into(),
+                            UntaggedValue::int(4).into(),
+                            UntaggedValue::int(5).into(),
+                            UntaggedValue::int(6).into(),
+                        ],
+                    ),
+                    Column::new(
+                        "variable".to_string(),
+                        vec![
+                            UntaggedValue::string("a").into(),
+                            UntaggedValue::string("a").into(),
+                            UntaggedValue::string("a").into(),
+                            UntaggedValue::string("d").into(),
+                            UntaggedValue::string("d").into(),
+                            UntaggedValue::string("d").into(),
+                        ],
+                    ),
+                    Column::new(
+                        "value".to_string(),
+                        vec![
+                            UntaggedValue::string("x").into(),
+                            UntaggedValue::string("y").into(),
+                            UntaggedValue::string("z").into(),
+                            UntaggedValue::string("a").into(),
+                            UntaggedValue::string("b").into(),
+                            UntaggedValue::string("c").into(),
+                        ],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -42,22 +115,35 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let id_col: Vec<Value> = args.req(0)?;
-    let val_col: Vec<Value> = args.req(1)?;
+    let id_col: Vec<Value> = args.req_named("columns")?;
+    let val_col: Vec<Value> = args.req_named("values")?;
+
+    let value_name: Option<Tagged<String>> = args.get_flag("value_name")?;
+    let variable_name: Option<Tagged<String>> = args.get_flag("variable_name")?;
 
     let (id_col_string, id_col_span) = convert_columns(&id_col, &tag)?;
     let (val_col_string, val_col_span) = convert_columns(&val_col, &tag)?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     check_column_datatypes(df.as_ref(), &id_col_string, &id_col_span)?;
     check_column_datatypes(df.as_ref(), &val_col_string, &val_col_span)?;
 
-    let res = df
+    let mut res = df
         .as_ref()
         .melt(&id_col_string, &val_col_string)
         .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
 
+    if let Some(name) = &variable_name {
+        res.rename("variable", &name.item)
+            .map_err(|e| parse_polars_error::<&str>(&e, &name.tag.span, None))?;
+    }
+
+    if let Some(name) = &value_name {
+        res.rename("value", &name.item)
+            .map_err(|e| parse_polars_error::<&str>(&e, &name.tag.span, None))?;
+    }
+
     Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
 }
 
@@ -79,11 +165,11 @@ fn check_column_datatypes<T: AsRef<str>>(
         for w in cols.windows(2) {
             let l_series = df
                 .column(w[0].as_ref())
-                .map_err(|e| parse_polars_error::<&str>(&e, &col_span, None))?;
+                .map_err(|e| parse_polars_error::<&str>(&e, col_span, None))?;
 
             let r_series = df
                 .column(w[1].as_ref())
-                .map_err(|e| parse_polars_error::<&str>(&e, &col_span, None))?;
+                .map_err(|e| parse_polars_error::<&str>(&e, col_span, None))?;
 
             if l_series.dtype() != r_series.dtype() {
                 return Err(ShellError::labeled_error_with_secondary(
@@ -103,3 +189,16 @@ fn check_column_datatypes<T: AsRef<str>>(
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/mod.rs

@@ -1,61 +1,69 @@
 pub mod aggregate;
+pub mod append;
 pub mod column;
 pub mod command;
+pub mod describe;
 pub mod drop;
 pub mod drop_duplicates;
 pub mod drop_nulls;
 pub mod dtypes;
 pub mod dummies;
 pub mod filter;
+pub mod first;
 pub mod get;
 pub mod groupby;
-pub mod head;
 pub mod join;
+pub mod last;
 pub mod list;
-pub mod load;
 pub mod melt;
+pub mod open;
 pub mod pivot;
+pub mod rename;
 pub mod sample;
 pub mod select;
+pub mod shape;
 pub mod show;
 pub mod slice;
 pub mod sort;
-pub mod tail;
+pub mod take;
 pub mod to_csv;
 pub mod to_df;
 pub mod to_parquet;
-pub mod to_series;
 pub(crate) mod utils;
 pub mod where_;
 pub mod with_column;
 
 pub use aggregate::DataFrame as DataFrameAggregate;
+pub use append::DataFrame as DataFrameAppend;
 pub use column::DataFrame as DataFrameColumn;
 pub use command::Command as DataFrame;
+pub use describe::DataFrame as DataFrameDescribe;
 pub use drop::DataFrame as DataFrameDrop;
 pub use drop_duplicates::DataFrame as DataFrameDropDuplicates;
 pub use drop_nulls::DataFrame as DataFrameDropNulls;
 pub use dtypes::DataFrame as DataFrameDTypes;
 pub use dummies::DataFrame as DataFrameDummies;
 pub use filter::DataFrame as DataFrameFilter;
+pub use first::DataFrame as DataFrameFirst;
 pub use get::DataFrame as DataFrameGet;
 pub use groupby::DataFrame as DataFrameGroupBy;
-pub use head::DataFrame as DataFrameHead;
 pub use join::DataFrame as DataFrameJoin;
+pub use last::DataFrame as DataFrameLast;
 pub use list::DataFrame as DataFrameList;
-pub use load::DataFrame as DataFrameLoad;
 pub use melt::DataFrame as DataFrameMelt;
+pub use open::DataFrame as DataFrameOpen;
 pub use pivot::DataFrame as DataFramePivot;
+pub use rename::DataFrame as DataFrameRename;
 pub use sample::DataFrame as DataFrameSample;
 pub use select::DataFrame as DataFrameSelect;
+pub use shape::DataFrame as DataFrameShape;
 pub use show::DataFrame as DataFrameShow;
 pub use slice::DataFrame as DataFrameSlice;
 pub use sort::DataFrame as DataFrameSort;
-pub use tail::DataFrame as DataFrameTail;
+pub use take::DataFrame as DataFrameTake;
 pub use to_csv::DataFrame as DataFrameToCsv;
 pub use to_df::DataFrame as DataFrameToDF;
 pub use to_parquet::DataFrame as DataFrameToParquet;
-pub use to_series::DataFrame as DataFrameToSeries;
 pub use where_::DataFrame as DataFrameWhere;
 pub use with_column::DataFrame as DataFrameWithColumn;
 
@@ -67,6 +75,19 @@ pub use series::DataFrameArgMin;
 pub use series::DataFrameArgSort;
 pub use series::DataFrameArgTrue;
 pub use series::DataFrameArgUnique;
+pub use series::DataFrameConcatenate;
+pub use series::DataFrameContains;
+pub use series::DataFrameCumulative;
+pub use series::DataFrameGetDay;
+pub use series::DataFrameGetHour;
+pub use series::DataFrameGetMinute;
+pub use series::DataFrameGetMonth;
+pub use series::DataFrameGetNanoSecond;
+pub use series::DataFrameGetOrdinal;
+pub use series::DataFrameGetSecond;
+pub use series::DataFrameGetWeek;
+pub use series::DataFrameGetWeekDay;
+pub use series::DataFrameGetYear;
 pub use series::DataFrameIsDuplicated;
 pub use series::DataFrameIsIn;
 pub use series::DataFrameIsNotNull;
@@ -74,8 +95,18 @@ pub use series::DataFrameIsNull;
 pub use series::DataFrameIsUnique;
 pub use series::DataFrameNNull;
 pub use series::DataFrameNUnique;
+pub use series::DataFrameNot;
+pub use series::DataFrameReplace;
+pub use series::DataFrameReplaceAll;
+pub use series::DataFrameRolling;
 pub use series::DataFrameSeriesRename;
 pub use series::DataFrameSet;
+pub use series::DataFrameSetWithIdx;
 pub use series::DataFrameShift;
+pub use series::DataFrameStrFTime;
+pub use series::DataFrameStringLengths;
+pub use series::DataFrameStringSlice;
+pub use series::DataFrameToLowercase;
+pub use series::DataFrameToUppercase;
 pub use series::DataFrameUnique;
 pub use series::DataFrameValueCounts;

crates/nu-command/src/commands/dataframe/open.rs

@@ -8,22 +8,22 @@ use nu_protocol::{
 };
 
 use nu_source::Tagged;
-use polars::prelude::{CsvReader, JsonReader, ParquetReader, SerReader};
+use polars::prelude::{CsvEncoding, CsvReader, JsonReader, ParquetReader, SerReader};
 use std::fs::File;
 
 pub struct DataFrame;
 
 impl WholeStreamCommand for DataFrame {
     fn name(&self) -> &str {
-        "dataframe load"
+        "dataframe open"
     }
 
     fn usage(&self) -> &str {
-        "Loads dataframe form csv file"
+        "Opens csv, json or parquet file to create dataframe"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("dataframe load")
+        Signature::build("dataframe open")
             .required(
                 "file",
                 SyntaxShape::FilePath,
@@ -43,7 +43,7 @@ impl WholeStreamCommand for DataFrame {
             .named(
                 "infer_schema",
                 SyntaxShape::Number,
-                "Set number of row to infer the schema of the file. CSV file",
+                "Set number of rows to infer the schema of the file. CSV file",
                 None,
             )
             .named(
@@ -67,7 +67,7 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Takes a file name and creates a dataframe",
-            example: "dataframe load test.csv",
+            example: "dataframe open test.csv",
             result: None,
         }]
     }
@@ -151,7 +151,8 @@ fn from_csv(args: CommandArgs) -> Result<polars::prelude::DataFrame, ShellError>
     let columns: Option<Vec<Value>> = args.get_flag("columns")?;
 
     let csv_reader = CsvReader::from_path(&file.item)
-        .map_err(|e| parse_polars_error::<&str>(&e, &file.tag.span, None))?;
+        .map_err(|e| parse_polars_error::<&str>(&e, &file.tag.span, None))?
+        .with_encoding(CsvEncoding::LossyUtf8);
 
     let csv_reader = match delimiter {
         None => csv_reader,
@@ -172,14 +173,10 @@ fn from_csv(args: CommandArgs) -> Result<polars::prelude::DataFrame, ShellError>
         }
     };
 
-    let csv_reader = if no_header {
-        csv_reader.has_header(false)
-    } else {
-        csv_reader.has_header(true)
-    };
+    let csv_reader = csv_reader.has_header(!no_header);
 
     let csv_reader = match infer_schema {
-        None => csv_reader.infer_schema(None),
+        None => csv_reader,
         Some(r) => csv_reader.infer_schema(Some(r.item)),
     };
 
@@ -208,7 +205,7 @@ fn from_csv(args: CommandArgs) -> Result<polars::prelude::DataFrame, ShellError>
     };
 
     match csv_reader.finish() {
-        Ok(csv_reader) => Ok(csv_reader),
+        Ok(df) => Ok(df),
         Err(e) => Err(parse_polars_error::<&str>(&e, &file.tag.span, None)),
     }
 }

crates/nu-command/src/commands/dataframe/pivot.rs

@@ -46,7 +46,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Performs a pivot operation on a groupby object"
+        "[GroupBy] Performs a pivot operation on a groupby object"
     }
 
     fn signature(&self) -> Signature {
@@ -72,8 +72,8 @@ impl WholeStreamCommand for DataFrame {
         vec![Example {
             description: "Pivot a dataframe on b and aggregation on col c",
             example:
-                "[[a b c]; [one x 1] [two y 2]] | dataframe to-df | dataframe group-by [a] | dataframe pivot b c sum",
-            result: None,
+                "[[a b c]; [one x 1] [two y 2]] | dataframe to-df | dataframe group-by a | dataframe pivot b c sum",
+            result: None, // No sample because there are nulls in the result dataframe
         }]
     }
 }
@@ -100,7 +100,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     let mut groupby = nu_groupby.to_groupby()?;
 
-    let pivot = groupby.pivot(pivot_col.item.as_ref(), value_col.item.as_ref());
+    let pivot = groupby.pivot(&pivot_col.item, &value_col.item);
 
     let res = match op {
         Operation::Mean => pivot.mean(),
@@ -120,7 +120,7 @@ fn check_pivot_column(
     col: &Tagged<String>,
 ) -> Result<(), ShellError> {
     let series = df
-        .column(col.item.as_ref())
+        .column(&col.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &col.tag.span, None))?;
 
     match series.dtype() {
@@ -146,7 +146,7 @@ fn check_value_column(
     col: &Tagged<String>,
 ) -> Result<(), ShellError> {
     let series = df
-        .column(col.item.as_ref())
+        .column(&col.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &col.tag.span, None))?;
 
     match series.dtype() {

crates/nu-command/src/commands/dataframe/rename.rs

@@ -0,0 +1,81 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
+};
+
+use nu_source::Tagged;
+
+use super::utils::parse_polars_error;
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe rename-col"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] rename a dataframe column"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe rename-col")
+            .required("from", SyntaxShape::String, "column name to be renamed")
+            .required("to", SyntaxShape::String, "new column name")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Renames a dataframe column",
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe rename-col a ab",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "ab".to_string(),
+                        vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                    ),
+                    Column::new(
+                        "b".to_string(),
+                        vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let from: Tagged<String> = args.req(0)?;
+    let to: Tagged<String> = args.req(1)?;
+
+    let (mut df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    df.as_mut()
+        .rename(&from.item, &to.item)
+        .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
+
+    Ok(OutputStream::one(df.into_value(tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/sample.rs

@@ -13,11 +13,11 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Create sample dataframe"
+        "[DataFrame] Create sample dataframe"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("dataframe load")
+        Signature::build("dataframe sample")
             .named(
                 "n_rows",
                 SyntaxShape::Number,
@@ -41,14 +41,14 @@ impl WholeStreamCommand for DataFrame {
         vec![
             Example {
                 description: "Sample rows from dataframe",
-                example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe sample -r 1",
-                result: None,
+                example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe sample -n 1",
+                result: None, // No expected value because sampling is random
             },
             Example {
                 description: "Shows sample row using fraction and replace",
                 example:
                     "[[a b]; [1 2] [3 4] [5 6]] | dataframe to-df | dataframe sample -f 0.5 -e",
-                result: None,
+                result: None, // No expected value because sampling is random
             },
         ]
     }
@@ -61,7 +61,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let fraction: Option<Tagged<f64>> = args.get_flag("fraction")?;
     let replace: bool = args.has_flag("replace");
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let res = match (rows, fraction) {
         (Some(rows), None) => df

crates/nu-command/src/commands/dataframe/select.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuDataFrame, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
 
 use super::utils::{convert_columns, parse_polars_error};
 
@@ -13,15 +16,11 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Creates a new dataframe with the selected columns"
+        "[DataFrame] Creates a new dataframe with the selected columns"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("dataframe select").required(
-            "columns",
-            SyntaxShape::Table,
-            "selected column names",
-        )
+        Signature::build("dataframe select").rest("rest", SyntaxShape::Any, "selected column names")
     }
 
     fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
@@ -31,8 +30,16 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Create new dataframe with column a",
-            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe select [a]",
-            result: None,
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe select a",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "a".to_string(),
+                    vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -40,11 +47,11 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let columns: Vec<Value> = args.req(0)?;
+    let columns: Vec<Value> = args.rest(0)?;
 
     let (col_string, col_span) = convert_columns(&columns, &tag)?;
 
-    let df = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let res = df
         .as_ref()
@@ -53,3 +60,16 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/all_false.rs

@@ -1,7 +1,10 @@
 use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuSeries, Signature, TaggedDictBuilder, UntaggedValue, Value};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue, Value,
+};
 
 pub struct DataFrame;
 
@@ -11,7 +14,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Returns true if all values are false"
+        "[Series] Returns true if all values are false"
     }
 
     fn signature(&self) -> Signature {
@@ -26,15 +29,31 @@ impl WholeStreamCommand for DataFrame {
         vec![
             Example {
                 description: "Returns true if all values are false",
-                example: "[$false $false $false] | dataframe to-series | dataframe all-false",
-                result: None,
+                example: "[$false $false $false] | dataframe to-df | dataframe all-false",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![Column::new(
+                        "all_false".to_string(),
+                        vec![UntaggedValue::boolean(true).into()],
+                    )],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
             Example {
                 description: "Checks the result from a comparison",
-                example: r#"let s = ([5 6 2 8] | dataframe to-series);
-let res = ($s > 9);
-$res | dataframe all-false"#,
-                result: None,
+                example: r#"let s = ([5 6 2 10] | dataframe to-df);
+    let res = ($s > 9);
+    $res | dataframe all-false"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![Column::new(
+                        "all_false".to_string(),
+                        vec![UntaggedValue::boolean(false).into()],
+                    )],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
         ]
     }
@@ -43,9 +62,10 @@ $res | dataframe all-false"#,
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let series = NuSeries::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
-    let bool = series.as_ref().bool().map_err(|e| {
+    let series = df.as_series(&df_tag.span)?;
+    let bool = series.bool().map_err(|e| {
         parse_polars_error::<&str>(
             &e,
             &tag.span,
@@ -60,8 +80,23 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         tag: tag.clone(),
     };
 
-    let mut data = TaggedDictBuilder::new(tag);
-    data.insert_value("all_false", value);
+    let df = NuDataFrame::try_from_columns(
+        vec![Column::new("all_false".to_string(), vec![value])],
+        &tag.span,
+    )?;
 
-    Ok(OutputStream::one(data.into_value()))
+    Ok(OutputStream::one(df.into_value(tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/series/all_true.rs

@@ -1,7 +1,10 @@
 use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuSeries, Signature, TaggedDictBuilder, UntaggedValue, Value};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue, Value,
+};
 
 pub struct DataFrame;
 
@@ -11,7 +14,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Returns true if all values are true"
+        "[Series] Returns true if all values are true"
     }
 
     fn signature(&self) -> Signature {
@@ -26,15 +29,31 @@ impl WholeStreamCommand for DataFrame {
         vec![
             Example {
                 description: "Returns true if all values are true",
-                example: "[$true $true $true] | dataframe to-series | dataframe all-true",
-                result: None,
+                example: "[$true $true $true] | dataframe to-df | dataframe all-true",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![Column::new(
+                        "all_true".to_string(),
+                        vec![UntaggedValue::boolean(true).into()],
+                    )],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
             Example {
                 description: "Checks the result from a comparison",
-                example: r#"let s = ([5 6 2 8] | dataframe to-series);
-let res = ($s > 9);
-$res | dataframe all-true"#,
-                result: None,
+                example: r#"let s = ([5 6 2 8] | dataframe to-df);
+    let res = ($s > 9);
+    $res | dataframe all-true"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![Column::new(
+                        "all_true".to_string(),
+                        vec![UntaggedValue::boolean(false).into()],
+                    )],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
             },
         ]
     }
@@ -43,9 +62,10 @@ $res | dataframe all-true"#,
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let series = NuSeries::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
-    let bool = series.as_ref().bool().map_err(|e| {
+    let series = df.as_series(&df_tag.span)?;
+    let bool = series.bool().map_err(|e| {
         parse_polars_error::<&str>(
             &e,
             &tag.span,
@@ -60,8 +80,23 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         tag: tag.clone(),
     };
 
-    let mut data = TaggedDictBuilder::new(tag);
-    data.insert_value("all_true", value);
+    let df = NuDataFrame::try_from_columns(
+        vec![Column::new("all_true".to_string(), vec![value])],
+        &tag.span,
+    )?;
 
-    Ok(OutputStream::one(data.into_value()))
+    Ok(OutputStream::one(df.into_value(tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/series/arg_max.rs

@@ -2,9 +2,12 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::NuSeries, Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value,
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
 };
 
+use polars::prelude::{IntoSeries, NewChunkedArray, UInt32Chunked};
+
 pub struct DataFrame;
 
 impl WholeStreamCommand for DataFrame {
@@ -13,7 +16,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Return index for max value in series"
+        "[Series] Return index for max value in series"
     }
 
     fn signature(&self) -> Signature {
@@ -27,8 +30,16 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Returns index for max value",
-            example: "[1 3 2] | dataframe to-series | dataframe arg-max",
-            result: None,
+            example: "[1 3 2] | dataframe to-df | dataframe arg-max",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "arg_max".to_string(),
+                    vec![UntaggedValue::int(1).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -36,22 +47,31 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let series = NuSeries::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let series = df.as_series(&df_tag.span)?;
 
-    let res = series.as_ref().arg_max();
+    let res = series.arg_max();
 
-    let value = match res {
-        Some(index) => UntaggedValue::Primitive(Primitive::Int(index as i64)),
-        None => UntaggedValue::Primitive(Primitive::Nothing),
+    let chunked = match res {
+        Some(index) => UInt32Chunked::new_from_slice("arg_max", &[index as u32]),
+        None => UInt32Chunked::new_from_slice("arg_max", &[]),
     };
 
-    let value = Value {
-        value,
-        tag: tag.clone(),
-    };
+    let res = chunked.into_series();
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
 
-    let mut data = TaggedDictBuilder::new(tag);
-    data.insert_value("arg-max", value);
-
-    Ok(OutputStream::one(data.into_value()))
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/series/arg_min.rs

@@ -2,9 +2,12 @@ use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{
-    dataframe::NuSeries, Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value,
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
 };
 
+use polars::prelude::{IntoSeries, NewChunkedArray, UInt32Chunked};
+
 pub struct DataFrame;
 
 impl WholeStreamCommand for DataFrame {
@@ -13,7 +16,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Return index for min value in series"
+        "[Series] Return index for min value in series"
     }
 
     fn signature(&self) -> Signature {
@@ -27,8 +30,16 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Returns index for min value",
-            example: "[1 3 2] | dataframe to-series | dataframe arg-min",
-            result: None,
+            example: "[1 3 2] | dataframe to-df | dataframe arg-min",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "arg_min".to_string(),
+                    vec![UntaggedValue::int(0).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -36,22 +47,30 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let series = NuSeries::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
-    let res = series.as_ref().arg_min();
+    let res = df.as_series(&df_tag.span)?.arg_min();
 
-    let value = match res {
-        Some(index) => UntaggedValue::Primitive(Primitive::Int(index as i64)),
-        None => UntaggedValue::Primitive(Primitive::Nothing),
+    let chunked = match res {
+        Some(index) => UInt32Chunked::new_from_slice("arg_min", &[index as u32]),
+        None => UInt32Chunked::new_from_slice("arg_min", &[]),
     };
 
-    let value = Value {
-        value,
-        tag: tag.clone(),
-    };
+    let res = chunked.into_series();
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
 
-    let mut data = TaggedDictBuilder::new(tag);
-    data.insert_value("arg-min", value);
-
-    Ok(OutputStream::one(data.into_value()))
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/series/arg_sort.rs

@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuSeries, Signature};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
 use polars::prelude::IntoSeries;
 
 pub struct DataFrame;
@@ -12,7 +15,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Returns indexes for a sorted series"
+        "[Series] Returns indexes for a sorted series"
     }
 
     fn signature(&self) -> Signature {
@@ -26,8 +29,22 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Returns indexes for a sorted series",
-            example: "[1 2 2 3 3] | dataframe to-series | dataframe arg-sort",
-            result: None,
+            example: "[1 2 2 3 3] | dataframe to-df | dataframe arg-sort",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "arg_sort".to_string(),
+                    vec![
+                        UntaggedValue::int(0).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(2).into(),
+                        UntaggedValue::int(3).into(),
+                        UntaggedValue::int(4).into(),
+                    ],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -36,12 +53,24 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
     let reverse = args.has_flag("reverse");
 
-    let series = NuSeries::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
-    let res = series.as_ref().argsort(reverse);
+    let mut res = df.as_series(&df_tag.span)?.argsort(reverse).into_series();
+    res.rename("arg_sort");
 
-    Ok(OutputStream::one(NuSeries::series_to_value(
-        res.into_series(),
-        tag,
-    )))
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/series/arg_true.rs

@@ -1,7 +1,10 @@
 use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuSeries, Signature};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
 use polars::prelude::IntoSeries;
 
 pub struct DataFrame;
@@ -12,7 +15,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Returns indexes where values are true"
+        "[Series] Returns indexes where values are true"
     }
 
     fn signature(&self) -> Signature {
@@ -26,8 +29,16 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Returns indexes where values are true",
-            example: "[$false $true $false] | dataframe to-series | dataframe arg-true",
-            result: None,
+            example: "[$false $true $false] | dataframe to-df | dataframe arg-true",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "arg_true".to_string(),
+                    vec![UntaggedValue::int(1).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -35,9 +46,10 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let series = NuSeries::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
-    let bool = series.as_ref().bool().map_err(|e| {
+    let series = df.as_series(&df_tag.span)?;
+    let bool = series.bool().map_err(|e| {
         parse_polars_error::<&str>(
             &e,
             &tag.span,
@@ -46,7 +58,21 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     })?;
 
     let mut res = bool.arg_true().into_series();
-    res.rename("int");
+    res.rename("arg_true");
 
-    Ok(OutputStream::one(NuSeries::series_to_value(res, tag)))
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/series/arg_unique.rs

@@ -1,7 +1,10 @@
 use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{dataframe::NuSeries, Signature};
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
 use polars::prelude::IntoSeries;
 
 pub struct DataFrame;
@@ -12,7 +15,7 @@ impl WholeStreamCommand for DataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Returns indexes for unique values"
+        "[Series] Returns indexes for unique values"
     }
 
     fn signature(&self) -> Signature {
@@ -26,8 +29,20 @@ impl WholeStreamCommand for DataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Returns indexes for unique values",
-            example: "[1 2 2 3 3] | dataframe to-series | dataframe arg-unique",
-            result: None,
+            example: "[1 2 2 3 3] | dataframe to-df | dataframe arg-unique",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "arg_unique".to_string(),
+                    vec![
+                        UntaggedValue::int(0).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(3).into(),
+                    ],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
         }]
     }
 }
@@ -35,15 +50,29 @@ impl WholeStreamCommand for DataFrame {
 fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
 
-    let series = NuSeries::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
-    let res = series
-        .as_ref()
+    let mut res = df
+        .as_series(&df_tag.span)?
         .arg_unique()
-        .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
+        .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?
+        .into_series();
 
-    Ok(OutputStream::one(NuSeries::series_to_value(
-        res.into_series(),
-        tag,
-    )))
+    res.rename("arg_unique");
+
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
 }

crates/nu-command/src/commands/dataframe/series/concatenate.rs

@@ -0,0 +1,107 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
+use polars::prelude::IntoSeries;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe concatenate"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Concatenates strings with other array"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe concatenate").required(
+            "other",
+            SyntaxShape::Any,
+            "Other array with string to be concatenated",
+        )
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Concatenate string",
+            example: r#"let other = ([za xs cd] | dataframe to-df);
+    [abc abc abc] | dataframe to-df | dataframe concatenate $other"#,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0".to_string(),
+                    vec![
+                        UntaggedValue::string("abcza").into(),
+                        UntaggedValue::string("abcxs").into(),
+                        UntaggedValue::string("abccd").into(),
+                    ],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let other: Value = args.req(0)?;
+
+    let other_df = match &other.value {
+        UntaggedValue::DataFrame(df) => Ok(df),
+        _ => Err(ShellError::labeled_error(
+            "Incorrect type",
+            "can only concatenate another series",
+            other.tag.span,
+        )),
+    }?;
+
+    let other_series = other_df.as_series(&other.tag.span)?;
+    let other_chunked = other_series.utf8().map_err(|e| {
+        parse_polars_error::<&str>(
+            &e,
+            &other.tag.span,
+            Some("The concatenate command can only be used with string columns"),
+        )
+    })?;
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let series = df.as_series(&df_tag.span)?;
+    let chunked = series.utf8().map_err(|e| {
+        parse_polars_error::<&str>(
+            &e,
+            &df_tag.span,
+            Some("The concatenate command can only be used with string columns"),
+        )
+    })?;
+
+    let mut res = chunked.concat(other_chunked);
+
+    res.rename(series.name());
+
+    let df = NuDataFrame::try_from_series(vec![res.into_series()], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/contains.rs

@@ -0,0 +1,89 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
+};
+use nu_source::Tagged;
+use polars::prelude::IntoSeries;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe contains"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Checks if a pattern is contained in a string"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe contains").required(
+            "pattern",
+            SyntaxShape::String,
+            "Regex pattern to be searched",
+        )
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Returns boolean indicating if pattern was found",
+            example: "[abc acb acb] | dataframe to-df | dataframe contains ab",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0".to_string(),
+                    vec![
+                        UntaggedValue::boolean(true).into(),
+                        UntaggedValue::boolean(false).into(),
+                        UntaggedValue::boolean(false).into(),
+                    ],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let pattern: Tagged<String> = args.req(0)?;
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let series = df.as_series(&df_tag.span)?;
+    let chunked = series.utf8().map_err(|e| {
+        parse_polars_error::<&str>(
+            &e,
+            &df_tag.span,
+            Some("The contains command can only be used with string columns"),
+        )
+    })?;
+
+    let res = chunked
+        .contains(&pattern.item)
+        .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
+
+    let df = NuDataFrame::try_from_series(vec![res.into_series()], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/cumulative.rs

@@ -0,0 +1,127 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
+};
+use nu_source::Tagged;
+use polars::prelude::DataType;
+
+enum CumType {
+    Min,
+    Max,
+    Sum,
+}
+
+impl CumType {
+    fn from_str(roll_type: &str, span: &Span) -> Result<Self, ShellError> {
+        match roll_type {
+            "min" => Ok(Self::Min),
+            "max" => Ok(Self::Max),
+            "sum" => Ok(Self::Sum),
+            _ => Err(ShellError::labeled_error_with_secondary(
+                "Wrong operation",
+                "Operation not valid for cumulative",
+                span,
+                "Perhaps you want to use: max, min, sum",
+                span,
+            )),
+        }
+    }
+
+    fn to_str(&self) -> &'static str {
+        match self {
+            CumType::Min => "cum_min",
+            CumType::Max => "cum_max",
+            CumType::Sum => "cum_sum",
+        }
+    }
+}
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe cum"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Cumulative calculation for a series"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe cum")
+            .required("type", SyntaxShape::String, "rolling operation")
+            .switch("reverse", "Reverse cumulative calculation", Some('r'))
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Cumulative sum for a series",
+            example: "[1 2 3 4 5] | dataframe to-df | dataframe cum sum",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0_cum_sum".to_string(),
+                    vec![
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(3).into(),
+                        UntaggedValue::int(6).into(),
+                        UntaggedValue::int(10).into(),
+                        UntaggedValue::int(15).into(),
+                    ],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let cum_type: Tagged<String> = args.req(0)?;
+    let reverse = args.has_flag("reverse");
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let series = df.as_series(&df_tag.span)?;
+
+    if let DataType::Object(_) = series.dtype() {
+        return Err(ShellError::labeled_error(
+            "Found object series",
+            "Series of type object cannot be used for cumulative operation",
+            &df_tag.span,
+        ));
+    }
+
+    let cum_type = CumType::from_str(&cum_type.item, &cum_type.tag.span)?;
+    let mut res = match cum_type {
+        CumType::Max => series.cummax(reverse),
+        CumType::Min => series.cummin(reverse),
+        CumType::Sum => series.cumsum(reverse),
+    };
+
+    let name = format!("{}_{}", series.name(), cum_type.to_str());
+    res.rename(&name);
+
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/get_day.rs

@@ -0,0 +1,75 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
+
+use polars::prelude::IntoSeries;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe get-day"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Gets day from date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe get-day")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Returns day from a date",
+            example: r#"let dt = ('2020-08-04T16:39:18+00:00' | str to-datetime -z 'UTC');
+    let df = ([$dt $dt] | dataframe to-df);
+    $df | dataframe get-day"#,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0".to_string(),
+                    vec![UntaggedValue::int(4).into(), UntaggedValue::int(4).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let series = df.as_series(&df_tag.span)?;
+
+    let casted = series
+        .datetime()
+        .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
+
+    let res = casted.day().into_series();
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/get_hour.rs

@@ -0,0 +1,75 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
+
+use polars::prelude::IntoSeries;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe get-hour"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Gets hour from date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe get-hour")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Returns hour from a date",
+            example: r#"let dt = ('2020-08-04T16:39:18+00:00' | str to-datetime -z 'UTC');
+    let df = ([$dt $dt] | dataframe to-df);
+    $df | dataframe get-hour"#,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0".to_string(),
+                    vec![UntaggedValue::int(16).into(), UntaggedValue::int(16).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let series = df.as_series(&df_tag.span)?;
+
+    let casted = series
+        .datetime()
+        .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
+
+    let res = casted.hour().into_series();
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/get_minute.rs

@@ -0,0 +1,75 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
+
+use polars::prelude::IntoSeries;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe get-minute"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Gets minute from date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe get-minute")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Returns minute from a date",
+            example: r#"let dt = ('2020-08-04T16:39:18+00:00' | str to-datetime -z 'UTC');
+    let df = ([$dt $dt] | dataframe to-df);
+    $df | dataframe get-minute"#,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0".to_string(),
+                    vec![UntaggedValue::int(39).into(), UntaggedValue::int(39).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let series = df.as_series(&df_tag.span)?;
+
+    let casted = series
+        .datetime()
+        .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
+
+    let res = casted.minute().into_series();
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/get_month.rs

@@ -0,0 +1,75 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
+
+use polars::prelude::IntoSeries;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe get-month"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Gets month from date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe get-month")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Returns month from a date",
+            example: r#"let dt = ('2020-08-04T16:39:18+00:00' | str to-datetime -z 'UTC');
+    let df = ([$dt $dt] | dataframe to-df);
+    $df | dataframe get-month"#,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0".to_string(),
+                    vec![UntaggedValue::int(8).into(), UntaggedValue::int(8).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let series = df.as_series(&df_tag.span)?;
+
+    let casted = series
+        .datetime()
+        .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
+
+    let res = casted.month().into_series();
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/series/get_nanosecond.rs

@@ -0,0 +1,75 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
+
+use polars::prelude::IntoSeries;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe get-nanosecond"
+    }
+
+    fn usage(&self) -> &str {
+        "[Series] Gets nanosecond from date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe get-nanosecond")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Returns nanosecond from a date",
+            example: r#"let dt = ('2020-08-04T16:39:18+00:00' | str to-datetime -z 'UTC');
+    let df = ([$dt $dt] | dataframe to-df);
+    $df | dataframe get-nanosecond"#,
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "0".to_string(),
+                    vec![UntaggedValue::int(0).into(), UntaggedValue::int(0).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let series = df.as_series(&df_tag.span)?;
+
+    let casted = series
+        .datetime()
+        .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
+
+    let res = casted.nanosecond().into_series();
+    let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}