# Nushell コードリーディングガイドライン

## はじめに

このガイドラインは、Nushellのコードベースを効率的に理解するための手引きです。
Rust言語に精通していないエンジニアでも、段階的に学習できるよう構成されています。

**対象読者:**
- プロジェクトに新規参画するエンジニア
- 他言語からの経験者
- コードレビューを行う担当者

---

## 1. 言語基礎

> このセクションでは、Rust言語の基本構文と概念を解説します。

### 1.1 プログラム構造

NushellはRust言語で記述されており、Cargoワークスペース構造を採用しています。
メインのエントリーポイントは `src/main.rs` にあります。

```rust
// ファイル: src/main.rs:61-62
fn main() -> Result<()> {
    let entire_start_time = std::time::Instant::now();
```

Rustのプログラムは `fn main()` 関数から開始されます。
`Result<()>` は関数の戻り値型で、成功または失敗を表すenum型です。

### 1.2 データ型と変数

Nushellでは `Value` 型がパイプラインを通じてデータを渡す際の主要なデータ型です。

```rust
// ファイル: crates/nu-protocol/src/value/mod.rs:51-53
#[derive(Debug, Serialize, Deserialize)]
pub enum Value {
    #[non_exhaustive]
    Bool {
        val: bool,
        #[serde(rename = "span")]
        internal_span: Span,
    },
    Int { val: i64, internal_span: Span },
    Float { val: f64, internal_span: Span },
    String { val: String, internal_span: Span },
    // ... その他のバリアント
}
```

**主要なデータ型:**
- `Bool`: 真偽値
- `Int`: 64ビット整数
- `Float`: 64ビット浮動小数点数
- `String`: 文字列
- `List`: 値のリスト
- `Record`: キーと値のペア (連想配列)
- `Closure`: クロージャ（無名関数）
- `Nothing`: 値なし

### 1.3 制御構造

Rustの制御構造はパターンマッチング (`match`) が特徴的です。

```rust
// ファイル: crates/nu-protocol/src/value/mod.rs (例)
match &self.expr {
    Expr::Block(block_id) => Some(block_id),
    Expr::Closure(block_id) => Some(block_id),
    _ => None,
}
```

`if let` を使った条件分岐も頻繁に使用されます：

```rust
// ファイル: src/main.rs:394-398
if let Some(ide_goto_def) = parsed_nu_cli_args.ide_goto_def {
    ide::goto_def(&mut engine_state, &script_name, &ide_goto_def);
    return Ok(());
}
```

### 1.4 関数/メソッド定義

Rustでは `impl` ブロック内でメソッドを定義します。

```rust
// ファイル: crates/nu-command/src/filters/where_.rs:7-13
impl Command for Where {
    fn name(&self) -> &str {
        "where"
    }

    fn description(&self) -> &str {
        "Filter values of an input list based on a condition."
    }
}
```

**関数シグネチャの読み方:**
- `fn name(&self) -> &str`: `self` への参照を受け取り、文字列スライスを返す
- `&self`: 不変の借用
- `&mut self`: 可変の借用
- `self`: 所有権を取得

### 1.5 モジュール/インポート

Rustのモジュールシステムは `mod` と `use` キーワードで構成されます。

```rust
// ファイル: src/main.rs:1-11
mod command;
mod command_context;
mod config_files;
mod experimental_options;
mod ide;
mod logger;
mod run;
mod signals;
#[cfg(unix)]
mod terminal;
mod test_bins;
```

`use` 文でインポート：

```rust
// ファイル: src/main.rs:13-17
use crate::{
    command::parse_cli_args_from_env,
    config_files::set_config_path,
    logger::{configure, logger},
};
```

---

## 2. プロジェクト固有の概念

> このセクションでは、Nushell特有の概念を解説します。

### 2.1 フレームワーク固有の概念

#### EngineState

`EngineState` はNushellの中核となるデータ構造で、全てのグローバル定義とセッション状態を保持します。

```rust
// ファイル: crates/nu-protocol/src/engine/engine_state.rs:84
#[derive(Clone)]
pub struct EngineState {
    files: Vec<CachedFile>,
    vars: Vec<Variable>,
    decls: Arc<Vec<Box<dyn Command + 'static>>>,
    pub(super) blocks: Arc<Vec<Arc<Block>>>,
    pub(super) modules: Arc<Vec<Arc<Module>>>,
    pub scope: ScopeFrame,
    pub env_vars: Arc<EnvVars>,
    pub config: Arc<Config>,
    // ...
}
```

