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

## はじめに

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

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

**プロジェクト概要:**
Doom Emacsは、GNU Emacs用の設定フレームワークです。モジュラー設計により、約150のオプションモジュールを提供し、パフォーマンス最適化とユーザー体験の向上を目指しています。

---

## 1. 言語基礎

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

### 1.1 プログラム構造

Emacs Lispファイルは通常、以下の構造を持ちます。

```elisp
;; ファイル: lisp/doom.el:1-71
;;; doom.el --- the heart of the beast -*- lexical-binding: t; -*-
;;
;; Author:  Henrik Lissner <contact@henrik.io>
;; URL:     https://github.com/doomemacs/doomemacs
;;
;;; Commentary:
;;
;; This is Doom's heart, where I define all its major constants and variables...
;;
;;; Code:

;; 実際のコードがここに続く

(provide 'doom)
;;; doom.el ends here
```

**構造の要素:**
- `;;; ファイル名 --- 説明 -*- lexical-binding: t; -*-` - ファイルヘッダー（lexical-bindingは必須）
- `;;; Commentary:` - ドキュメントセクション
- `;;; Code:` - 実装コードの開始
- `(provide 'feature)` - モジュールの公開
- `;;; ファイル名 ends here` - ファイル終端マーカー

### 1.2 データ型と変数

**変数定義の種類:**

```elisp
;; ファイル: lisp/doom.el:218-231
(defgroup doom nil
  "A development framework for Emacs configurations and Emacs Lisp projects."
  :link '(url-link :tag "Website" "https://doomemacs.org")
  :group 'emacs)

(defconst doom-version "3.0.0-pre"
  "Current version of Doom Emacs core.")

(defvar doom-init-time nil
  "The time it took, in seconds (as a float), for Doom Emacs to start up.")
```

| 定義形式 | 用途 | 再代入可能 |
|---------|------|-----------|
| `defconst` | 定数の定義 | 技術的には可能だが非推奨 |
| `defvar` | グローバル変数（デフォルト値付き） | 可能 |
| `defcustom` | ユーザーカスタマイズ可能な変数 | 可能 |
| `setq` | 変数への代入 | - |
| `let` / `let*` | ローカル変数 | スコープ内のみ |

### 1.3 制御構造

```elisp
;; ファイル: lisp/doom.el:121-127
;; 条件分岐: pcase (パターンマッチング)
(defconst doom-system
  (pcase system-type
    ('darwin                           '(macos bsd))
    ((or 'cygwin 'windows-nt 'ms-dos)  '(windows))
    ((or 'gnu 'gnu/linux)              '(linux))
    ((or 'gnu/kfreebsd 'berkeley-unix) '(linux bsd))
    ('android                          '(android)))
  "A list of symbols denoting available features...")

;; ファイル: lisp/doom-lib.el:100-105
;; ループ: cl-loop
(cl-loop for hook in hook-list
         if (eq (car-safe hook) 'quote)
         collect (cadr hook)
         else collect (intern (format "%s-hook" (symbol-name hook))))
```

**主要な制御構造:**
- `if` / `when` / `unless` - 条件分岐
- `cond` - 多分岐
- `pcase` - パターンマッチング（推奨）
- `cl-loop` / `dolist` / `while` - ループ

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

```elisp
;; ファイル: lisp/doom-lib.el:182-205
(defun doom-load (path &optional noerror)
  "Load PATH and handle any Doom errors that arise from it.

If NOERROR, don't throw an error if PATH doesn't exist.
Return non-nil if loading the file succeeds."
  (doom-log "load: %s %s" (abbreviate-file-name path) noerror)
  (condition-case-unless-debug e
      (load path noerror 'nomessage)
    (doom-error
     (signal (car e) (cdr e)))
    (error
     ;; エラーハンドリング
     )))
```

**関数定義のパターン:**
- `defun` - 通常の関数
- `defmacro` - マクロ（コンパイル時展開）
- `cl-defun` - Common Lisp拡張関数（&key, &rest等）
- `defadvice!` - Doom独自のアドバイス定義マクロ

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

