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
|
;;;"alist.scm", alist functions for Scheme.
;;;Copyright (C) 1992, 1993, 2003 Aubrey Jaffer
;
;Permission to copy this software, to modify it, to redistribute it,
;to distribute modified versions, and to use it for any purpose is
;granted, subject to the following restrictions and understandings.
;
;1. Any copy made of this software must include this copyright notice
;in full.
;
;2. I have made no warranty or representation that the operation of
;this software will be error-free, and I am under no obligation to
;provide any services, by way of maintenance, update, or otherwise.
;
;3. In conjunction with products arising from the use of this
;material, there shall be no use of my name in any advertising,
;promotional, or sales literature without prior written consent in
;each case.
;;@code{(require 'alist)}
;;@ftindex alist
;;
;;Alist functions provide utilities for treating a list of key-value pairs
;;as an associative database. These functions take an equality predicate,
;;@var{pred}, as an argument. This predicate should be repeatable,
;;symmetric, and transitive.
;;
;;Alist functions can be used with a secondary index method such as hash
;;tables for improved performance.
;;@body
;;Returns an @dfn{association function} (like @code{assq}, @code{assv}, or
;;@code{assoc}) corresponding to @var{pred}. The returned function
;;returns a key-value pair whose key is @code{pred}-equal to its first
;;argument or @code{#f} if no key in the alist is @var{pred}-equal to the
;;first argument.
(define (predicate->asso pred)
(cond ((eq? eq? pred) assq)
((eq? = pred) assv)
((eq? eqv? pred) assv)
((eq? char=? pred) assv)
((eq? equal? pred) assoc)
((eq? string=? pred) assoc)
(else (lambda (key alist)
(let l ((al alist))
(cond ((null? al) #f)
((pred key (caar al)) (car al))
(else (l (cdr al)))))))))
;;@body
;;Returns a procedure of 2 arguments, @var{alist} and @var{key}, which
;;returns the value associated with @var{key} in @var{alist} or @code{#f} if
;;@var{key} does not appear in @var{alist}.
(define (alist-inquirer pred)
(let ((assofun (predicate->asso pred)))
(lambda (alist key)
(let ((pair (assofun key alist)))
(and pair (cdr pair))))))
;;@body
;;Returns a procedure of 3 arguments, @var{alist}, @var{key}, and
;;@var{value}, which returns an alist with @var{key} and @var{value}
;;associated. Any previous value associated with @var{key} will be
;;lost. This returned procedure may or may not have side effects on its
;;@var{alist} argument. An example of correct usage is:
;;
;;@lisp
;;(define put (alist-associator string-ci=?))
;;(define alist '())
;;(set! alist (put alist "Foo" 9))
;;@end lisp
(define (alist-associator pred)
(let ((assofun (predicate->asso pred)))
(lambda (alist key val)
(let* ((pair (assofun key alist)))
(cond (pair (set-cdr! pair val)
alist)
(else (cons (cons key val) alist)))))))
;;@body
;;Returns a procedure of 2 arguments, @var{alist} and @var{key}, which
;;returns an alist with an association whose @var{key} is key removed.
;;This returned procedure may or may not have side effects on its
;;@var{alist} argument. An example of correct usage is:
;;
;;@lisp
;;(define rem (alist-remover string-ci=?))
;;(set! alist (rem alist "foo"))
;;@end lisp
(define (alist-remover pred)
(lambda (alist key)
(cond ((null? alist) alist)
((pred key (caar alist)) (cdr alist))
((null? (cdr alist)) alist)
((pred key (caadr alist))
(set-cdr! alist (cddr alist)) alist)
(else
(let l ((al (cdr alist)))
(cond ((null? (cdr al)) alist)
((pred key (caadr al))
(set-cdr! al (cddr al)) alist)
(else (l (cdr al)))))))))
;;@body
;;Returns a new association list formed by mapping @var{proc} over the
;;keys and values of @var{alist}. @var{proc} must be a function of 2
;;arguments which returns the new value part.
(define (alist-map proc alist)
(map (lambda (pair) (cons (car pair) (proc (car pair) (cdr pair))))
alist))
;;@body
;;Applies @var{proc} to each pair of keys and values of @var{alist}.
;;@var{proc} must be a function of 2 arguments. The returned value is
;;unspecified.
(define (alist-for-each proc alist)
(for-each (lambda (pair) (proc (car pair) (cdr pair))) alist))
|