#### PipelineData

パイプラインを通じてコマンド間でデータを受け渡すための型です。

```rust
// ファイル: crates/nu-protocol/src/pipeline/mod.rs:1-15
pub mod byte_stream;
mod handlers;
pub mod list_stream;
mod metadata;
mod out_dest;
mod pipeline_data;
mod signals;
```

#### Command トレイト

全てのNushellコマンドは `Command` トレイトを実装します。

```rust
// ファイル: crates/nu-command/src/filters/where_.rs:7-51
impl Command for Where {
    fn name(&self) -> &str { "where" }
    fn description(&self) -> &str { ... }
    fn signature(&self) -> nu_protocol::Signature { ... }
    fn run(
        &self,
        engine_state: &EngineState,
        stack: &mut Stack,
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> { ... }
}
```

### 2.2 プロジェクト独自のパターン

#### コマンド実装パターン

新しいコマンドを追加する際の標準パターン：

1. 構造体を定義
2. `Command` トレイトを実装
3. `name()`, `description()`, `signature()`, `run()` を実装
4. テストケースと例を追加

```rust
// ファイル: crates/nu-command/src/filters/where_.rs:4-6
#[derive(Clone)]
pub struct Where;
```

#### Result型によるエラーハンドリング

Nushellでは `ShellError` を使用したエラーハンドリングが標準です。

```rust
// ファイル: crates/nu-command/src/filters/where_.rs:57-82
fn run(
    &self,
    engine_state: &EngineState,
    stack: &mut Stack,
    call: &Call,
    input: PipelineData,
) -> Result<PipelineData, ShellError> {
    let head = call.head;
    let closure: Closure = call.req(engine_state, stack, 0)?;
    // ...
}
```

---

## 3. 命名規則

> このセクションでは、プロジェクト全体で使用される命名規則を解説します。

### 3.1 ファイル・ディレクトリ命名

| パターン | 意味 | 例 |
|---------|------|-----|
| `nu-*` | コアクレート | `nu-protocol`, `nu-engine`, `nu-parser` |
| `nu_plugin_*` | プラグインクレート | `nu_plugin_example`, `nu_plugin_query` |
| `mod.rs` | モジュールのルートファイル | `crates/nu-protocol/src/engine/mod.rs` |
| `lib.rs` | クレートのルートファイル | `crates/nu-protocol/src/lib.rs` |
| `*.nu` | Nushellスクリプト | `toolkit.nu`, `testing.nu` |

### 3.2 クラス・関数・変数命名

| プレフィックス/サフィックス | 意味 | 例 |
|---------------------------|------|-----|
| `eval_*` | 評価・実行関数 | `eval_block`, `eval_expression`, `eval_call` |
| `parse_*` | パース関数 | `parse_block`, `parse_expression`, `parse_pattern` |
| `*_id` | ID型の変数 | `block_id`, `var_id`, `decl_id` |
| `*State` | 状態を保持する構造体 | `EngineState`, `ReplState` |
| `*Error` | エラー型 | `ShellError`, `ParseError` |
| `get_*` | 取得メソッド | `get_decl`, `get_block`, `get_config` |
| `add_*` | 追加メソッド | `add_env_var`, `add_decl`, `add_variable` |
| `is_*` | 真偽値を返す関数 | `is_interactive`, `is_login`, `is_empty` |

### 3.3 プログラム分類一覧

| 分類 | 説明 | 主要クレート |
|------|------|-------------|
| コアエンジン | 言語の実行エンジン | `nu-engine` |
| プロトコル | 型定義とデータ構造 | `nu-protocol` |
| パーサー | Nushellスクリプトの解析 | `nu-parser` |
| コマンド | ビルトインコマンド群 | `nu-command` |
| CLI | コマンドラインインターフェース | `nu-cli` |
| プラグイン | プラグインシステム | `nu-plugin`, `nu-plugin-engine` |
| 標準ライブラリ | Nu標準関数 | `nu-std` |

---

## 4. ディレクトリ構造

> このセクションでは、プロジェクトのディレクトリ構造を解説します。