```elisp
;; ファイル: lisp/doom.el:210-212
(add-to-list 'load-path (file-name-directory load-file-name))
(require 'doom-compat) ; backport niceties from later versions of Emacs
(require 'doom-lib)

;; ファイル: lisp/doom-lib.el:882-938
(defmacro after! (package &rest body)
  "Evaluate BODY after PACKAGE have loaded.
...
Since the contents of these blocks will never by byte-compiled, avoid putting
things you want byte-compiled in them! Like function/macro definitions."
  ...)
```

**読み込みメカニズム:**
- `require` - 即座に読み込み（未ロード時のみ）
- `load` - ファイルを読み込み
- `autoload` - 遅延読み込み定義
- `after!` - Doom独自の遅延評価マクロ

---

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

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

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

**モジュールシステム:**

Doom Emacsは`:group module`形式でモジュールを識別します。

```elisp
;; ファイル: static/init.example.el:17-198
(doom! :input
       ;;chinese
       ;;japanese

       :completion
       (corfu +orderless)  ; フラグ付きモジュール
       vertico

       :ui
       doom              ; Doomのルックアンドフィール
       doom-dashboard
       ...

       :lang
       emacs-lisp
       (python +lsp)     ; +lsp フラグ付き
       ...)
```

**モジュールフラグ:**
- `+flag` - 機能を有効化
- モジュール設定で`(modulep! +flag)`により条件分岐

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

**use-package! マクロ:**

```elisp
;; ファイル: modules/lang/python/config.el:16-107
(use-package! python
  :mode ("/\\(?:Pipfile\\|\\.?flake8\\)\\'" . conf-mode)
  :init
  (setq python-environment-directory doom-cache-dir
        python-indent-guess-indent-offset-verbose nil)

  (when (modulep! +tree-sitter)
    (set-tree-sitter! 'python-mode 'python-ts-mode ...))

  :config
  (when (modulep! +lsp)
    (add-hook 'python-mode-local-vars-hook #'lsp! 'append))
  ...)
```

**map! マクロ（キーバインド定義）:**

```elisp
;; ファイル: modules/lang/python/config.el:112-118
(map! :after python
      :map python-base-mode-map
      :localleader
      :prefix ("i" . "imports")
      :desc "Insert missing imports" "i" #'pyimport-insert-missing
      :desc "Remove unused imports"  "R" #'pyimport-remove-unused
      :desc "Optimize imports"       "o" #'+python/optimize-imports)
```

**add-hook! マクロ:**

```elisp
;; ファイル: lisp/doom-ui.el:404-407
(add-hook! 'comint-mode-hook
  (defun doom--comint-init-move-cursor-to-prompt-h ()
    (add-hook 'pre-command-hook #'doom--comint-move-cursor-to-prompt-h
              nil t)))
```

---

## 3. 命名規則

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

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

| パターン | 意味 | 例 |
|---------|------|-----|
| `doom-*.el` | Doomコアファイル | `doom-lib.el`, `doom-ui.el` |
| `+*.el` | モジュール拡張ファイル | `+bindings.el`, `+evil.el` |
| `config.el` | モジュール設定ファイル | `modules/lang/python/config.el` |
| `packages.el` | パッケージ定義ファイル | `modules/lang/python/packages.el` |
| `init.el` | 初期化ファイル | `modules/*/init.el` |

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

| プレフィックス/サフィックス | 意味 | 例 |
|---------------------------|------|-----|
| `doom-*` | Doomコア関数/変数 | `doom-emacs-dir`, `doom-load` |
| `doom--*` | 内部（プライベート）関数/変数 | `doom--map-forms` |
| `+module/*` | モジュール固有関数 | `+python/open-repl` |
| `*-h` | フック関数 | `doom-init-ui-h` |
| `*-a` | アドバイス関数 | `doom--switch-to-fallback-buffer-maybe-a` |
| `*-fn` | 関数オブジェクト | `doom-run-switch-frame-hooks-fn` |
| `*!` | Doom独自マクロ | `use-package!`, `map!`, `add-hook!` |

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

| 分類 | 説明 | 配置場所 |
|-----|------|---------|
| コア | Doom本体の基盤機能 | `lisp/` |
| CLI | コマンドラインインターフェース | `lisp/cli/` |
| ライブラリ | 共通ユーティリティ | `lisp/lib/` |
| モジュール | 機能単位のプラグイン | `modules/` |
| ユーザー設定 | ユーザー固有設定 | `$DOOMDIR/` |

