oantolin / orderless Goto Github PK
View Code? Open in Web Editor NEWEmacs completion style that matches multiple regexps in any order
License: GNU General Public License v3.0
Emacs completion style that matches multiple regexps in any order
License: GNU General Public License v3.0
It seems orderless
does not respect completion-ignore-case
when completing accounts in ledger.
emacs-27.2
orderless
commit d97a91f
ledger-mode commit 58a2bf57
Create these two files
/tmp/init.el
(require 'ledger-mode)
(require 'orderless)
(add-to-list 'auto-mode-alist '("\\.dat\\'" . ledger-mode))
(setq tab-always-indent 'complete
completion-ignore-case t
ledger-complete-in-steps t
completion-styles '(orderless))
/tmp/ledger.dat
2015/10/12 Exxon
Expenses:Auto:Gas $10.00
Liabilities:MasterCard $-10.00
2021/05/15 Exxon
Expenses:au
Then run
emacs -Q -L /load/path/to/orderless -L /load/path/to/ledger-mode -l /tmp/init.el +6:16 /tmp/ledger.dat
and then run M-x completion-at-point
which will give the error No match
. If you change au
to Au
emacs will expand it to Auto:
as expected.
If you instead use:
/tmp/init.el
(require 'ledger-mode)
(require 'orderless)
(add-to-list 'auto-mode-alist '("\\.dat\\'" . ledger-mode))
(setq tab-always-indent 'complete
completion-ignore-case t
ledger-complete-in-steps t)
I.e. not setting completion-styles
to '(orderless)
, emacs will expand au
to Auto:
as expected.
Not sure if this is an issue with ledger-mode
or orderless
, but given that this issue shows up when I use orderless
I'll start here. And to clarify this only happens in ledger-mode
, orderless
will ignore the case when running M-x
for example.
Thanks
Does it make sense to remove the condition-case since this should never happen? I think it is better to remove it then, since it could potentially shadow other bugs. Basically the pattern compiler should never produce invalid regexps. See 237ee00.
I just had a bug report where someone configured orderless as in your README, basically copying it verbatim, activating icomplete and then activating selectrum at the same time. Is it necessary to recommend icomplete in the example config? Ideally the example configs we provide should be such that they just work if copied verbatim. This is at least what I am trying to do 😄
I've recently started building an Emacs configuration myself instead of using some packaged solution, and I happily use orderless
, it's awesome :)
Now that I've come the point where I want to program (again) in Emacs, I realized that orderless is used for those company popups as well (great!). Is there a way to make it so that when typing (in a scratch buffer, I tried typing (macro
to see its hundreds of completions) the completions that are shown are interpreted as if I had actually typed ^myword
?
With the examples in the readme I'm pretty sure I could do that "globally" for orderless by adding a dispatcher, but I think I only want this behavior for those popups. Is there a nice way to do that?
(If this is the wrong place, I'm sorry)
Hello
I've modified the definition of words to include -
and _
, it looks like this change affects how orderless work with orderless-strict-*-initialism
(defun diego--treat-chars-as-word-char ()
(modify-syntax-entry ?_ "w")
(modify-syntax-entry ?- "w"))
(add-hook 'after-change-major-mode-hook #'diego--treat-chars-as-word-char)
When I disabled above code, orderless-strict-*-initialism
works as expected.
I've tried setting
(setq completion-pcm-word-delimiters "-_./:| ")
but it doesn't have any effect on orderless.
thanks!
These are just some ideas for discussion, no real feature request.
I wonder if we could have a possibility to filter based on metadata attached to candidates? Candidates could have a property 'candidate-metadata
which could then be matched on using some special syntax. The downside is that this would introduce a heavy implicit dependency on the metadata format.
Alternatively I can experiment with some consult internal completion style similar to consult--async-split
and add a consult-specific metadata filtering syntax. Maybe the only command where this is useful is consult-buffer
? But one could also see it as some in-band generalization of the current Consult narrowing.
Another question is if it is possible to add metadata filtering capabilities to existing commands. For example describe-variable
could have a special filter "type:c" to show only custom variables. But I have no idea what the best way is to add such special filtering expressions to given commands. I probably would not like to see too much special casing in orderless. Maybe something could be done based on the completion category?
cc @clemera
There hasn’t been a new for release for about a year, there has also
been some changes to the core API, like renaming
‘orderless-default-pattern-compiler’ to ‘orderless-pattern-compiler’,
which has caused the vertico package to complain. I think it might be
time to tag a new release :)
When completing-read
is given an initial input, such as one that represents a directory path, out-of-order matching will yield no results, unless the user's input starts with a space.
(find-file
(completing-read "Open recentf entry: " recentf-list nil t "/home/prot/"))
So If I evaluate the above and immediately type the mo
I am getting no matches. But if I type SPC the mo
I am getting a list of candidates.
Would it be possible to account for initial input and assume a space?
Would you be willing to add functions that can be used directly to support integration with ivy? I've already written them and can make a PR (they are very short). If not would the readme or wiki be better?
This command is only one of many ways to interactively change the separator. Besides prompting for the new separator, like this command does, you could toggle between two choices, cycle among a list of many, popup a hydra of choices, use the top of the kill-ring or some register, etc. It seems a matter of personal preference.
Probably choosing one particular way of interactively changing the separator and putting it in the package is a bad idea. Specially since I would guess the most popular thing is to not change the separator interactively at all, and people who do change it interactively probably have a fixed set of choices. A better option is to document various methods of interactively changing the separator on the Wiki.
So I've marked this function as obsolete and have created this issue, to have a location for comments on the matter.
EDIT: orderless
now includes a variable called orderless-transient-component-separator
intended to make writing such commands much easier.
Since d1c0cbf, there seems to be a major performance regression of the pattern compiler. When running consult-line
, entering a search term and then scrolling over the candidates in Selectrum by pressing <down>
, the scrolling gets slower and slower. I did some profiling and the main culprit is orderless-default-pattern-compiler
which eats up 80% of the time.
When there is no input leading numbers get highlighted for some reason, to reproduce:
(setq completion-styles '(orderless))
(setq orderless-matching-styles
'(orderless-strict-leading-initialism))
(completing-read "Test: " '("1this" "2that" "nohighlight"))
Sometimes I would like to find out items with str1
or str2
, instead of str1
AND str2
.
Is there a way like str1|str2
such that it can match both foo-str1
and foo-str2
?
Using a unicode letter character.
:map company-active-map
("," . (lambda () (interactive) (insert (propertize "ߊ" 'display " "))))
...
(setq orderless-component-separator "[ ߊ]+")
Add this to the readme? This trick is by @clemera, see radian-software/selectrum#419 (comment)
If I add the following code to my init.el
to activate orderless
in Emacs, then counsel-rg
no longer works in Emacs:
(require 'orderless)
(setq completion-styles '(orderless))
(setq ivy-re-builders-alist '((t . orderless-ivy-re-builder)))
Do you have any ideas how I might fix this problem?
Below is the code in myinit
file that pertains to counsel-rg
:
(defvar my-rg-excludes '("~/personal" "~/computing" "~/deft" "~/emacs" "~/resources" "~/sermons")
"List of directories to exclude from `counsel-rg' results.")
(define-advice counsel-rg
(:around (fn &optional in dir opts &rest args) my-glob)
"Exclude `my-rg-excludes' from `counsel-rg' results."
(let ((dir (or dir default-directory)))
(dolist (x my-rg-excludes)
(let ((glob (and (file-in-directory-p x dir)
(file-relative-name (expand-file-name "**" x) dir))))
(when glob (setq opts (concat "-g !" glob (and opts " ") opts))))))
(apply fn in dir opts args))
'(counsel-rg-base-command
'("rg" "-M" "260" "--with-filename" "--no-heading" "--line-number" "--color" "never" "%s" "--no-hidden"))
@oantolin I must say, I really like this package. I just added the twiddle flex matching to my init.el. It is really nice how this thing can be tweaked. In particular I like that this package is so easy to integrate - only replace the completion-style and done.
Right now I am using orderless without any fancy sorting package, but it would probably be nice to use something based on frecency. There is prescient and then there is the frecency package on melpa (but I think this is only the algorithm). What do you use?
Not sure if this is feasible, but it would be nice if there was a way to have smart case support or at least to support the equivalent case-fold-search
.
To keep in mind, see radian-software/selectrum#436 (comment). Maybe nothing can be done for certain patterns which may necessarily result in high complexity. Needs further investigation.
Not sure if this is significant, but FYI doom issues the following warning:
In toplevel form:
autoloads.28.0.50.el:698:168: Warning: Unused lexical variable
‘orderless-match-faces’
Hi Omar, you weren't very active on github any more so I hope you are doing well,
I discovered that orderless
matching does not work with org-set-tags-command
and multiple tags. You get completion for the first tag only. I have tested it with emacs -Q
(emacs-version 26.3, org-version 9.3.6) and completion-styles
set to orderless
:
#+tags: some tags to test
* Test :test:
When you press C-c C-q
with the point on the headline and afterwards press TAB
inside the minibuffer you will get [no match]
. With the default completion-styles
the completion buffer pops up showing the available tags.
Clearly orderless is configurable to a pretty much arbitrary degree... if you are willing to deal with minibuffer hooks and what not.
Now, suppose I wanted to use a particular value of orderless-matching-styles
for a particular class of commands, say just '(orderless-regexp)
for consult-lines
and friends (because orderless-initialism
is too permissive when matching against whole lines of text). How would you do it? I think it would be neat if a configuration like this worked:
(setq completion-category-overrides
'((file (styles partial-completion))
(consult-location (orderless-matching-styles orderless-regexp))
(orderless-style-dispatchers first-initialism
flex-if-twiddle
without-if-bang)))
I am experimenting with dynamic candidate sets. This is used in consult for the consult-buffer function which filters the virtual buffer candidates. If you press "b SPC" you are only shown buffers etc. @clemera wrote a minimal example which works in icomplete, but it does not in my usual init.el config where I have orderless.
This is the example:
(let ((colla '("this" "is" "the" "colla"))
(collb '("now" "showing" "collb")))
(defun test (str pred action)
(if (eq action 'metadata)
`(metadata
(cycle-sort-function . identity)
(display-sort-function . identity))
(let ((coll (cond ((string-prefix-p "a " str)
colla)
((string-prefix-p "b " str)
collb)
(t
(append colla collb)))))
(cond ((null action)
(cond ((or (string-prefix-p "a " str)
(string-prefix-p "b " str))
(concat (substring str 0 2)
(try-completion (substring str 2) coll pred)))
(t (try-completion str coll pred))))
((eq action t)
(all-completions
(cond ((or (string-prefix-p "a " str)
(string-prefix-p "b " str))
(substring str 2))
(t str))
coll pred))
(t nil))))))
(define-key minibuffer-local-completion-map (kbd "SPC") 'self-insert-command)
(completing-read "Check: " 'test)
See radian-software/selectrum#235 (comment) for context.
Is there some easy way to achieve this globally currently? I thought (global-)subword-mode
might do the trick, but it doesn't look like it.
See radian-software/selectrum#429 (comment) and discussion in radian-software/selectrum#429. cc @clemera @jaor
You have this ! matcher in your config. Would it be possible to add sth like this to orderless by default? Basically a not-matching style. Right now I am using a simple dispatcher which dispatches based on suffix ~ to flex and to literal with =.
When using orderless
and find-file
and I type /ssh:
, the completions I get are /scp:
and /scpx:
, expected to see a list of hostnames prefixed with /ssh:
.
orderless-0.6
emacs-28.0.50
Create /tmp/init.el
containing:
(require 'orderless)
(setf completion-styles '(orderless))
Run emacs -Q -l /tmp/init.el
and call find-file
and type /ssh:
and press tab. It should just give /scp:
and /scpx:
as completions.
Run emacs -Q
do the same and you should see a list of known hosts.
For example, if I type sl
as a query with the intention of it being an intialism, I'd rather all matches (or at least the first ones) be those matched by an initialism. This could be achieved by sorting initialisms first, but this package doesn't do sorting, and that would be overly complicated and slower.
What might be nice if there was some way to mark a query as something specific. I was thinking you could potentially customize different separators for different query types, which would allow doing this without any extra keypresses. For example -
could match an initialism,
could match an initialism or a regexp, etc. There could be a default if you haven't typed a separator yet. Even better would be if you could set a default per-query number (and as an alist per command). I guess this could potentially have speed improvements as well.
For example, I might set the default for query 1 to be initialism and the default for query 2 to be a regexp.
as a separator would not change things from the default. Normally, I would start with an initialism and then add a regexp if needed. If I wanted to start with a regexp instead, I would just add a space at the beginning to start the second query. For some commands, I would probably want to reverse that order (or maybe I could just do query 1 regexp, query 2 initialism, query 3 regexp instead of having different defaults for different commands; I'd have to play around with it).
In another example, maybe I realize I didn't type the initialism correctly (e.g. included too many letters). Instead of deleting the query, I could change it to fuzzy by using .
(or whatever) as a separator after it.
I guess this would require adding more commands for configuring separators. It's a little more complicated, but it would be completely optional, and it seems like it could be worth it to me. Most of the benefit for me would come from having different default matching types for different queries, so I think having different separators for different query types would be the less often useful part. Something similar (but not quite as flexible) could be achieved by just initially hitting the separator key enough times to get to the query type you want. I guess you could add even more rules to also be able to pick a specific query type beforehand, like you could specify two separators in a row... but that makes things even more complicated. I think it's probably enough to be able to change the query type afterward to handle the "oops, I actually need fuzzy" case. And even then, if it was the first query, you could just go to the beginning of the line and add the necessary number of separators to get it to be in the fuzzy query position. So maybe using separators to specify the query type isn't useful enough to justify the extra complexity.
What do you think? Do you have any other ideas?
In the light of the keep-lines/flush-lines discussion, would it make sense to support a special token like !!! to orderless such that we can get the complement?
These variables can be replaced by setting the "real" corresponding variables buffer-locally. This can be done in a minibuffer-with-setup-hook
. Original comment in #31, #31 (comment).
I tried to add the following recommended config from the README on a vanilla install of orderless:
(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))))
but this doesn't seem to actually add initialism matching to e.g. M-x
or C-h f
(tested with dk
for describe-key
).
While experimenting with dynamic tables I noticed that tables like the following behave differently with orderless:
(setq completion-styles
'(orderless))
(completing-read "Test: "
(completion-table-dynamic
(lambda (input)
(cond ((string-match "this" input)
(list "this" "this and that" "this and more"))
(t
(list "check" "that" "out"))))))
When using this
as input I don't get any completions with orderless, when using the standard styles I get the completions from the first cond clause.
The naive autoloading of cl-pushnew
is bad for a number of reasons:
cl-lib
library when packages are initialized.cl-pushnew
is not an autoloaded macro, so this will cause Emacs to fail to load packages if there is no other package or user config that is loading cl-lib
.Right now I have this in my config:
(defun dired-narrow--orderless-filter (filter)
(orderless-filter filter (list (dired-utils-get-filename 'no-dir))))
(defun dired-narrow-orderless ()
"Narrow a dired buffer to the files matching an orderless query."
(interactive)
(dired-narrow--internal #'dired-narrow--orderless-filter))
Maybe it would be better to add a command directly to dired-narrow
that just uses completion-styles
. I'll have to look into how completion-styles
actually works. It doesn't seem like changing it affects all-completions
.
I am trying to make a new "matching style" (not sure if I'm using the correct jargon) to make filtering in orderless
behaves well with diacritics. For example typing resume
would match résumé
, etc...
I have written a small function that would convert résumé
to resume
, using the built-in ucs-normalize.el
:
(defun remove-diacritics (s)
(replace-regexp-in-string
ucs-normalize-nfd-quick-check-regexp ""
(ucs-normalize-NFD-string s)))
However, adding this function to either orderless-matching-styles
or orderless-style-dispatchers
doesn't seem to work. I read the README but haven't been able to wrap my head around this. Any help is appreciated. Thanks!
This optimization plays a role for consult-ripgrep as long as you only enter "#grep" without a filter expression. The speed up is noticeable with many candidates. Where can we add this optimization to the pattern compiler? Short-circuit on empty/white-space-only input strings?
The variable
orderless-component-matching-style
should be set to a list of the desired styles to use. By default it enables the regexp and initialism styles.
Should be: orderless-component-matching-styles
Tripped me until I checked the source.
I'm hoping to add Orderless to GNU ELPA at some point and to this end I just signed the FSF copyright assignment papers. I believe all contributors whose lines added and deleted sum to more than 8 have also signed the papers except perhaps for @noctuid. So, @noctuid, have you already done the FSF copyright assignment? And if not, would you be willing to do so?
With default completion-styles
,
$ emacs -Q -l vertico/vertico.el -l orderless/orderless.el --eval '(vertico-mode)'
Then the following buffers are displayed.
After setting the following configuration,
(setq completion-styles '(orderless))
(setq completion-category-defaults nil)
(setq orderless-component-separator 'orderless-escapable-split-on-space)
Is it possible to display these buffers with orderless
completion style only?
I'm not quite sure how to debug this but I figured I should at least post it. Whenever my emacs instance has been running for some time the performance of company-capf
degrades to a standstill. I've done a profile when running some completion in an empty buffer and I got the below. Indicating something in orderless-filter
. However, even if I enable edebug on this function I cannot seem to trigger it to determine the issue. Have you experienced anything similar?
- company-post-command 1451 85%
- company--perform 1441 84%
- company--continue 1439 84%
- company-calculate-candidates 1439 84%
- company--fetch-candidates 1427 83%
- company-call-backend-raw 1427 83%
- apply 1427 83%
- company-capf 1427 83%
- company-capf--candidates 1427 83%
- completion-all-completions 1427 83%
- completion--nth-completion 1427 83%
- completion--some 1427 83%
- #<compiled 0x808f96f84b95aa8> 1427 83%
- orderless-all-completions 1427 83%
- orderless-filter 1410 82%
- condition-case 1410 82%
- save-match-data 1410 82%
- let 1410 82%
- unwind-protect 1410 82%
- progn 1410 82%
- pcase-let* 1410 82%
- let* 1410 82%
- let 1410 82%
let* 1410 82%
+ orderless-highlight-matches 16 0%
+ company--postprocess-candidates 9 0%
+ company-call-frontends 2 0%
+ company-call-frontends 10 0%
+ command-execute 93 5%
+ ... 67 3%
+ redisplay_internal (C function) 53 3%
+ timer-event-handler 33 1%
+ server-process-filter 6 0%
This is the profile when the same completion is run with completion-styles = '(basic partial-completion)
- command-execute 755 55%
+ funcall-interactively 755 55%
- company-post-command 324 23%
- company--perform 282 20%
- company--continue 274 19%
- company-calculate-candidates 271 19%
- company--fetch-candidates 270 19%
- company-call-backend-raw 270 19%
- apply 270 19%
- company-capf 270 19%
- company-capf--candidates 270 19%
- completion-all-completions 270 19%
- completion--nth-completion 270 19%
- completion--some 270 19%
- #<compiled 0x808f7f942f944a8> 270 19%
completion-basic-all-completions 258 18%
- completion-pcm-all-completions 12 0%
completion-pcm--find-all-completions 12 0%
+ company-call-backend 1 0%
company-update-candidates 1 0%
+ company-cancel 1 0%
+ company-call-frontends 8 0%
+ company-call-frontends 42 3%
+ timer-event-handler 142 10%
+ redisplay_internal (C function) 108 7%
+ ... 30 2%
+ server-process-filter 7 0%
posframe-run-hidehandler 1 0%
+ flycheck-maybe-display-error-at-point-soon 1 0%
+ evil-repeat-post-hook 1 0%
amx-save-to-file 1 0%
+ highlight-parentheses--initiate-highlight 1 0%
I'm opening an issue here first because I'm not sure whether company is actually at fault or not. If I set completion-styles
to '(flex)
, for example, it shows the highlighting correctly in the company popup, but for orderless, there is no highlighting.
When using capf, the backend completion table may ignore the prefix string and only use it to trigger completion (and not for filtering). An example given by @astoff is \cite{title TAB
and then the returned results do not necessarily match the prefix, the backend could return \cite{ref1}
.
(defun test-capf ()
(list
(save-excursion
(backward-word)
(point))
(point)
(lambda (str pred action)
(message "CALLED %S %S" str action)
(setq str "") ;; NOTE: Backend ignores the prefix!
(complete-with-action action '("a1" "a2" "a3" "a4"
"b1" "b2" "b3" "b4"
"c1" "c2" "c3" "c4")
str pred))))
(add-to-list 'completion-at-point-functions #'test-capf)
When using the style with a well-behaving "backend" like a list of strings, then the prefix is not ignored and matched as usual against the candidates. Maybe it makes sense to implement a separate prefix+orderless
style? This style could then be used mainly for capf, where it seems most useful.
If one looks at eglot, it does not actually ignore the prefix but matches it against a filterText
as returned by the server.
Probably in the case where the server returns items which do not actually match the prefix, the filterText
then contains the prefix such that the items are not filtered out? At least this is what @astoff's server seems to do:
(defun toy-all-completions (str table pred _point)
(let* ((parts (split-string str nil t))
(completion-regexp-list (mapcar #'regexp-quote (cdr parts)))
(completions (all-completions (or (car parts) "") table pred)))
(and completions (nconc completions 0))))
(defun toy-try-completion (str table pred _point)
;; (let* ((parts (split-string str nil t))
;; (completion-regexp-list (mapcar #'regexp-quote (cdr parts)))
;; (completion (try-completion (or (car parts) "") table pred)))
;; (if (stringp completion)
;; (cons completion (length completion))
;; completion)))
(car (split-string str nil t))
)
(add-to-list 'completion-styles-alist
'(toy
toy-try-completion toy-all-completions
"Toy completion."))
I wonder if it's possible to set orderless to match package-delete
by typing either padelete
and/or delepack
setting completion style to orderless-flex only achieves the former
Using orderless with find-file is severly disappointing: the candidates don't include paths but find-file starts by inserting a path, so there usually no matches.
If you delete the path in the minibuffer, you can match against the files in the current directory, but there seems to be no way to match files in other directories.
Thank you for publishing this!
When given a list of candidates:
A failed match will not shrink the minibuffer (as per resize-mini-windows t
):
The above also throws: Error in post-command-hook (icomplete-post-command-hook): (wrong-type-argument listp 0)
From that point, deleting the mismatching input and hitting SPC will automatically expand the first match, as if that were the only one:
But from that point, hitting TAB (minibuffer-complete
) will actually cycle through the candidates even though they are not visible.
Using your icomplete-vertical, though all of the above except minibuffer-resizing apply to the horizontal layout.
Currently "orderless-try-completion" does not try to complete the input when it matches more than one candidate. I think it could be useful to have this feature, so I have written a little package to find the longest common substrings(s) of multiple strings using Ukkonen's algorithm for building generalized suffix trees. The repository is here: https://gitlab.com/mmemmew/suffix-tree
I am wondering about your opinions. Do you think it would be a useful feature to add?
Hi, I've been using Orderless for a while and I love it, however there have been a few minor annoyances. Specifically, I used to be able to type in ev-b
for eval-buffer
, but now, Orderless expands ev-b
to switch-to-prev-buffer
. I'm not even sure what type of solution I'm looking for, but is there a completion style I'm not aware of that could help this?
cc: @minad (vertico author)
Thanks for your package!
I got Error in post-command-hook (vertico--exhibit): (void-function orderless-highlight-matches)
and minibuffer doesn't work anyway...
~/.debug.emacs.d/vertico-sample/init.el
;;; init.el --- Sample clean init.el -*- lexical-binding: t; -*-
;; ~/.debug.emacs.d/orderless/init.el
;; you can run like 'emacs -q -l ~/.debug.emacs.d/orderless/init.el'
(let ((this-file (or (bound-and-true-p byte-compile-current-file)
load-file-name
buffer-file-name)))
(setq user-emacs-directory
(expand-file-name (file-name-directory this-file))))
(custom-set-variables
'(package-archives '(("org" . "https://orgmode.org/elpa/")
("melpa" . "https://melpa.org/packages/")
("gnu" . "https://elpa.gnu.org/packages/"))))
(package-initialize)
(package-refresh-contents)
(setq debug-on-error t)
(unless (package-installed-p 'vertico)
(package-install 'vertico))
(vertico-mode 1)
(unless (package-installed-p 'orderless)
(package-install 'orderless))
(setq completion-styles '(orderless))
cd ~/.debug.emacs.d/vertico-sample
rm -rf elpa && emacs -q -l ~/.debug.emacs.d/vertico-sample/init.el
C-x C-f
then press e
.I have no idea but when I start Emacs again (with orderless and vertico installed), the minibuffer works fine.
rm -rf elpa && emacs -q -l ~/.debug.emacs.d/vertico-sample/init.el
C-x C-f
then press e
.C-x C-c
to exit Emacsemacs -q -l ~/.debug.emacs.d/vertico-sample/init.el
C-x C-f
then press e
.I have no idea too, but when I fix init.el like this (install orderless
before enabling vertico-mode
), minibuffer error has gone and works well.
;;; init.el --- Sample clean init.el -*- lexical-binding: t; -*-
;; ~/.debug.emacs.d/orderless/init.el
;; you can run like 'emacs -q -l ~/.debug.emacs.d/orderless/init.el'
(let ((this-file (or (bound-and-true-p byte-compile-current-file)
load-file-name
buffer-file-name)))
(setq user-emacs-directory
(expand-file-name (file-name-directory this-file))))
(custom-set-variables
'(package-archives '(("org" . "https://orgmode.org/elpa/")
("melpa" . "https://melpa.org/packages/")
("gnu" . "https://elpa.gnu.org/packages/"))))
(package-initialize)
(package-refresh-contents)
(setq debug-on-error t)
(unless (package-installed-p 'vertico)
(package-install 'vertico))
(unless (package-installed-p 'orderless)
(package-install 'orderless))
(vertico-mode 1)
(setq completion-styles '(orderless))
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.