### Orderless Keyword Dispatch Examples

Source: https://context7.com/oantolin/orderless/llms.txt

Provides various examples of using the Orderless keyword dispatcher for advanced filtering. These examples demonstrate filtering by buffer mode, file path, documentation, minor mode status, buffer modification status, read-only status, category, annotation, content, group, key binding, and variable value.

```emacs-lisp
;; Filter by buffer mode
;; Input: ":mod:org config" matches org-mode buffers containing "config"

;; Filter by file path
;; Input: ":fil:projects meeting" matches buffers visiting files in "projects" dir

;; Filter by documentation
;; Input: ":doc:completion function" finds functions with "completion" in docs

;; Filter enabled minor modes
;; Input: ":on auto" shows only enabled minor modes matching "auto"

;; Filter disabled minor modes
;; Input: ":off line" shows only disabled minor modes matching "line"

;; Filter modified buffers
;; Input: ":dif emacs" shows modified buffers with "emacs" in name

;; Filter read-only buffers
;; Input: ":ro help" shows read-only buffers with "help" in name

;; Match by category
;; Input: ":cat:buffer temp" filters to buffer category entries

;; Match by annotation
;; Input: ":ann:obsolete" matches candidates with "obsolete" in annotation

;; Match buffer content
;; Input: ":con:TODO" matches buffers containing "TODO" in their content

;; Match by group
;; Input: ":grp:files" matches candidates in the "files" group

;; Match by key binding
;; Input: ":key:C-x" finds commands bound to keys containing "C-x"

;; Match by variable value
;; Input: ":val:nil" matches variables with nil value
```

--------------------------------

### Basic Keyword Dispatch Setup for Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Enables and configures the keyword dispatcher for advanced filtering with Orderless. This setup allows for sophisticated filtering based on keywords and separators, providing a powerful way to narrow down completion candidates in Emacs.

```emacs-lisp
;; Enable keyword dispatcher for advanced filtering
(require 'orderless-kwd)
(add-to-list 'orderless-style-dispatchers #'orderless-kwd-dispatch)

;; Configure keyword syntax (defaults shown)
(setq orderless-kwd-prefix ?:,
      orderless-kwd-separator ":=")

;; Example: Switch to buffer with mode filtering
;; Input in switch-to-buffer: "work :mod:org"
;; Matches all buffers with "work" in name that are in org-mode
```

--------------------------------

### Helm Integration with Orderless Completion

Source: https://context7.com/oantolin/orderless/llms.txt

Demonstrates how to configure Orderless completion style for use with the Helm package. This setup ensures that Orderless features are automatically applied when using Helm for command execution or buffer switching, providing a consistent and powerful completion experience.

```emacs-lisp
;; Configure orderless with Helm
(setq helm-completion-style 'emacs)

;; Orderless configuration applies automatically
(setq completion-styles '(orderless basic))

;; Example: Using helm-M-x with orderless
;; Input: "mode enable" matches "auto-revert-mode-enable-hook"
```

--------------------------------

### Basic Orderless Configuration with use-package

Source: https://context7.com/oantolin/orderless/llms.txt

This snippet shows how to install and configure the Orderless completion style using the `use-package` macro in Emacs. It sets Orderless as the primary completion style with `basic` as a fallback and enables `partial-completion` for file paths. It also includes an alternative manual configuration.

```emacs-lisp
;; Install and configure orderless with use-package
(use-package orderless
  :ensure t
  :custom
  ;; Set orderless as primary completion style with basic as fallback
  (completion-styles '(orderless basic))
  ;; Use partial-completion for file paths to support wildcards
  (completion-category-overrides '((file (styles partial-completion))))
  ;; Enable leading wildcards in Emacs 31+
  (completion-pcm-leading-wildcard t))

;; Alternative manual configuration
(require 'orderless)
(setq completion-styles '(orderless basic)
      completion-category-overrides '((file (styles partial-completion))))
```

--------------------------------

### Custom Keyword Definition for Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Demonstrates how to define and register a custom keyword for Orderless filtering. This example shows how to create a keyword to filter buffers based on their size, illustrating the extensibility of the Orderless system.

```emacs-lisp
;; Add custom keyword to filter by buffer size
(defun my-orderless-kwd-large-buffer (_)
  "Match large buffers (>100KB)."
  (lambda (str)
    (when-let ((buf (get-buffer str)))
      (> (buffer-size buf) 100000))))

;; Register the custom keyword
(add-to-list 'orderless-kwd-alist
             '(large my-orderless-kwd-large-buffer t))

;; Usage: ":large python" finds large Python buffers
```

--------------------------------