```
nushell-main/
├── src/                      # メインバイナリのソースコード
│   ├── main.rs               # エントリーポイント
│   ├── command.rs            # CLIコマンドライン引数処理
│   ├── config_files.rs       # 設定ファイル処理
│   └── run.rs                # 実行モード（REPL、ファイル、コマンド）
├── crates/                   # Cargoワークスペースのクレート群
│   ├── nu-protocol/          # 型定義・プロトコル
│   ├── nu-engine/            # 評価エンジン
│   ├── nu-parser/            # パーサー
│   ├── nu-command/           # ビルトインコマンド
│   ├── nu-cli/               # CLI・REPL
│   ├── nu-plugin/            # プラグインAPI
│   ├── nu-std/               # 標準ライブラリ
│   └── nu_plugin_*/          # 公式プラグイン
├── tests/                    # 統合テスト
├── devdocs/                  # 開発者ドキュメント
└── Cargo.toml                # ワークスペース設定
```

### 各ディレクトリの役割

| ディレクトリ | 役割 | 主要ファイル |
|-------------|------|-------------|
| `src/` | メインバイナリ | `main.rs`, `run.rs` |
| `crates/nu-protocol/` | 型定義・AST・設定 | `value/mod.rs`, `engine/`, `ast/` |
| `crates/nu-engine/` | コード実行・評価 | `eval.rs`, `compile/`, `closure_eval.rs` |
| `crates/nu-parser/` | ソース解析 | `parser.rs`, `lex.rs`, `parse_keywords.rs` |
| `crates/nu-command/` | ビルトインコマンド | `filters/`, `strings/`, `filesystem/` |
| `crates/nu-cli/` | REPL・補完 | `repl.rs`, `completions/`, `syntax_highlight.rs` |
| `crates/nu-plugin/` | プラグインSDK | `plugin/`, `lib.rs` |
| `crates/nu-std/` | Nu標準関数 | `std/`, `testing.nu` |

---

## 5. アーキテクチャ

> このセクションでは、プロジェクトのアーキテクチャパターンを解説します。

### 5.1 全体アーキテクチャ

Nushellはレイヤードアーキテクチャを採用しており、各レイヤーが明確な責務を持っています。

```
┌─────────────────────────────────────────────────────────────┐
│                      CLI / REPL Layer                        │
│  (nu-cli, src/main.rs)                                      │
├─────────────────────────────────────────────────────────────┤
│                    Command Layer                             │
│  (nu-command, nu-cmd-lang, nu-cmd-extra)                    │
├─────────────────────────────────────────────────────────────┤
│                     Engine Layer                             │
│  (nu-engine)                                                │
├─────────────────────────────────────────────────────────────┤
│                     Parser Layer                             │
│  (nu-parser)                                                │
├─────────────────────────────────────────────────────────────┤
│                   Protocol Layer                             │
│  (nu-protocol: Value, EngineState, AST, Config)             │
├─────────────────────────────────────────────────────────────┤
│                    Plugin Layer                              │
│  (nu-plugin, nu-plugin-engine, nu-plugin-protocol)          │
└─────────────────────────────────────────────────────────────┘
```

### 5.2 レイヤー構成

| レイヤー | 責務 | 代表的なファイル |
|---------|------|-----------------|
| CLI/REPL | ユーザーインタラクション | `src/main.rs`, `nu-cli/src/repl.rs` |
| Command | コマンドロジック実装 | `nu-command/src/filters/*.rs` |
| Engine | コード評価・実行 | `nu-engine/src/eval.rs` |
| Parser | ソースコード解析 | `nu-parser/src/parser.rs` |
| Protocol | データ型・状態管理 | `nu-protocol/src/value/mod.rs` |
| Plugin | 外部拡張機能 | `nu-plugin/src/lib.rs` |

### 5.3 データフロー

Nushellのデータフローは以下の順序で処理されます：

1. **入力受付**: CLI/REPLでユーザー入力を受け付ける
2. **レキシング**: `nu-parser` でトークン化
3. **パース**: トークンからAST（抽象構文木）を生成
4. **コンパイル**: ASTからIR（中間表現）を生成
5. **評価**: `nu-engine` でIRを実行
6. **出力**: `PipelineData` としてコマンド間でデータを受け渡し
7. **表示**: 最終結果をテーブルなどの形式で表示