---

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

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

```
doomemacs-master/
├── bin/                    # CLIスクリプト
├── docs/                   # ドキュメント
├── early-init.el           # Emacs起動時の最初のエントリーポイント
├── lisp/                   # Doomコアライブラリ
│   ├── doom.el             # コア定義（心臓部）
│   ├── doom-lib.el         # 標準ライブラリ
│   ├── doom-start.el       # インタラクティブセッション用ブートストラップ
│   ├── doom-ui.el          # UI設定
│   ├── doom-editor.el      # エディタ設定
│   ├── doom-keybinds.el    # キーバインド基盤
│   ├── doom-cli.el         # CLIフレームワーク
│   ├── cli/                # 各CLIコマンド実装
│   └── lib/                # ユーティリティライブラリ
├── modules/                # 機能モジュール
│   ├── app/                # アプリケーション（カレンダー、RSSなど）
│   ├── checkers/           # 構文・スペルチェッカー
│   ├── completion/         # 補完システム
│   ├── config/             # 設定モジュール
│   ├── editor/             # エディタ機能
│   ├── emacs/              # Emacs組み込み機能拡張
│   ├── email/              # メールクライアント
│   ├── input/              # 入力メソッド
│   ├── lang/               # プログラミング言語サポート
│   ├── os/                 # OS固有設定
│   ├── term/               # ターミナルエミュレータ
│   ├── themes/             # テーマ
│   ├── tools/              # 開発ツール
│   └── ui/                 # UIコンポーネント
├── profiles/               # プロファイル設定
├── static/                 # テンプレート・サンプルファイル
└── shell.nix               # Nix開発環境
```

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

| ディレクトリ | 役割 | 主要ファイル |
|-------------|------|-------------|
| `lisp/` | Doomのコアシステム | `doom.el`, `doom-lib.el` |
| `lisp/cli/` | bin/doomコマンド実装 | `sync.el`, `doctor.el` |
| `lisp/lib/` | 共有ユーティリティ | `files.el`, `buffers.el` |
| `modules/` | 機能モジュール集 | 各`config.el`, `packages.el` |
| `bin/` | シェルスクリプト | `doom` |

---

## 5. アーキテクチャ

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

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

Doom Emacsは**モジュラーモノリス**パターンを採用しています。

```mermaid
graph TB
    subgraph "起動フロー"
        A[early-init.el] --> B[lisp/doom.el]
        B --> C[lisp/doom-lib.el]
        B --> D[lisp/doom-start.el]
        D --> E[doom-before-init-hook]
        E --> F[$DOOMDIR/init.el]
        F --> G[モジュール読み込み]
        G --> H[$DOOMDIR/config.el]
    end

    subgraph "コア層"
        B
        C
        D
    end

    subgraph "モジュール層"
        I[modules/:group/:name/]
        I --> J[init.el]
        I --> K[config.el]
        I --> L[packages.el]
    end
```

### 5.2 レイヤー構成

| レイヤー | 責務 | 代表的なファイル |
|---------|------|-----------------|
| ブートストラップ | Emacs起動・初期化 | `early-init.el` |
| コア | 基盤機能・API提供 | `lisp/doom.el`, `lisp/doom-lib.el` |
| インフラ | UI・エディタ・キーバインド | `lisp/doom-ui.el`, `lisp/doom-keybinds.el` |
| モジュール | 機能単位の実装 | `modules/*/*/config.el` |
| ユーザー | ユーザーカスタマイズ | `$DOOMDIR/config.el` |

### 5.3 データフロー

**起動時のロード順序（`lisp/doom.el:33-62`より）:**

```
1. $EMACSDIR/early-init.el
2.   -> $EMACSDIR/lisp/doom.el
3.      -> $EMACSDIR/lisp/doom-lib.el
4.   -> $EMACSDIR/lisp/doom-start.el
5.      -> hook: doom-before-init-hook
6.      -> $DOOMDIR/init.el
7. hook: before-init-hook
8. プロファイル初期化ファイル
9.    -> doom-{keybinds,ui,projects,editor}.el
10.   -> hook: doom-before-modules-init-hook
11.   -> modules/*/*/init.el
12.   -> hook: doom-after-modules-init-hook
13.   -> modules/*/*/config.el
14.   -> $DOOMDIR/config.el
15. hook: after-init-hook
16. hook: emacs-startup-hook
17. hook: doom-after-init-hook
```