### Configuring Substring Expansion in Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Explains the options for substring expansion in Orderless: `prefix` (default, efficient), `substring` (more flexible), and `nil` (disables expansion). Examples illustrate how each setting affects the completion process when the user triggers completion.

```emacs-lisp
;; Enable prefix expansion (default, efficient)
(setq orderless-expand-substring 'prefix)

;; Enable full substring expansion
(setq orderless-expand-substring 'substring)

;; Disable expansion (only complete unique matches)
(setq orderless-expand-substring nil)

;; Example with prefix expansion:
;; Input: "def" then TAB
;; If unique prefix exists, expands to "default-"
;; Then continue typing for further filtering

;; Example with substring expansion:
;; Input: "mode" then TAB
;; If substring "mode" is unique, expands to full match
;; More flexible but potentially slower
```

--------------------------------

### Configure Orderless Completion Style with use-package

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code snippet demonstrates how to install and configure the Orderless completion style using the `use-package` macro. It sets Orderless as the primary completion style, configures file completion overrides, and enables leading wildcard matching for partial completions.

```emacs-lisp
(use-package orderless
  :ensure t
  :custom
  (completion-styles '(orderless basic))
  (completion-category-overrides '((file (styles partial-completion))))
  (completion-pcm-leading-wildcard t)) ;; Emacs 31: partial-completion behaves like substring

```

--------------------------------

### Company Integration for Orderless Completion

Source: https://context7.com/oantolin/orderless/llms.txt

Configures Orderless completion style for use with the Company package. It allows spaces in company completion and highlights matches using a single face. This setup enhances the completion experience by offering more flexible and visually consistent results.

```emacs-lisp
;; Allow spaces in company completion
(setq orderless-component-separator "[ &]")

;; Highlight matches in company using single face
(defun just-one-face (fn &rest args)
  (let ((orderless-match-faces [completions-common-part]))
    (apply fn args)))

(advice-add 'company-capf--candidates :around #'just-one-face)

;; Example: In an Emacs Lisp buffer, typing "buf&mod"
;; completes to "buffer-mode" even with the ampersand separator

;; Alternative: Use different completion styles with company
(defun company-completion-styles (capf-fn &rest args)
  (let ((completion-styles '(basic partial-completion)))
    (apply capf-fn args)))

(advice-add 'company-capf :around #'company-completion-styles)
```

--------------------------------

### Emacs Lisp: Ivy Integration with Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Configures Orderless to work with the Ivy completion UI by setting `ivy-re-builders-alist` and adding `orderless-ivy-highlight` to `ivy-highlight-functions-alist`. An example shows 'file vis' matching 'find-file-visit-truename'.

```emacs-lisp
;; Configure orderless with Ivy
(setq ivy-re-builders-alist '((t . orderless-ivy-re-builder)))
(add-to-list 'ivy-highlight-functions-alist
             '(orderless-ivy-re-builder . orderless-ivy-highlight))

;; Example: Using counsel-M-x with orderless
;; Input: "file vis" matches "find-file-visit-truename"
;; Highlighting shows matched components in different colors
```

--------------------------------

### Orderless Component Separator Configuration

Source: https://context7.com/oantolin/orderless/llms.txt

This snippet demonstrates various ways to configure the component separator for Orderless. It shows how to set the separator to split on spaces, spaces/hyphens/slashes, use backslash-escaped spaces, or use shell-style quoted spaces. Each configuration is explained with an example of its usage.

```emacs-lisp
;; Default: split on spaces
(setq orderless-component-separator " +")

;; Split on spaces, hyphens, or slashes (useful for file paths and symbols)
(setq orderless-component-separator " +\\|[-/]")

;; Use backslash-escaped spaces
(setq orderless-component-separator #'orderless-escapable-split-on-space)

;; Use shell-style quoted spaces
(setq orderless-component-separator #'split-string-and-unquote)

;; Example usage with escaped spaces:
;; Input: "major\ mode emacs" matches "major mode for emacs"
;; Each escaped space is treated as part of the component, not a separator
```

--------------------------------

### Emacs Lisp: Literal Prefix Matching Dispatcher

Source: https://context7.com/oantolin/orderless/llms.txt

Defines a custom dispatcher that enables literal prefix matching for components starting with '^'. It shows an example where '^def value' matches 'default-value' but not 'undefined-value'.

```emacs-lisp
;; Match components as literal prefixes
(defun my-prefix-dispatcher (pattern _index _total)
  (when (string-prefix-p "^" pattern)
    (cons 'orderless-literal-prefix (substring pattern 1))))

(setq orderless-style-dispatchers '(my-prefix-dispatcher))

;; Example: Input "^def value" matches:
;; - "default-value"
;; - "define-value-list"
;; But not "undefined-value" (doesn't start with "def")
```