```
User Input → Lexer → Parser → AST → Compiler → IR → Evaluator → Output
                                          ↑
                               EngineState (グローバル状態)
                                          ↓
                                    Stack (ローカル状態)
```

---

## 6. 主要コンポーネント

> このセクションでは、主要なコンポーネントとその連携を解説します。

### 6.1 エントリーポイント

アプリケーションは `src/main.rs` から開始されます。

```rust
// ファイル: src/main.rs:61-70
fn main() -> Result<()> {
    let entire_start_time = std::time::Instant::now();
    let mut start_time = std::time::Instant::now();
    miette::set_panic_hook();

    let engine_state = EngineState::new();

    // Parse commandline args very early
    let parsed = parse_cli_args_from_env().unwrap_or_else(|err| {
        // ...
    });
```

実行モードは以下の3つ：
- **REPL**: 対話型シェル (`run_repl`)
- **ファイル実行**: スクリプトファイル実行 (`run_file`)
- **コマンド実行**: `-c` オプションでコマンド実行 (`run_commands`)

### 6.2 ビジネスロジック

コマンドの実装は `crates/nu-command/` にカテゴリ別に整理されています。

```rust
// ファイル: crates/nu-command/src/filters/where_.rs:57-82
fn run(
    &self,
    engine_state: &EngineState,
    stack: &mut Stack,
    call: &Call,
    input: PipelineData,
) -> Result<PipelineData, ShellError> {
    let head = call.head;
    let closure: Closure = call.req(engine_state, stack, 0)?;

    let mut closure = ClosureEval::new(engine_state, stack, closure);

    let metadata = input.metadata();
    Ok(input
        .into_iter_strict(head)?
        .filter_map(move |value| {
            match closure
                .run_with_value(value.clone())
                .and_then(|data| data.into_value(head))
            {
                Ok(cond) => cond.is_true().then_some(value),
                Err(err) => Some(Value::error(err, head)),
            }
        })
        .into_pipeline_data_with_metadata(head, engine_state.signals().clone(), metadata))
}
```

### 6.3 データアクセス

`EngineState` と `Stack` がデータアクセスの中心です。

```rust
// ファイル: crates/nu-protocol/src/engine/engine_state.rs:84-138
pub struct EngineState {
    vars: Vec<Variable>,
    decls: Arc<Vec<Box<dyn Command + 'static>>>,
    pub(super) blocks: Arc<Vec<Arc<Block>>>,
    pub scope: ScopeFrame,
    pub env_vars: Arc<EnvVars>,
    pub config: Arc<Config>,
    // ...
}
```

**EngineState**: グローバルな定義（コマンド、変数、ブロック）を保持
**Stack**: ローカルな実行状態（変数値、スコープ）を保持

### 6.4 ユーティリティ/共通機能

`nu-utils` クレートに共通ユーティリティがあります：
- 文字列処理
- パフォーマンス計測
- ロケール処理

`nu-path` クレートにパス操作ユーティリティがあります：
- クロスプラットフォームパス処理
- ホームディレクトリ展開

---

## 7. よく使われるパターン

> このセクションでは、コード内で頻出するパターンを解説します。

### パターン一覧

| パターン | 説明 | 出現頻度 | 代表的なファイル |
|---------|------|---------|-----------------|
| Command実装 | コマンドトレイト実装 | 高 | `crates/nu-command/src/filters/*.rs` |
| Result伝播 | `?` 演算子によるエラー伝播 | 高 | 全ファイル |
| パターンマッチ | match式によるデータ処理 | 高 | `nu-protocol/src/value/mod.rs` |
| イテレータ | 関数型スタイルのデータ処理 | 高 | `nu-command/src/filters/*.rs` |
| Arc/Mutex | 並行性制御 | 中 | `nu-protocol/src/engine/*.rs` |

### 各パターンの詳細

#### パターン1: Command実装パターン

**目的:** 新しいNushellコマンドを追加する