---

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

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

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

```elisp
;; ファイル: early-init.el:28-151
;; Doomの「ユニバーサルブートストラッパー」
;; インタラクティブ/非インタラクティブ両セッションで最初に読み込まれる

;; GC遅延によるパフォーマンス最適化
(if noninteractive
    (setq gc-cons-threshold 134217728)  ; 128mb
  (setq gc-cons-threshold most-positive-fixnum))

;; Doomのコアを読み込み
(if (let ((load-suffixes '(".elc" ".el"))
          (doom (expand-file-name "lisp/doom" user-emacs-directory)))
      (if (file-exists-p (concat doom ".el"))
          (load doom nil (not init-file-debug) nil 'must-suffix)
        ...))
    (doom-initialize (not noninteractive))
  ...)
```

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

Doomのビジネスロジックはモジュールシステムに基づいています。

```elisp
;; ファイル: lisp/doom-lib.el:1530-1549
(defmacro doom! (&rest modules)
  "Bootstraps DOOM Emacs and its modules.

If the first item in MODULES doesn't satisfy `keywordp', MODULES is evaluated,
otherwise, MODULES is a variadic-property list..."
  `(when noninteractive
     (when (fboundp 'doom-module-mplist-map)
       (doom-module-mplist-map
        #'doom-module--put
        ,@(if (keywordp (car modules))
              (list (list 'quote modules))
            modules)))
     t))
```

### 6.3 データアクセス

Doomは`doom-modules`ハッシュテーブルでモジュール情報を管理します。

```elisp
;; ファイル: lisp/doom-lib.el:1387-1401
(defun doom-module-get (key &optional property)
  "Returns the plist for GROUP MODULE. Gets PROPERTY, specifically, if set."
  (declare (side-effect-free t))
  (when-let ((m (gethash key doom-modules)))
    (if property
        (aref m (or (plist-get
                     (eval-when-compile
                       (cl-loop with i = 1
                                for info in (cdr (cl-struct-slot-info 'doom-module))
                                nconc (list (doom-keyword-intern (symbol-name (car info)))
                                            (prog1 i (cl-incf i)))))
                     property)
                    (error "Unknown doom-module property: %s" property)))
      m)))
```

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

```elisp
;; ファイル: lisp/doom-lib.el:152-162
(defun doom-rpartial (fn &rest args)
  "Return a partial application of FUN to right-hand ARGS.

ARGS is a list of the last N arguments to pass to FUN..."
  (declare (side-effect-free t))
  (lambda (&rest pre-args)
    (apply fn (append pre-args args))))

;; ファイル: lisp/doom-lib.el:574-620
(defmacro fn! (&rest args)
  "Return an lambda with implicit, positional arguments.
...
Instead of:
  (lambda (a _ c &rest d) (if a c (cadr d)))
you can use:
  (fn! (if %1 %3 (cadr %*)))"
  ...)
```

---

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

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

### パターン一覧

| パターン | 説明 | 出現頻度 | 代表的なファイル |
|---------|------|---------|-----------------|
| `use-package!` | パッケージ設定宣言 | 高 | `modules/*/config.el` |
| `after!` | 遅延評価 | 高 | 全域 |
| `add-hook!` | フック登録 | 高 | 全域 |
| `map!` | キーバインド定義 | 高 | `modules/*/config.el` |
| `defadvice!` | 関数アドバイス | 中 | `lisp/*.el` |
| `setq!` | カスタム変数設定 | 中 | `lisp/*.el` |

### 各パターンの詳細

#### パターン1: use-package!

**目的:** パッケージの宣言的設定

```elisp
;; ファイル: lisp/doom-ui.el:440-476
(use-package! hl-line
  ;; Highlights the current line
  :hook (doom-first-buffer . global-hl-line-mode)
  :init
  (defvar global-hl-line-modes
    '(prog-mode text-mode conf-mode special-mode
      org-agenda-mode dired-mode)
    "What modes to enable `hl-line-mode' in.")
  :config
  (if (boundp 'global-hl-line-buffers)
      (setq global-hl-line-buffers ...)
    ...))