--------------------------------

### Emacs Lisp: Negation Dispatcher for Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Implements a negation dispatcher using the '!' prefix. It allows excluding components from matches, as shown in the example where 'buffer !temp' matches buffers without 'temp'.

```emacs-lisp
;; Use the orderless-not modifier with a dispatcher
(defun my-not-dispatcher (pattern _index _total)
  (cond
   ((equal "!" pattern) #'ignore)
   ((string-prefix-p "!" pattern)
    `(orderless-not . ,(substring pattern 1)))))

(setq orderless-style-dispatchers '(my-not-dispatcher))

;; Example: Input "buffer !temp" matches:
;; - "buffer-list"
;; - "buffer-mode"
;; But not "temporary-buffer" or "buffer-temp-file"
```

--------------------------------

### Orderless Initialism Matching Style

Source: https://context7.com/oantolin/orderless/llms.txt

This configuration enables initialism matching within Orderless, allowing users to match candidates by typing the first letter of each word. It's combined with literal and regexp matching for broader compatibility. The example demonstrates how 'eis' can match candidates like 'emacs-init-system'.

```emacs-lisp
;; Enable initialism matching for abbreviations
(setq orderless-matching-styles '(orderless-initialism
                                   orderless-literal
                                   orderless-regexp))

;; Example: Input "eis" matches:
;; - "emacs-init-system"
;; - "execute-internal-shell"
;; - "eval-in-sequence"
;; Each character must appear at the start of a word in order
```

--------------------------------

### Define Custom Orderless Style Dispatchers in Emacs Lisp

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code defines custom functions to act as style dispatchers for orderless completion. These functions determine matching styles based on the component pattern, its index, and the total number of components. It overrides default matching styles with regexps, initialisms, flex matching for twiddled patterns, and literal matching for patterns starting with '!'.

```emacs-lisp
  (defun flex-if-twiddle (pattern _index _total)
    (when (string-suffix-p "~" pattern)
      `(orderless-flex . ,(substring pattern 0 -1))))

  (defun first-initialism (pattern index _total)
    (if (= index 0) 'orderless-initialism))

  (defun not-if-bang (pattern _index _total)
    (cond
     ((equal "!" pattern)
      #'ignore)
     ((string-prefix-p "!" pattern)
      `(orderless-not . ,(substring pattern 1)))))

  (setq orderless-matching-styles '(orderless-regexp)
        orderless-style-dispatchers '(first-initialism
                                      flex-if-twiddle
                                      not-if-bang))
