This is the nkeymaps Reference Manual, version 1.1.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Tue Jul 15 06:05:40 2025 GMT+0.
The main system appears first, followed by any subsystem dependency.
nkeymapsGeneral-purpose keymap management à-la Emacs.
Atlas Engineer LLC
(GIT https://github.com/atlas-engineer/nkeymaps.git)
BSD 3-Clause
1.1.1
alexandria (system).
fset (system).
trivial-package-local-nicknames (system).
uiop (system).
str (system).
types.lisp (file).
conditions.lisp (file).
package.lisp (file).
translators.lisp (file).
keymap.lisp (file).
modifiers.lisp (file).
keyscheme-map.lisp (file).
keyschemes.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
nkeymaps/nkeymaps.asdnkeymaps/types.lispnkeymaps/conditions.lispnkeymaps/package.lispnkeymaps/translators.lispnkeymaps/keymap.lispnkeymaps/modifiers.lispnkeymaps/keyscheme-map.lispnkeymaps/keyschemes.lispnkeymaps/types.lispnkeymaps (system).
list-of (type).
list-of-key-p (function).
list-of-keymap-p (function).
list-of-keyscheme-p (function).
list-of-modifier-p (function).
list-of-p (function).
list-of-string-p (function).
nkeymaps/conditions.lisptypes.lisp (file).
nkeymaps (system).
bad-keyspec (condition).
bad-modifier (condition).
cycle (condition).
duplicate-modifiers (condition).
empty-keyspec (condition).
empty-modifiers (condition).
empty-value (condition).
make-key-required-arg (condition).
override-existing-binding (condition).
error-condition (reader method).
(setf error-condition) (writer method).
existing-binding-value (reader method).
(setf existing-binding-value) (writer method).
keymap (reader method).
(setf keymap) (writer method).
keyspec (reader method).
keyspec (reader method).
(setf keyspec) (writer method).
(setf keyspec) (writer method).
message (reader method).
message (reader method).
message (reader method).
message (reader method).
message (reader method).
(setf message) (writer method).
(setf message) (writer method).
(setf message) (writer method).
(setf message) (writer method).
(setf message) (writer method).
modifiers (reader method).
(setf modifiers) (writer method).
nkeymaps/package.lispconditions.lisp (file).
nkeymaps (system).
nkeymaps/translators.lisppackage.lisp (file).
nkeymaps (system).
normalize-shift-modifier-state (function).
shift (function).
unshift (function).
+shift-layer-alist+ (special variable).
nkeymaps/keymap.lisptranslators.lisp (file).
nkeymaps (system).
*print-shortcut* (special variable).
*translator* (special variable).
binding-keys (function).
bound-type (reader method).
(setf bound-type) (writer method).
compare (method).
compare (method).
compose (function).
copy-key (function).
define-key (compiler macro).
define-key (function).
define-modifier (function).
key (structure).
key-code (reader).
(setf key-code) (writer).
key-modifiers (reader).
(setf key-modifiers) (writer).
key-status (reader).
(setf key-status) (writer).
key-value (reader).
(setf key-value) (writer).
key= (function).
keymap (class).
keymap->map (function).
keymap-p (function).
keymap-with-parents->map (function).
keys->keyspecs (function).
lookup-key (function).
make-key (function).
make-keymap (function).
modifier= (function).
modifiers (reader method).
(setf modifiers) (writer method).
name (reader method).
(setf name) (writer method).
parents (reader method).
(setf parents) (writer method).
pretty-binding-keys (function).
print-object (method).
%copy-key (function).
%make-key (function).
*default-bound-type* (special variable).
*modifier-list* (special variable).
bind-key (function).
binding-keys* (function).
copy-keymap (function).
copy-modifier (function).
entries (reader method).
(setf entries) (writer method).
key->keyspec (function).
key-p (function).
key-status-type (type).
keymap->map* (function).
keymap-tree->list (function).
keymap-with-parents (function).
keyspec->key (function).
keyspecs->keys (function).
keyspecs-type (type).
legal-modifiers-p (function).
lookup-key* (function).
lookup-keys-in-keymap (function).
make-modifier (function).
modifier (structure).
modifier-list (type).
modifier-p (function).
modifier-shortcut (reader).
(setf modifier-shortcut) (writer).
modifier-string (reader).
(setf modifier-string) (writer).
modspec->modifier (function).
modspecs->modifiers (function).
string-join (function).
nkeymaps/modifiers.lispkeymap.lisp (file).
nkeymaps (system).
nkeymaps/keyscheme-map.lispmodifiers.lisp (file).
nkeymaps (system).
bound-type (reader method).
(setf bound-type) (writer method).
define-keyscheme-map (compiler macro).
define-keyscheme-map (function).
get-keymap (function).
keyscheme (class).
keyscheme-map (type).
keyscheme-map-p (function).
keyscheme-p (function).
make-keyscheme (function).
make-keyscheme-map (function).
modifiers (reader method).
(setf modifiers) (writer method).
name (reader method).
(setf name) (writer method).
parents (reader method).
(setf parents) (writer method).
print-object (method).
copy-keyscheme-map (function).
quoted-symbol-p (function).
nkeymaps/keyschemes.lispkeyscheme-map.lisp (file).
nkeymaps (system).
Packages are listed by definition order.
nkeymaps/keyschemenkeymaps/translatornkeymaps/modifiernkeymapsnkeymaps/typesnkeymaps/conditionsnkeymaps/corenkeymaps/keyschemePackage holding the list of well-known keyschemes.
We use a dedicated package so that keyschemes can easily be listed and completed.
common-lisp.
nkeymaps/translatorPackage holding the list of predefined translators.
We use a dedicated package so that modifiers can easily be listed and completed.
See ‘nkeymaps:*translator*’.
common-lisp.
nkeymaps/core.
nkeymaps/modifier.
normalize-shift-modifier-state (function).
shift (function).
unshift (function).
+shift-layer-alist+ (special variable).
nkeymaps/modifierPackage holding the list of predefined modifiers.
We use a dedicated package so that modifiers can easily be listed and completed.
See ‘nkeymaps:define-modifier’.
common-lisp.
nkeymapsThe workflow goes as follows:
- Make a keymap with ‘nkeymaps:make-keymap’.
- Define a binding on it with ‘nkeymaps:define-key’.
- Lookup this binding with ‘nkeymaps:lookup-key’.
Example:
(let* ((parent-keymap (nkeymaps:make-keymap "parent-keymap"))
(my-keymap (nkeymaps:make-keymap "my-keymap" parent-keymap)))
(nkeymaps:define-key parent-keymap
"C-c" ’copy
"C-v" ’paste)
(nkeymaps:define-key my-keymap
"C-x" ’cut)
(values
(nkeymaps:lookup-key "C-x" parent-keymap)
(nkeymaps:lookup-key "C-x" my-keymap)
(nkeymaps:lookup-key "C-c" my-keymap)
(nkeymaps:binding-keys ’cut parent-keymap)
(nkeymaps:binding-keys ’copy my-keymap)
(nkeymaps:binding-keys ’paste my-keymap)))
;; => NIL, CUT, COPY;; => NIL, CUT, COPY, NIL, ("C-c"), ("C-v")
Notice that the inverse of ‘nkeymaps:lookup-key’ is ‘nkeymaps:binding-keys’.
Another workflow is to use ‘nkeymaps:keyscheme’s, which allows to compose
different binding styles.
Example:
(nkeymaps:define-keyscheme-map "test" ()
nkeymaps:cua ’("C-c" copy
"C-v" paste)
nkeymaps:emacs ’("C-x" cut))
The default keyschemes can be listed from the ‘nkeymaps/keyscheme:’ package
exported symbols.
New keyschemes can be created with ‘nkeymaps:make-keyscheme’.
Keys can be created with ‘nkeymaps:make-key’, which gives you more fine-tuning
compared to the "keyspecs" above:
(nkeymaps:make-key :code 38 :value "a" :modifiers ’("C"))
You can also specify key codes from the keyspec directly. For instance,
"C-#10" corresponds to keycode 10 with the ‘nkeymaps:+control+’.
Keymaps can be composed with ‘nkeymaps:compose’.
New modifiers can be defined with ‘nkeymaps:define-modifier’.
(nkeymaps:define-modifier :string "duper" :shortcut "D")
Some globals can be tweaked to customize the library to your needs:
- ‘nkeymaps:*translator*’: The function to infer the right binding when
the exact binding hits nothing.
- ‘nkeymaps:*print-shortcut*’: Print modifiers using their short form instead of the
full name, e.g. "C" instead of "control".
nkeymaps/typesPackage for types.
It’s useful to have a separate package because some types may need to generate
functions for the ‘satisfies’ type condition.
common-lisp.
list-of (type).
list-of-key-p (function).
list-of-keymap-p (function).
list-of-keyscheme-p (function).
list-of-modifier-p (function).
list-of-p (function).
list-of-string-p (function).
nkeymaps/conditionsPackage listing conditions.
common-lisp.
bad-keyspec (condition).
bad-modifier (condition).
cycle (condition).
duplicate-modifiers (condition).
empty-keyspec (condition).
empty-modifiers (condition).
empty-value (condition).
make-key-required-arg (condition).
override-existing-binding (condition).
error-condition (generic reader).
(setf error-condition) (generic writer).
existing-binding-value (generic reader).
(setf existing-binding-value) (generic writer).
keymap (generic reader).
(setf keymap) (generic writer).
keyspec (generic reader).
(setf keyspec) (generic writer).
message (generic reader).
(setf message) (generic writer).
modifiers (generic reader).
(setf modifiers) (generic writer).
nkeymaps/coreSee the ‘nkeymaps’ package documentation.
common-lisp.
nkeymaps/conditions.
nkeymaps/types.
*print-shortcut* (special variable).
*translator* (special variable).
binding-keys (function).
bound-type (generic reader).
(setf bound-type) (generic writer).
compose (function).
copy-key (function).
define-key (compiler macro).
define-key (function).
define-keyscheme-map (compiler macro).
define-keyscheme-map (function).
define-modifier (function).
get-keymap (function).
key (structure).
key-code (reader).
(setf key-code) (writer).
key-modifiers (reader).
(setf key-modifiers) (writer).
key-status (reader).
(setf key-status) (writer).
key-value (reader).
(setf key-value) (writer).
key= (function).
keymap (class).
keymap->map (function).
keymap-p (function).
keymap-with-parents->map (function).
keys->keyspecs (function).
keyscheme (class).
keyscheme-map (type).
keyscheme-map-p (function).
keyscheme-p (function).
lookup-key (function).
make-key (function).
make-keymap (function).
make-keyscheme (function).
make-keyscheme-map (function).
modifier= (function).
modifiers (generic reader).
(setf modifiers) (generic writer).
name (generic reader).
(setf name) (generic writer).
parents (generic reader).
(setf parents) (generic writer).
pretty-binding-keys (function).
%copy-key (function).
%make-key (function).
*default-bound-type* (special variable).
*modifier-list* (special variable).
bind-key (function).
binding-keys* (function).
copy-keymap (function).
copy-keyscheme-map (function).
copy-modifier (function).
entries (generic reader).
(setf entries) (generic writer).
key->keyspec (function).
key-p (function).
key-status-type (type).
keymap->map* (function).
keymap-tree->list (function).
keymap-with-parents (function).
keyspec->key (function).
keyspecs->keys (function).
keyspecs-type (type).
legal-modifiers-p (function).
lookup-key* (function).
lookup-keys-in-keymap (function).
make-modifier (function).
modifier (structure).
modifier-list (type).
modifier-p (function).
modifier-shortcut (reader).
(setf modifier-shortcut) (writer).
modifier-string (reader).
(setf modifier-string) (writer).
modspec->modifier (function).
modspecs->modifiers (function).
quoted-symbol-p (function).
string-join (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Whether to print the short form of the modifiers.
Key translator to use in ‘keymap’ objects.
When no binding is found, call this function to
generate new bindings to lookup. The function takes a list of ‘key’ objects and
returns a list of list of keys.
This parameter can be let-bound around ‘lookup-key’ calls.
The key modifier commonly known as ’control’.
The key modifier commonly known as ’hyper’.
The key modifier commonly known as ’alt’, ’option’ or ’meta’.
The key modifier commonly known as ’shift’.
The key modifier commonly known as ’windows’, ’command’ or ’super’.
The CUA keyscheme as popularly used by GTK, Qt, Windows, Cocoa, etc.
The keyscheme parent to all other keyschemes.
The Emacs editor keyscheme.
The VI editor ’insert mode’ keyscheme.
The VI editor ’normal mode’ keyscheme.
We need a compiler macro to check that bindings are valid at compile time.
This is because most Common Lisp implementations are not capable of checking
types that use ‘satisfies’ for non-top-level symbols.
We can verify this with:
(compile nil (lambda () (nkeymaps::define-key keymap "C-x C-f" ’open-file)))
See the ‘define-key’ compiler-macro for why we need one here too.
Return the list of ‘keyspec’s bound to BINDING in KEYMAP-OR-KEYMAPS.
The order of the result is dictated by the order of KEYMAP-OR-KEYMAPS.
As a second value, return an alist of (keyspec keymap) for all the
‘keyspec’s bound to BINDING in KEYMAP.
Comparison against BINDING is done with TEST.
Duplicates and shadowed bindings are removed.
For instance, to list all keymaps that have a binding, call:
(mapcar #’second (nth-value 1 (binding-keys ...)))
Return a new keymap that’s the composition of all given KEYMAPS.
KEYMAPS are composed by order of precedence, first keymap being the one with
highest precedence.
Return a new copy of KEY.
This is useful as a low-level function to translate keys without modifying existing keys.
Bind KEYS to BOUND-VALUE in KEYMAP.
Return KEYMAP.
KEYSPECS is either a ‘keyspecs-type’, or a list of arguments passed to invocations
of ‘make-key’s, or (:REMAP OTHER-VALUE &OPTIONAL OTHER-KEYMAP).
BOUND-VALUE can be anything. If NIL, the binding is removed.
With (:REMAP OTHER-VALUE &OPTIONAL OTHER-KEYMAP), define-key maps the binding of
OTHER-VALUE in OTHER-KEYMAP (default to KEYMAP) to BOUND-VALUE.
In other words, it remaps OTHER-VALUE to VALUE.
Examples:
(define-key foo-map "C-x C-f" ’open-file)
(define-key foo-map
"C-x C-f" ’open-file
"C-h k" ’describe-key)
"C-M-1 x" on a QWERTY:
(define-key foo-map ’((:code 10 :modifiers ("C" "M") (:value "x"))) ’open-file)
or the shorter:
(define-key foo-map "C-M-#1" ’open-file)
Remapping keys:
(define-key foo-map ’(:remap foo-a) ’foo-value)
(define-key foo-map ‘(:remap foo-a ,bar-map) ’new-value)
Return a keyscheme-map, a hash table with ‘keyscheme’s as key and ‘keymap’s
holding BINDINGS as value.
The keymap names are prefixed with NAME-PREFIX and suffixed with "-map".
OPTIONS is list of keyword arguments.
For now the only supported option is IMPORT.
When given a ‘keyscheme-map’ to IMPORT, it is used as initial values for the new
keyscheme-map. The content is copied. Further alteration to the imported
keyscheme-map won’t reflect on this newly define keyscheme-map.
This is a macro like ‘define-key’ so that it can type-check the BINDINGS
keyspecs at compile-time.
Example:
(define-keyscheme-map "my-mode" ’()
nkeymaps/keyscheme:cua (list
"C-c" ’copy
"C-v" ’paste)
nkeymaps/keyscheme:emacs ’("M-w" copy
"M-y" paste))
‘nkeymaps/keyscheme:cua’ and ‘nkeymaps/keyscheme:emacs’ are pre-defined keyschemes.
To define a new keyscheme, see ‘make-keyscheme’.
‘nkeymaps/keyscheme:cua’ is a parent of ‘nkeymaps/keyscheme:emacs’; thus, in the
above example, the Emacs keymap will have the CUA keymap as parent.
The keyscheme-map keymaps are named "my-mode-cua-map" and
"my-mode-emacs-map".
Return a new modifier.
It is registered globally and can be used from any new keymap, unless the keymap
filters out the modifier in its ‘modifiers’ slot.
Return keymap corresponding to KEYSCHEME in KEYSCHEME-MAP.
If no keymap is found, try with KEYSCHEME’s ‘parents’.
For instance, if KEYSCHEME has a ‘nkeymaps/keyscheme:cua’ keymap and no
‘nkeymaps/keyscheme:emacs’ keymap, this function returns the
‘nkeymaps/keyscheme:cua’ keymap when NAME is ‘nkeymaps/keyscheme:emacs’.
Return nil if nothing is found.
Two keys are equal if the have the same modifiers, status and key code.
If codes don’t match, the values are compared instead. This way, code-matching
keys match before the value which is usually what the users want when they
specify a key-code binding.
Return a hash-table of (KEYSPEC BOUND-VALUE) from KEYMAP.
Parent bindings are not listed; see ‘keymap-with-parents->map’ instead.
This is convenient if the caller wants to list all the bindings.
When multiple keymaps are provided, return the union of the ‘fset:map’ of each arguments.
Keymaps are ordered by precedence, highest precedence comes first.
Return non-nil if OBJECT is a ‘keymap’.
List bindings in KEYMAP and all its parents. See ‘keymap->map’.
Return the keyspecs (a list of ‘keyspec’) for KEYS. See ‘key->keyspec’ for the details.
Return non-nil if OBJECT is a ‘keyscheme-map’.
Return non-nil if OBJECT is a ‘keyscheme’.
Return the value bound to KEYS-OR-KEYSPECS in KEYMAP-OR-KEYMAPS.
As a second value, return the matching keymap.
As a third value, return the possibly translated KEYS.
Return NIL if no value is found.
The successive keymaps from KEYMAP-OR-KEYMAPS (if a list) are looked up one
after the other.
If no binding is found, the direct parents are looked up in the same order.
And so on if the binding is still not found.
Return new ‘key’.
Modifiers can be either a list of ‘modifier’ types or of strings that will be
looked up in ‘*modifier-list*’.
Return a new ‘keymap’.
Return a new ‘keyscheme’ object.
The scheme name inherits from the optional PARENTS, ordered by priority.
Example:
(defvar emacs (make-keyscheme "emacs" cua))
In the above, we define a new scheme name called ‘emacs‘ which inherits from the existing keyscheme ‘cua‘.
Return a new scheme associating KEYSCHEME to KEYMAP.
With MORE-KEYSCHEME+KEYMAP-PAIRS, include those names and keymaps as well. This is
useful in complement to ‘define-keyscheme-map’ to make a scheme with pre-existing
keymaps.
Return non-nil if STRING-OR-MODIFIER1 and STRING-OR-MODIFIER2 represent the same modifier.
Print the binding keys in a pretty manner.
This violates the keyspec <-> key functional relationship, and should not be used for anything but rendering to the user.
keyscheme)) ¶keyscheme)) ¶Type of the bound-value.
The type is enforced in ‘define-keyscheme-map’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
keymap)) ¶keymap)) ¶Type of the bound-value.
The type is enforced in ‘define-key’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
key) (y key)) ¶Needed to use the KEY structure as keys in Fset maps.
Would we use the default comparison function, case-sensitivity would be lost on
key values because ‘fset:equal?’ folds case.
fset.
modifier) (y modifier)) ¶Modifier sets need this comparison function to be ordered, so that ("C" "M") is the same as ("M" "C").
fset.
Warning raised when trying to derive a key from an illegal keyspec.
warning.
(quote "illegal keyspec")
:message
(quote (alexandria:required-argument (quote nkeymaps/conditions::error-condition)))
:error-condition
Condition raised when we didn’t get a modifier as expected.
error.
(quote "")
:message
Warning raised when keymap has cycles.
This is possible if a bound value is a keymap that occured before.
Warning raised when a keyspec contains multiple occurences of the same modifiers.
warning.
(quote "duplicate modifiers")
:message
(quote (alexandria:required-argument (quote nkeymaps/conditions::modifiers)))
:modifiers
Error raised when a ‘keyspec’ is empty, since, it’s not allowed.
error.
Error raised when modifier is the empty string in a keyspec.
error.
(quote (alexandria:required-argument (quote nkeymaps/conditions::keyspec)))
:keyspec
Error raised when keyspec has no CODE nor VALUE.
error.
(quote (alexandria:required-argument (quote nkeymaps/conditions::keyspec)))
:keyspec
Error raised when ‘nkeymaps::make-key’ is called without CODE or VALUE.
error.
Warning raised overriding an existing binding.
warning.
(quote "key was bound to")
:message
(quote (alexandria:required-argument (quote nkeymaps/conditions::existing-binding-value)))
:existing-binding-value
The fundamental type to represent any input, be it keyboard, mouse or others.
structure-object.
integer
0
string
""
nkeymaps/core::modifier-list
(fset:set)
nkeymaps/core::key-status-type
:pressed
A map of ‘key’ bindings to values.
Values must be of type ‘bound-type’.
The bindings from the parents are inherited, with the children having precedence.
Name of the keymap.
Used for documentation purposes, e.g. referring to a keymap by a well known name.
string
"anonymous"
:name
name.
Hash table of which the keys are key-chords and the values are a symbol or a keymap.
fset:wb-map
(fset:empty-map)
:entries
Type of the bound-value.
The type is enforced in ‘define-key’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
nkeymaps/core::*default-bound-type*
:bound-type
List of parent keymaps.
Parents are ordered by priority, the first parent has highest priority.
(nkeymaps/types:list-of nkeymaps/core:keymap)
:parents
Accepted modifiers for this ‘keymap’.
nkeymaps/core::modifier-list
(fset:convert (quote fset:set) nkeymaps/core::*modifier-list*)
:modifiers
A keyscheme is best understood as a conventional family of bindings.
See ‘nkeymaps/keyscheme:cua’ for an example.
Keyschemes can be associated to ‘keymap’s with ‘keyscheme-map’.
The list of parents. When a scheme is defined, the
keymap parents are automatically set to the keymaps corresponding to the given
keyschemes. See ‘define-keyscheme-map’.
(nkeymaps/types:list-of nkeymaps/core:keyscheme)
(quote nil)
:parents
Type of the bound-value.
The type is enforced in ‘define-keyscheme-map’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
nkeymaps/core::*default-bound-type*
:bound-type
Accepted modifiers for this ‘keyscheme’.
fset:wb-set
(fset:convert (quote fset:set) nkeymaps/core::*modifier-list*)
:modifiers
Default value for the ‘bound-type’ slot of ‘keymap’.
Do not change this, instead create new a ‘keyscheme’ or subclass ‘keymap’.
List of known modifiers.
‘make-key’ and ‘define-key’ raise an error when setting a modifier that is not
in this list.
Recursively bind the KEYS to keymaps starting from KEYMAP.
The last key is bound to BOUND-VALUE.
If BOUND-VALUE is nil, the key is unbound.
If KEYS has modifiers that are not allowed in KEYMAP, do nothing.
Return KEYMAP.
Return a the list of ‘keyspec’s bound to BINDING in KEYMAP. The list is sorted alphabetically to ensure reproducible results. Comparison against BINDING is done with TEST.
Return the keyspec of KEY.
If the key has a code, return it prefixed with ’#’.
The status is not encoded in the keyspec, but this may change in the future.
Return a map of (KEYSPEC SYM) from KEYMAP.
Flatten the KEYMAPS into a list.
It traverses KEYMAPS first, then traverses the each keymap ‘parent’ layer after layer.
Example:
- keymap1 has parents (k1a k1b)
- k1a has parents (k1ap)
- keymap2 has parents (k2a)
Return (keymap1 keymap2 k1a k1b k2a k1ap).
Return the list of keymap and all its parents.
Parse STRING and return a new ‘key’.
STRING must be passed in one of two forms:
MODIFIERS-#<code>
MODIFIERS-<value>
MODIFIERS are hyphen-separated modifiers as per ‘*modifier-list*’.
E.g. control-#1 or control-a.
Note that ’-’ or ’#’ as a last character is supported, e.g. ’control–’ and ’control-#’ are valid.
Parse SPEC and return corresponding list of keys.
Whether KEY’s modifiers are allowed in KEYMAP.
Return non-nil if LIST contains only elements of the given TYPE.
Internal function, see ‘lookup-key’ for the user-facing function.
VISITED is used to detect cycles.
As a second value, return the matching keymap.
Return bound value or keymap for KEYS. Return nil when KEYS is not found in KEYMAP. VISITED is used to detect cycles.
Return the ‘modifier’ corresponding to STRING-OR-MODIFIER.
Return the list of ‘modifier’s corresponding to STRINGS-OR-MODIFIERS.
Adapted from ‘serapeum:string-join’.
bad-keyspec)) ¶bad-keyspec)) ¶override-existing-binding)) ¶override-existing-binding)) ¶empty-modifiers)) ¶empty-modifiers)) ¶empty-value)) ¶empty-value)) ¶bad-keyspec)) ¶bad-keyspec)) ¶bad-modifier)) ¶bad-modifier)) ¶override-existing-binding)) ¶override-existing-binding)) ¶duplicate-modifiers)) ¶duplicate-modifiers)) ¶duplicate-modifiers)) ¶duplicate-modifiers)) ¶| Jump to: | %
(
B C D E F G K L M N P Q S U |
|---|
| Jump to: | %
(
B C D E F G K L M N P Q S U |
|---|
| Jump to: | *
+
B C D E K M N P S V |
|---|
| Jump to: | *
+
B C D E K M N P S V |
|---|
| Jump to: | B C D E F K L M N O P S T |
|---|
| Jump to: | B C D E F K L M N O P S T |
|---|