```

**解説:** `use-package!`はDoomの拡張版`use-package`で、`:hook`、`:init`、`:config`等のキーワードでパッケージのライフサイクルを宣言的に定義します。

#### パターン2: modulep!

**目的:** モジュール/フラグの条件チェック

```elisp
;; ファイル: modules/lang/python/config.el:22-25
(when (modulep! +tree-sitter)
  (set-tree-sitter! 'python-mode 'python-ts-mode
    `((python :url "https://github.com/tree-sitter/tree-sitter-python"
              :rev ,(if (< (treesit-library-abi-version) 15) "v0.23.6" "v0.25.0")))))

;; ファイル: modules/lang/python/config.el:34-36
(when (modulep! +lsp)
  (add-hook 'python-mode-local-vars-hook #'lsp! 'append)
  (add-hook 'python-ts-mode-local-vars-hook #'lsp! 'append))
```

**解説:** `modulep!`はモジュールやフラグが有効かどうかをコンパイル時にチェックし、条件付きコードを生成します。

#### パターン3: add-hook!

**目的:** 複数のフック/関数を簡潔に登録

```elisp
;; ファイル: lisp/doom-ui.el:538-539
(add-hook! '(completion-list-mode-hook Man-mode-hook)
           #'hide-mode-line-mode)

;; ファイル: lisp/doom-ui.el:558-559
(add-hook! '(prog-mode-hook text-mode-hook conf-mode-hook)
           #'display-line-numbers-mode)
```

**解説:** `add-hook!`は複数のフックに複数の関数を一度に登録できるDoom独自のマクロです。

---

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

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

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

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

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

#### 例1: Doom起動フロー

**概要:** Emacsが起動してからDoomが完全に初期化されるまでの流れ

**処理フロー:**
```
early-init.el → doom.el → doom-start.el → init.el → modules → config.el
```

**詳細な追跡:**

1. **early-init.el読み込み** (`early-init.el:29-44`)
   ```elisp
   ;; GC遅延設定
   (if noninteractive
       (setq gc-cons-threshold 134217728)
     (setq gc-cons-threshold most-positive-fixnum))
   ```

2. **doom.el読み込み** (`early-init.el:111-118`)
   ```elisp
   (if (let ((load-suffixes '(".elc" ".el"))
             (doom (expand-file-name "lisp/doom" user-emacs-directory)))
         (if (file-exists-p (concat doom ".el"))
             (load doom nil (not init-file-debug) nil 'must-suffix)
           ...))
       (doom-initialize (not noninteractive))
     ...)
   ```

3. **doom-initialize呼び出し** (`lisp/doom.el:793-892`)
   ```elisp
   (defun doom-initialize (&optional interactive?)
     "Bootstrap the Doom session ahead."
     (when (doom-context-push 'startup)
       ;; 各種初期化処理
       (require 'doom-start)
       ...))
   ```

4. **モジュール設定読み込み** (各`modules/*/config.el`)
   ```elisp
   ;; doom-before-modules-config-hook → config.el読み込み
   ```

#### 例2: キーバインド定義フロー

**概要:** `map!`マクロを使ったキーバインドが実際に登録されるまで

**処理フロー:**
```
map! → doom--map-process → general-define-key → define-key
```

**詳細な追跡:**

1. **map!マクロ展開** (`lisp/doom-keybinds.el:439-487`)
   ```elisp
   (defmacro map! (&rest rest)
     "A convenience macro for defining keybinds, powered by `general'."
     (when (or (bound-and-true-p byte-compile-current-file)
               (not noninteractive))
       (doom--map-process rest)))
   ```

2. **内部処理** (`lisp/doom-keybinds.el:294-366`)
   ```elisp
   (defun doom--map-process (rest)
     (let ((doom--map-fn doom--map-fn)
           doom--map-state
           doom--map-forms
           desc)
       (while rest
         ;; キーワード処理: :leader, :map, :prefix等
         )))
   ```

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

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

---

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

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

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

#### 全体像を把握したい場合
1. `README.md` - プロジェクト概要
2. `docs/index.org` - 公式ドキュメント
3. `lisp/doom.el` - コア定義（コメントの起動フロー説明）
4. `static/init.example.el` - モジュール構成例

#### 特定機能を理解したい場合
1. 対象モジュールの`README.org`（存在する場合）
2. `modules/:group/:name/config.el` - 設定実装
3. `modules/:group/:name/packages.el` - 依存パッケージ
4. `lisp/doom-*.el` - 関連コア機能

#### 改修作業を行う場合
1. `CONTRIBUTING.org` - コントリビューションガイド
2. 対象ファイルのヘッダーコメント
3. 関連する`doom-*-hook`の定義と使用箇所
4. テスト（存在する場合）

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

| ドキュメント | 概要 | 参照タイミング |
|-------------|------|---------------|
| `README.md` | プロジェクト紹介 | 初回 |
| `docs/index.org` | 総合ドキュメント | 通常 |
| `docs/getting_started.org` | 入門ガイド | 初回 |
| `docs/faq.org` | よくある質問 | トラブル時 |
| `docs/contributing.org` | 貢献ガイド | 開発時 |
| 各モジュールの`README.org` | モジュール説明 | 機能理解時 |

---

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

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

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

#### Q: `doom!`マクロの中身が評価されない
A: `doom!`は`noninteractive`セッション（`doom sync`等）でのみ評価されます。インタラクティブセッションでは空の`(when noninteractive ...)`となります。

#### Q: `use-package!`と`use-package`の違いは？
A: `use-package!`はDoomの拡張版で、`:defer-incrementally`や`:after-call`等の追加キーワードをサポートし、Doomのパッケージ管理と統合されています。

#### Q: `+module/function`の`+`の意味は？
A: `+`プレフィックスはモジュール固有の関数を示します。例えば`+python/open-repl`は`:lang python`モジュール専用の関数です。

#### Q: フックが呼ばれるタイミングを知りたい
A: `lisp/doom.el:33-62`のコメントに起動時のフック順序が詳細に記載されています。

### デバッグのヒント

**デバッグモードの有効化:**
```sh
# 環境変数でデバッグを有効化
DEBUG=1 emacs

# または
emacs --debug-init
```

**ロギングの確認:**
```elisp
;; doom-log でログを出力（DEBUG環境変数が必要）
(doom-log "message: %s" variable)

;; *Messages*バッファでログを確認
```

**コンテキストの確認:**
```elisp
;; 現在のDoomコンテキストを確認
doom-context  ; => (t) または (startup emacs ...)
```

---

## 付録

### A. 用語集

| 用語 | 説明 |
|-----|------|
| モジュール | `:group name`形式で識別されるDoomの機能単位 |
| フラグ | `+flag`形式のモジュールオプション |
| プロファイル | Doomの設定セット（`NAME@VERSION`形式） |
| `$DOOMDIR` | ユーザー設定ディレクトリ（通常`~/.doom.d/`） |
| `$EMACSDIR` | Doom本体ディレクトリ（通常`~/.config/emacs/`） |
| フック | 特定のイベントで実行される関数のリスト |
| アドバイス | 既存関数の振る舞いを変更する仕組み |

### B. ファイル一覧

| ファイル/ディレクトリ | 説明 | 主な内容 |
|---------------------|------|---------|
| `early-init.el` | 最初のエントリーポイント | GC最適化、Doom読み込み |
| `lisp/doom.el` | Doomの心臓部 | 定数、変数、起動最適化 |
| `lisp/doom-lib.el` | 標準ライブラリ | マクロ、ユーティリティ関数 |
| `lisp/doom-start.el` | インタラクティブ起動 | UI初期化、遅延読み込み |
| `lisp/doom-ui.el` | UI設定 | テーマ、フォント、バッファ |
| `lisp/doom-keybinds.el` | キーバインド基盤 | `map!`マクロ、リーダーキー |
| `modules/` | 機能モジュール | 言語サポート、ツール統合 |

### C. 参考資料

- [Doom Emacs公式ドキュメント](https://github.com/doomemacs/doomemacs/blob/master/docs/index.org)
- [Emacs Lisp Manual](https://www.gnu.org/software/emacs/manual/elisp.html)
- [use-packageドキュメント](https://github.com/jwiegley/use-package)
- [General.elドキュメント](https://github.com/noctuid/general.el)
- [Doom Emacs Discord](https://doomemacs.org/discord)