```

--------------------------------

### Orderless Regular Expression Matching Style

Source: https://context7.com/oantolin/orderless/llms.txt

This snippet configures Orderless to use regular expression matching in addition to literal matching. When enabled, each component of the user's input is interpreted as a regular expression, allowing for more flexible and powerful pattern matching. The example shows how '^def.*or$' can match various candidates.

```emacs-lisp
;; Enable regexp matching (default, combined with literal)
(setq orderless-matching-styles '(orderless-regexp orderless-literal))

;; Example: Input "^def.*or$" matches:
;; - "default-minor-mode-indicator"
;; - "define-error"
;; Components are interpreted as regular expressions
```

--------------------------------

### Orderless Literal Matching Style

Source: https://context7.com/oantolin/orderless/llms.txt

This configuration enables only literal matching for Orderless. Literal matching requires each component of the input to appear exactly as typed within the candidate string. The example illustrates how input like 'buf mode' would match candidates containing both 'buf' and 'mode' literally.

```emacs-lisp
;; Enable only literal matching
(setq orderless-matching-styles '(orderless-literal))

;; Example: Input "buf mode" matches:
;; - "buffer-mode"
;; - "mode-in-buffer"
;; - "modify-buffer"
;; Each component must appear exactly as typed
```

--------------------------------

### Orderless Flex (Fuzzy) Matching Style

Source: https://context7.com/oantolin/orderless/llms.txt

This snippet shows how to enable flex (fuzzy) matching in Orderless, which allows components to match even if they are not consecutive in the candidate string, as long as the characters appear in the correct order. It's combined with literal and regexp matching. The example illustrates how 'abc' can match candidates like 'a-big-car'.

```emacs-lisp
;; Enable flex matching
(setq orderless-matching-styles '(orderless-flex
                                   orderless-literal
                                   orderless-regexp))

;; Example: Input "abc" matches:
;; - "a-big-car"
;; - "apply-basic-configuration"
;; - "alphabetic-character"
;; Characters must appear in order but not consecutively
```

--------------------------------

### Highlighting Matches with Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Demonstrates how to use orderless-highlight-matches to visually emphasize strings that match a compiled pattern or a direct list of regexps. It also shows how to create custom highlighting functions.

```emacs-lisp
;; Compile pattern and highlight strings
(let* ((pattern "buf mode")
       (compiled (orderless-compile pattern))
       (regexps (cdr compiled))
       (strings '("buffer-mode" "mode-buffer-list" "major-mode")))
  (orderless-highlight-matches regexps strings))
;; Returns list with strings highlighted using orderless-match-face-* faces

;; Highlight with direct regexp list
(orderless-highlight-matches
 '("buf" "mode")
 '("buffer-mode" "global-mode-buffer"))
;; Each component highlighted in different cyclical faces

;; Custom highlighting example
(defun my-custom-highlighter (input candidates)
  "Highlight CANDIDATES matching INPUT with custom colors."
  (let* ((compiled (orderless-compile input))
         (regexps (cdr compiled)))
    (orderless-highlight-matches regexps candidates)))

(my-custom-highlighter "file vis"
                      '("find-file-visit-truename"
                        "file-visitor"
                        "visit-file-hook"))
```

--------------------------------

### Basic Orderless Pattern Compilation

Source: https://context7.com/oantolin/orderless/llms.txt

Covers the fundamental use of `orderless-compile` to transform a search string into a list of regular expression strings. It also demonstrates how to use style dispatchers for special matching behaviors like literal or initialism matching.

```emacs-lisp
;; Compile a pattern into predicate and regexps
(orderless-compile "buf mode")
;; Returns: (nil . ("buf" "mode"))
;; First element is predicate (nil means no special predicate)
;; Second element is list of regexp strings

;; Compile with style dispatchers
(let ((orderless-style-dispatchers '(orderless-affix-dispatch)))
  (orderless-compile "=buf ,mode"))
;; Returns: (nil . ("\\`buf" "\\<m.*\\<o.*\\<d.*\\<e"))
;; =buf compiles to literal, ,mode compiles to initialism

;; Compile with custom styles
(orderless-compile "test"
                  '(orderless-flex)
                  nil)
;; Returns: (nil . ("t.*e.*s.*t"))
;; Forces flex matching for all components
```

--------------------------------

### Configure Orderless Completion Style Manually

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code snippet shows the manual configuration for the Orderless completion style after it has been added to the load-path. It requires the `orderless` package and then sets the `completion-styles`, `completion-category-overrides`, and `completion-pcm-leading-wildcard` variables to enable Orderless functionality.

```emacs-lisp
(require 'orderless)
(setq completion-styles '(orderless basic)
      completion-category-overrides '((file (styles partial-completion)))
      completion-pcm-leading-wildcard t) ;; Emacs 31: partial-completion behaves like substring

```

--------------------------------

### Advanced Orderless Compilation with Predicates

Source: https://context7.com/oantolin/orderless/llms.txt

Explains how to compile patterns that include predicates, such as negation, to filter candidates. It shows how to define custom style dispatchers to generate these predicates and how to use the compiled pattern for matching.

```emacs-lisp
;; Pattern with negation creates predicates
(let ((orderless-style-dispatchers
       '((lambda (pattern _index _total)
          (when (string-prefix-p "!" pattern)
            `(orderless-not . ,(substring pattern 1)))))))
  (orderless-compile "mode !temp"))
;; Returns: (PREDICATE-FUNCTION . ("mode"))
;; The predicate function filters out strings containing "temp"

;; Use compiled pattern for matching
(let* ((compiled (orderless-compile "buf !temp"))
       (pred (car compiled))
       (regexps (cdr compiled))
       (candidates '("buffer-mode" "temp-buffer" "buffer-list")))
  (cl-remove-if-not
   (lambda (str)
     (and (or (not pred) (funcall pred str))
          (cl-every (lambda (re) (string-match-p re str)) regexps)))
   candidates))
;; Returns: ("buffer-mode" "buffer-list")
;; "temp-buffer" filtered out by predicate
```

--------------------------------

### Direct Filtering API with Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Illustrates the direct filtering API provided by Orderless. This API allows programmatic filtering of candidate lists using simple string matching, predicates, or by integrating with completion actions, offering flexibility for custom completion logic.

```emacs-lisp
;; Filter a list of candidates
(let ((candidates '("buffer-mode" "file-mode" "major-mode"
                   "minor-mode" "mode-line-format")))
  (orderless-filter "mode buf" candidates))
;; Returns: ("buffer-mode")

;; Filter with predicate
(let ((candidates '("test-function" "production-function" "test-suite")))
  (orderless-filter "test" candidates
                   (lambda (s) (string-match-p "function" s))))
;; Returns: ("test-function")

;; Use with completion tables
(orderless-filter "find file"
                 (lambda (string pred action)
                   (complete-with-action action
                                       '("find-file" "find-file-other-window"
                                         "find-library" "recentf-find-file")
                                       string pred)))
;; Returns: ("find-file" "find-file-other-window" "recentf-find-file")
```

--------------------------------

### Emacs Lisp: Configure Icomplete to use Helm Completion Style

Source: https://github.com/oantolin/orderless/blob/master/README.org

This snippet demonstrates how to configure Emacs' Icomplete mode to use Helm's completion style for out-of-order matching. It requires the Helm package and sets 'helm' as a completion style alongside 'basic'.

```emacs-lisp
(require 'helm)
(setq completion-styles '(helm basic))
(icomplete-mode)
```

--------------------------------

### Extracting Component Regexps with Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Shows how to use `orderless-compile` internally to extract the individual regular expression components of a pattern. This is useful for understanding how patterns are parsed and for debugging matching logic, including different matching styles like initialism.

```emacs-lisp
;; Internal function for getting component regexps
(defun my-get-component-regexps (pattern)
  "Extract component regexps from PATTERN."
  (cdr (orderless-compile pattern)))

(my-get-component-regexps "find file recent")
;; Returns: ("find" "file" "recent")

(let ((orderless-matching-styles '(orderless-initialism)))
  (my-get-component-regexps "fdf"))
;; Returns: ("\\<f.*\\<d.*\\<f")
;; Shows the actual regexp for initialism matching
```

--------------------------------

### Customizing Orderless Match Faces

Source: https://context7.com/oantolin/orderless/llms.txt

Explains how to customize the faces used for highlighting matches in Orderless. This includes setting specific colors and weights for different match levels, or reducing to a single face for simpler highlighting.

```emacs-lisp
;; Customize match faces
(custom-set-faces
 '(orderless-match-face-0 ((t (:foreground "blue" :weight bold))))
 '(orderless-match-face-1 ((t (:foreground "magenta" :weight bold))))
 '(orderless-match-face-2 ((t (:foreground "green" :weight bold))))
 '(orderless-match-face-3 ((t (:foreground "orange" :weight bold)))))

;; Reduce to single face for simpler highlighting
(setq orderless-match-faces [completions-common-part])

;; Example: All matches use the same face instead of cycling through 4 faces
```

--------------------------------

### Emacs Lisp: Dynamic Configuration for Literal Matching

Source: https://context7.com/oantolin/orderless/llms.txt

Provides a function `my/match-components-literally` to switch Orderless to literal matching for the current session, bound to `C-l` in the minibuffer. This forces exact phrase matching.

```emacs-lisp
;; Function to switch to literal matching on-the-fly
(defun my/match-components-literally ()
  "Components match literally for the rest of the session."
  (interactive)
  (setq-local orderless-matching-styles '(orderless-literal)
              orderless-style-dispatchers nil))

;; Bind to C-l in minibuffer
(define-key minibuffer-local-completion-map (kbd "C-l")
  #'my/match-components-literally)

;; Example: During M-x completion, press C-l to force literal matching
;; Input after C-l: "query replace" will only match exact phrases
```

--------------------------------

### Emacs Lisp: Configure Orderless for Ivy Integration

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp configuration snippet integrates the orderless completion style with the Ivy completion UI. It sets the 'ivy-re-builders-alist' to use the orderless regex builder and adds orderless highlighting to the 'ivy-highlight-functions-alist'. This ensures that Ivy uses orderless for regex building and highlighting.

```emacs-lisp
(setq ivy-re-builders-alist '((t . orderless-ivy-re-builder)))
(add-to-list 'ivy-highlight-functions-alist '(orderless-ivy-re-builder . orderless-ivy-highlight))
```

--------------------------------

### Emacs Lisp: Default Orderless Affix Dispatch Configuration

Source: https://context7.com/oantolin/orderless/llms.txt

Configures the default affix dispatch behavior for Orderless, mapping prefixes like '%', '!', ',', '=', '^', and '~' to different matching styles such as ignore diacritics, negation, initialism, literal, literal prefix, and flex.

```emacs-lisp
;; Default affix dispatch configuration
(setq orderless-style-dispatchers '(orderless-affix-dispatch))
(setq orderless-affix-dispatch-alist
      '((?% . char-fold-to-regexp)  ; Ignore diacritics
        (?! . orderless-not)         ; Negation
        (?& . orderless-annotation)  ; Match in annotations
        (?, . orderless-initialism)  ; Initialism
        (?= . orderless-literal)     ; Literal
        (?^ . orderless-literal-prefix) ; Literal prefix
        (?~ . orderless-flex)))      ; Flex/fuzzy

;; Example usage:
;; Input: "=buffer ,efl !temp" matches:
;; - "buffer-enable-file-local" (=buffer as literal, ,efl as initialism)
;; But not anything containing "temp" (!temp negation)

;; Input: "~abc ^def" matches:
;; - "a-big-configuration-default-enable-feature" (~abc flex, ^def prefix)
```

--------------------------------

### Create Custom Completion Command with Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Defines custom Emacs Lisp functions to create completion commands using the orderless completion style. These functions allow users to complete buffer names or execute commands with specific orderless matching styles like initialism or literal.

```emacs-lisp
;; Custom completion command using orderless
(defun my-complete-buffer-name () 
  "Complete buffer name with orderless."
  (interactive)
  (let ((completion-styles '(orderless)))
    (switch-to-buffer
     (completing-read "Buffer: " (mapcar #'buffer-name (buffer-list))))))

;; Example: Call M-x my-complete-buffer-name
;; Input: "init el" completes to "*init.el*" buffer

;; Custom completion with category override
(defun my-complete-with-initialism () 
  "Complete with orderless+initialism style."
  (interactive)
  (let ((completion-styles '(orderless))
        (orderless-matching-styles '(orderless-initialism
                                     orderless-literal)))
    (call-interactively #'execute-extended-command)))

;; Example: Call my-complete-with-initialism
;; Input: "ffo" matches "find-file-other-window"
```

--------------------------------

### Orderless Matching Styles - Emacs Lisp

Source: https://github.com/oantolin/orderless/blob/master/README.org

Defines various styles for matching components of a pattern against a candidate string in Emacs Lisp. These styles include regular expressions, literal strings, prefixes, initialisms, and flexible matching. They are configurable via the `orderless-matching-styles` variable.

```Emacs Lisp
;; orderless-regexp :: the component is treated as a regexp that must
;; match somewhere in the candidate.

;; orderless-literal :: the component is treated as a literal string
;; that must occur in the candidate.

;; orderless-literal-prefix :: the component is treated as a literal
;; string that must occur as a prefix of a candidate.

;; orderless-prefixes :: the component is split at word endings and
;; each piece must match at a word boundary in the candidate, occurring
;; in that order.

;; orderless-initialism :: each character of the component should appear
;; as the beginning of a word in the candidate, in order.

;; orderless-flex :: the characters of the component should appear in
;; that order in the candidate, but not necessarily consecutively.

;; orderless-without-literal :: the component is a treated as a literal
;; string that must *not* occur in the candidate.

;; Example configuration:
;; (setq orderless-matching-styles '(orderless-literal orderless-regexp))

```

--------------------------------

### Emacs Lisp: Custom Orderless Dispatchers (Flex, Initialism, Negation)

Source: https://context7.com/oantolin/orderless/llms.txt

Defines custom dispatchers for flex matching with a tilde suffix, initialism for the first component, and negation with a bang prefix. These are then applied to `orderless-style-dispatchers`.

```emacs-lisp
;; Dispatcher for tilde suffix (flex matching)
(defun flex-if-twiddle (pattern _index _total)
  (when (string-suffix-p "~" pattern)
    `(orderless-flex . ,(substring pattern 0 -1))))

;; First component always as initialism
(defun first-initialism (pattern index _total)
  (if (= index 0) 'orderless-initialism))

;; Bang prefix for negation
(defun not-if-bang (pattern _index _total)
  (cond
   ((equal "!" pattern) #'ignore)
   ((string-prefix-p "!" pattern)
    `(orderless-not . ,(substring pattern 1)))))

;; Apply all custom dispatchers
(setq orderless-matching-styles '(orderless-regexp)
      orderless-style-dispatchers '(first-initialism
                                    flex-if-twiddle
                                    not-if-bang))

;; Example with M-x (execute-extended-command):
;; Input: "eis mino~ !global" matches:
;; - "emacs-init-system-minor-mode" (eis=initialism, mino~=flex, !global=not)
;; First component "eis" uses initialism, "mino~" uses flex, "!global" excludes
```

--------------------------------

### Integrate Orderless in Custom Completion Tables

Source: https://context7.com/oantolin/orderless/llms.txt

Demonstrates how to create a custom Emacs Lisp completion table that utilizes orderless filtering. This allows for flexible matching of candidates based on a provided string and predicate, supporting actions like metadata retrieval, providing all completions, trying a single completion, or testing completion.

```emacs-lisp
;; Create a completion table with orderless filtering
(defun my-completion-table (string pred action) 
  "Custom completion table using orderless."
  (let ((candidates '("emacs-lisp-mode"
                     "python-mode"
                     "org-mode"
                     "text-mode"
                     "fundamental-mode")))
    (cond
     ((eq action 'metadata)
      '(metadata (display-sort-function . identity)))
     ((eq action t)  ; all-completions
      (orderless-filter string candidates pred))
     ((eq action nil)  ; try-completion
      (try-completion string (orderless-filter string candidates pred) pred))
     ((eq action 'lambda)  ; test-completion
      (test-completion string candidates pred)))))

;; Use the custom completion table
(completing-read "Select mode: " #'my-completion-table)
;; Input: "py mode" matches "python-mode"
```

--------------------------------

### Emacs Lisp: Enable Word Prefix Matching in Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Configures Orderless to use word prefix matching styles, including prefixes, literal, and regexp. It demonstrates how inputs like 're-re' and 'f-d.t' match specific patterns.

```emacs-lisp
;; Enable word prefix matching
(setq orderless-matching-styles '(orderless-prefixes
                                   orderless-literal
                                   orderless-regexp))

;; Example: Input "re-re" matches:
;; - "query-replace-regexp"
;; - "recode-region"
;; - "magit-remote-list-refs"
;; Example: Input "f-d.t" matches:
;; - "final-draft.txt"
;; Components split at word endings must match at word boundaries
```

--------------------------------

### Emacs Lisp: Configure Helm to Use Emacs Completion Style

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp configuration snippet sets Helm's completion style to 'emacs'. This allows Helm to work with completion styles like orderless that adhere to the standard Emacs completion API. No specific orderless configuration is needed here, as Helm will defer to the Emacs backend.

```emacs-lisp
(setq helm-completion-style 'emacs)
```

--------------------------------

### Custom Orderless Completion Style Definition

Source: https://context7.com/oantolin/orderless/llms.txt

This code defines a custom Orderless completion style named `orderless+initialism` that includes `orderless-initialism`, `orderless-literal`, and `orderless-regexp` matching styles. It then applies this custom style to specific completion categories like `command`, `symbol`, `variable`, and `file`.

```emacs-lisp
;; Define a custom orderless style with initialism enabled
(orderless-define-completion-style orderless+initialism
  (orderless-matching-styles '(orderless-initialism
                               orderless-literal
                               orderless-regexp)))

;; Apply custom style to specific completion categories
(setq completion-category-overrides
      '((command (styles orderless+initialism))
        (symbol (styles orderless+initialism))
        (variable (styles orderless+initialism))
        (file (styles partial-completion))))

;; Example: When using M-x (execute-extended-command), typing "fdf"
;; will match "find-dired-file" using initialism matching
```

--------------------------------

### Define Custom Orderless Completion Style in Emacs Lisp

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code defines a new completion style named 'orderless+initialism' using the 'orderless-define-completion-style' macro. This custom style includes initialism, literal, and regexp matching styles. It then configures completion categories (command, symbol, variable) to use this new style.

```emacs-lisp
  (orderless-define-completion-style orderless+initialism
    (orderless-matching-styles '(orderless-initialism
                                 orderless-literal
                                 orderless-regexp)))
  (setq completion-category-overrides
        '((command (styles orderless+initialism))
          (symbol (styles orderless+initialism))
          (variable (styles orderless+initialism))))
```

--------------------------------

### Orderless Style Dispatchers - Emacs Lisp

Source: https://github.com/oantolin/orderless/blob/master/README.org

Enables custom query syntaxes in Emacs Lisp by mapping special characters to specific matching styles or modifiers. This allows for fine-grained control over how each component of a query string is interpreted, such as using '!' for negation or '^' for prefix matching.

```Emacs Lisp
;; Example default style dispatcher configuration:
;; (setq orderless-style-dispatchers
;;        '(orderless-affix-dispatch))

;; orderless-affix-dispatch maps characters to styles:
;; ! -> orderless-not
;; & -> orderless-annotation
;; , -> orderless-initialism
;; = -> orderless-literal
;; ^ -> orderless-literal-prefix
;; ~ -> orderless-flex
;; % -> ignore diacritics (char-fold-to-regexp)

```

--------------------------------

### Emacs Lisp: Add Company Completion Style Around Advice

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code defines a function `company-completion-styles` and adds it as an around advice to the `company-capf` function. This is likely used to customize or extend the behavior of the Company completion framework.

```emacs-lisp
(defun company-completion-styles (capf-fn &rest args)
  (let ((completion-styles '(basic partial-completion)))
    (apply capf-fn args)))

(advice-add 'company-capf :around #'company-completion-styles)
```

--------------------------------

### Emacs Lisp: Make All Components Match Literally

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code defines a function to set the orderless matching style to literal for all components and disables style dispatchers. It then binds this function to the 'C-l' key in the minibuffer for interactive use. This ensures that during a completion session, all parts of the pattern are treated as literal strings.

```emacs-lisp
(defun my/match-components-literally () "Components match literally for the rest of the session." (interactive) (setq-local orderless-matching-styles '(orderless-literal) orderless-style-dispatchers nil))

(define-key minibuffer-local-completion-map (kbd "C-l") #'my/match-components-literally)
```

--------------------------------

### Emacs Lisp: Apply Single Face for Orderless Matches in Company

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code defines an advice function 'just-one-face' that wraps the 'company-capf--candidates' function. It forces the 'orderless-match-faces' variable to use only the 'completions-common-part' face. This is a workaround for Company's limitation of only using one face for highlighting matches when orderless is used.

```emacs-lisp
(defun just-one-face (fn &rest args) (let ((orderless-match-faces [completions-common-part])) (apply fn args)))

(advice-add 'company-capf--candidates :around #'just-one-face)
```

--------------------------------

### Configuring Smart Case in Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Details how to enable or disable the 'smart case' feature in Orderless, which affects case sensitivity during matching. When enabled, input case determines matching behavior; when disabled, it falls back to the standard `completion-ignore-case` setting.

```emacs-lisp
;; Enable smart case (default)
(setq orderless-smart-case t)

;; Example with smart case enabled:
;; Input: "buffer mode" (lowercase) - case-insensitive
;; Matches: "Buffer-Mode", "buffer-mode", "BUFFER-MODE"

;; Input: "Buffer Mode" (mixed case) - case-sensitive
;; Matches: "Buffer-Mode" only
;; Does not match: "buffer-mode" or "BUFFER-MODE"

;; Disable smart case (use standard completion-ignore-case)
(setq orderless-smart-case nil
      completion-ignore-case t)
;; Now case sensitivity follows completion-ignore-case setting
```

--------------------------------

### Perform Batch Filtering with Orderless

Source: https://context7.com/oantolin/orderless/llms.txt

Provides Emacs Lisp functions for batch filtering operations using orderless. The first function filters a list of candidates against multiple patterns, returning matches for each pattern. The second function counts the number of candidates that match a single pattern.

```emacs-lisp
;; Filter multiple patterns across candidates
(defun my-multi-pattern-filter (patterns candidates) 
  "Filter CANDIDATES with multiple PATTERNS using orderless."
  (cl-loop for pattern in patterns
           collect (cons pattern (orderless-filter pattern candidates))))

(my-multi-pattern-filter
 '("buf mode" "file vis" "list all")
 '("buffer-mode" "file-visitor" "list-buffers-all"
   "global-mode-buffer" "visit-file" "all-completions-list"))
;; Returns: (("buf mode" . ("buffer-mode" "global-mode-buffer"))
;;           ("file vis" . ("file-visitor" "visit-file"))
;;           ("list all" . ("list-buffers-all" "all-completions-list")))

;; Filter and count matches
(defun my-count-matches (pattern candidates) 
  "Count candidates matching PATTERN."
  (length (orderless-filter pattern candidates)))

(my-count-matches "mode" (mapcar #'symbol-name obarray))
;; Returns: number of symbols containing "mode"
```

--------------------------------

### Emacs Lisp: Set Custom Separator for Orderless Company Integration

Source: https://github.com/oantolin/orderless/blob/master/README.org

This Emacs Lisp code snippet sets a custom separator for the orderless completion style, specifically for integration with Company. It uses an ampersand ('&') as an allowed separator within identifiers, which is useful for Emacs Lisp code. This modification addresses the limitation where the default space separator can prematurely end a completion component.

```emacs-lisp
(setq orderless-component-separator "[ &]")
```

--------------------------------

### Orderless Style Modifiers - Emacs Lisp

Source: https://github.com/oantolin/orderless/blob/master/README.org

Provides style modifiers in Emacs Lisp that alter how matching styles are applied. These modifiers can change the matching target (e.g., to annotations) or invert the matching logic (e.g., to exclude matches). They are intended for use with style dispatchers.

```Emacs Lisp
;; orderless-annotation :: this style modifier matches the pattern
;; against the annotation string of the candidate, instead of against
;; the candidate string.

;; orderless-not :: this style modifier inverts the pattern, such that
;; candidates pass which do not match the pattern.

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.