**実装例:**
```rust
// ファイル: crates/nu-command/src/filters/where_.rs:4-51
#[derive(Clone)]
pub struct Where;

impl Command for Where {
    fn name(&self) -> &str {
        "where"
    }

    fn description(&self) -> &str {
        "Filter values of an input list based on a condition."
    }

    fn signature(&self) -> nu_protocol::Signature {
        Signature::build("where")
            .input_output_types(vec![
                (Type::List(Box::new(Type::Any)), Type::List(Box::new(Type::Any))),
            ])
            .required("condition", SyntaxShape::RowCondition, "Filter condition.")
            .category(Category::Filters)
    }

    fn run(
        &self,
        engine_state: &EngineState,
        stack: &mut Stack,
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
        // 実装
    }

    fn examples(&self) -> Vec<Example<'_>> {
        vec![
            Example {
                description: "Filter rows of a table.",
                example: "[{a: 1} {a: 2}] | where a > 1",
                result: Some(Value::test_list(vec![...])),
            },
        ]
    }
}
```

**解説:** 各コマンドは `Command` トレイトを実装し、`name()`, `description()`, `signature()`, `run()` メソッドを定義します。`examples()` はドキュメント生成とテストに使用されます。

#### パターン2: パイプラインデータ処理

**目的:** パイプラインを通じてデータを変換・フィルタリング

**実装例:**
```rust
// ファイル: crates/nu-command/src/filters/where_.rs:70-81
Ok(input
    .into_iter_strict(head)?
    .filter_map(move |value| {
        match closure
            .run_with_value(value.clone())
            .and_then(|data| data.into_value(head))
        {
            Ok(cond) => cond.is_true().then_some(value),
            Err(err) => Some(Value::error(err, head)),
        }
    })
    .into_pipeline_data_with_metadata(head, engine_state.signals().clone(), metadata))
```

**解説:** `PipelineData` を `into_iter_strict()` でイテレータに変換し、`filter_map()` でデータを処理後、`into_pipeline_data_with_metadata()` で再度 `PipelineData` に変換します。

---

## 8. 業務フロー追跡の実践例

> このセクションでは、実際の業務フローをコードで追跡する方法を解説します。

### 8.1 フロー追跡の基本手順

1. エントリーポイントを特定
2. 処理の流れを追跡（呼び出し関係を追う）
3. データの変換を確認
4. 最終的な出力を確認

### 8.2 フロー追跡の実例

#### 例1: `where` コマンドの実行フロー

**概要:** `[1 2 3] | where $it > 2` コマンドの実行フローを追跡

**処理フロー:**
```
REPL入力 → パーサー → AST生成 → エンジン評価 → where.run() → フィルタリング → 出力
```

**詳細な追跡:**

1. **REPL入力受付** (`crates/nu-cli/src/repl.rs`)
   ```rust
   // ユーザー入力をreedlineから受け取る
   ```

2. **パース処理** (`crates/nu-parser/src/parser.rs:26-32`)
   ```rust
   pub fn garbage(working_set: &mut StateWorkingSet, span: Span) -> Expression {
       Expression::garbage(working_set, span)
   }
   ```

3. **コマンド検索** (`crates/nu-engine/src/eval.rs:15-23`)
   ```rust
   pub fn eval_call<D: DebugContext>(
       engine_state: &EngineState,
       caller_stack: &mut Stack,
       call: &Call,
       input: PipelineData,
   ) -> Result<PipelineData, ShellError> {
       engine_state.signals().check(&call.head)?;
       let decl = engine_state.get_decl(call.decl_id);
   ```

4. **whereコマンド実行** (`crates/nu-command/src/filters/where_.rs:57-82`)
   ```rust
   fn run(
       &self,
       engine_state: &EngineState,
       stack: &mut Stack,
       call: &Call,
       input: PipelineData,
   ) -> Result<PipelineData, ShellError> {
       let head = call.head;
       let closure: Closure = call.req(engine_state, stack, 0)?;
       // ...
   }
   ```

5. **結果出力** (パイプラインの終端でテーブル表示)

### 8.3 フロー追跡チェックリスト

- [ ] エントリーポイントを特定したか
- [ ] 呼び出し関係を把握したか
- [ ] データの変換ポイントを確認したか
- [ ] エラーハンドリングを確認したか
- [ ] 最終的な出力を確認したか

---

## 9. 設計書の参照順序

> このセクションでは、プロジェクト理解のための設計書参照順序を案内します。

### 9.1 目的別ロードマップ

#### 全体像を把握したい場合
1. README.md - プロジェクト概要
2. crates/README.md - クレート構成
3. devdocs/README.md - 開発者ドキュメント

