blob: 381638fda62b09a6ef45090e4e4f3ad235c37f27 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
;;; kv.el --- key/value data structure functions
;; Copyright (C) 2012 Nic Ferrier
;; Author: Nic Ferrier <nferrier@ferrier.me.uk>
;; Keywords: lisp
;; Version: 0.0.1
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; Some routines for working with key/value data structures like
;; hash-tables and alists and plists.
;;; Code:
(eval-when-compile (require 'cl))
(defun kvalist->hash (alist &rest hash-table-args)
(let ((table (apply 'make-hash-table hash-table-args)))
(mapcar
(lambda (pair)
(puthash (car pair) (cdr pair) table))
alist)
table))
(defun kvhash->alist (hash)
(let (store)
(maphash
(lambda (key value)
(setq
store
(append (list (cons key value)) store)))
hash)
store))
(defun kvalist->plist (alist)
"Convert an alist to a plist."
;; Why doesn't elisp provide this?
(loop for pair in alist
append (list
(intern
(concat
":"
(cond
((symbolp (car pair))
(symbol-name (car pair)))
((stringp (car pair))
(car pair)))))
(cdr pair))))
(defun kvalist->keys (alist)
"Get just the keys from the alist."
(mapcar (lambda (pair) (car pair)) alist))
(defun kvalist->values (alist)
"Get just the values from the alist."
(mapcar (lambda (pair) (cdr pair)) alist))
(defun kvdotassoc-fn (expr table func)
"Use the dotted EXPR to access deeply nested data in TABLE.
EXPR is a dot separated expression, either a symbol or a string.
For example:
\"a.b.c\"
or:
'a.b.c
If the EXPR is a symbol then the keys of the alist are also
expected to be symbols.
TABLE is expected to be an alist currently.
FUNC is some sort of `assoc' like function."
(let ((state table)
(parts
(if (symbolp expr)
(mapcar
'intern
(split-string (symbol-name expr) "\\."))
;; Else it's a string
(split-string expr "\\."))))
(catch 'break
(while (listp parts)
(let ((traverse (funcall func (car parts) state)))
(setq parts (cdr parts))
(if parts
(setq state (cdr traverse))
(throw 'break (cdr traverse))))))))
(defun kvdotassoc (expr table)
"Dotted expression handling with `assoc'."
(kvdotassoc-fn expr table 'assoc))
(defun kvdotassq (expr table)
"Dotted expression handling with `assq'."
(kvdotassoc-fn expr table 'assq))
(defalias 'dotassoc 'kvdotassoc)
(defalias 'dotassq 'kvdotassq)
(provide 'kv)
(provide 'dotassoc)
;;; kv.el ends here
|