#### 特定機能を理解したい場合
1. 該当クレートのlib.rs - 公開API確認
2. 該当モジュールのmod.rs - 構造把握
3. 該当機能の実装ファイル

#### 改修作業を行う場合
1. CONTRIBUTING.md - 貢献ガイドライン
2. devdocs/rust_style.md - コードスタイル
3. tests/ - 既存テストケース確認

### 9.2 ドキュメント一覧

| ドキュメント | 概要 | 参照タイミング |
|-------------|------|---------------|
| README.md | プロジェクト概要 | 初回参照 |
| CONTRIBUTING.md | 貢献方法 | PRを作成する前 |
| crates/README.md | クレート概要 | 構造理解時 |
| devdocs/rust_style.md | Rustスタイルガイド | コード記述時 |
| devdocs/FAQ.md | よくある質問 | 問題発生時 |
| devdocs/PLATFORM_SUPPORT.md | プラットフォームサポート | クロスプラットフォーム開発時 |

---

## 10. トラブルシューティング

> このセクションでは、コードリーディング時によくある問題と解決法を解説します。

### よくある疑問と回答

#### Q: `Value` 型のバリアントが多すぎて追跡が難しい
A: `crates/nu-protocol/src/value/mod.rs` で `Value` enumの定義を確認し、主要なバリアント（Bool, Int, String, List, Record）から理解を始めてください。

#### Q: `EngineState` と `Stack` の違いは？
A: `EngineState` はグローバルな定義（コマンド、モジュール、ブロック）を保持し、全スコープで共有されます。`Stack` はローカルな実行状態（変数値、環境変数）を保持し、スコープごとに異なります。

#### Q: コマンドの追加方法は？
A: `crates/nu-command/src/` 配下の適切なカテゴリディレクトリに新しいファイルを作成し、`Command` トレイトを実装します。その後、`mod.rs` と `default_context.rs` に登録が必要です。

#### Q: テストの実行方法は？
A: `cargo test --workspace` で全テストを実行。特定クレートのみは `cargo test -p nu-command` のように指定。

### デバッグのヒント

1. **ログ出力**: `RUST_LOG=trace cargo run` で詳細ログを有効化
2. **IDE活用**: rust-analyzerを使用してコード内をジャンプ
3. **テスト駆動**: 既存テストを実行して動作を確認
4. **小さな変更から**: 最小限の変更でビルド・テストを繰り返す

---

## 付録

### A. 用語集

| 用語 | 説明 |
|-----|------|
| AST | Abstract Syntax Tree（抽象構文木）。パースされたコードの構造表現 |
| Block | Nushellのコードブロック（`{...}`） |
| Closure | 環境をキャプチャするブロック |
| Decl | Declaration。コマンドなどの宣言 |
| EngineState | エンジンのグローバル状態 |
| IR | Intermediate Representation（中間表現） |
| PipelineData | パイプラインを流れるデータ |
| Span | ソースコード内の位置情報 |
| Stack | 実行時のローカル状態 |
| Value | Nushellの値型 |

### B. ファイル一覧

| ファイル/ディレクトリ | 説明 | 主な内容 |
|---------------------|------|---------|
| src/main.rs | エントリーポイント | 起動処理、引数解析 |
| crates/nu-protocol/ | プロトコル定義 | Value, EngineState, AST |
| crates/nu-engine/ | 評価エンジン | eval, compile |
| crates/nu-parser/ | パーサー | lex, parse |
| crates/nu-command/ | ビルトインコマンド | filters, strings, system |
| crates/nu-cli/ | CLI/REPL | repl, completions |
| crates/nu-plugin/ | プラグインSDK | Plugin trait |
| crates/nu-std/ | 標準ライブラリ | Nuスクリプト |
| tests/ | 統合テスト | shellテスト |
| devdocs/ | 開発者ドキュメント | スタイルガイド、FAQ |

### C. 参考資料

- [Nushell Book (公式ドキュメント)](https://www.nushell.sh/book/)
- [Nushell Commands](https://www.nushell.sh/commands/)
- [Rust公式ドキュメント](https://doc.rust-lang.org/book/)
- [Rustonomicon (unsafe Rust)](https://doc.rust-lang.org/nomicon/)
- [Nushell Discord](https://discord.gg/NtAbbGn)
- [Nushell GitHub](https://github.com/nushell/nushell)
