The fset Reference Manual

4.1.1 fset/fset.asd

Source

fset.asd.

Parent Component

fset (system).

ASDF Systems

fset.

---

4.1.2 fset/Code/defs.lisp

Source

fset.asd.

Parent Component

code (module).

Packages

• fset-user.
• fset.
• fset2.

---

4.1.3 fset/Code/port.lisp

Dependency

defs.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Internals

• base-char-p (function).
• defglobal (macro).
• define-atomic-series (macro).
• gen (macro).
• increment-atomic-series (macro).
• length-nv (macro).
• make-char (function).
• make-lock (function).
• read-memory-barrier (macro).
• tuple-key-number-mask (constant).
• tuple-key-number-size (constant).
• tuple-value-index-size (constant).
• while (macro).
• with-lock (macro).
• write-memory-barrier (macro).

---

4.1.4 fset/Code/macros.lisp

Dependency

port.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• @ (macro).
• adjoinf (macro).
• appendf (macro).
• compare-slots (macro).
• compare-slots-no-unequal (macro).
• composef (macro).
• define-cross-type-compare-methods (macro).
• do-bag (macro).
• do-bag-pairs (macro).
• do-map (macro).
• do-map-domain (macro).
• do-seq (macro).
• do-set (macro).
• excludef (macro).
• imagef (macro).
• includef (macro).
• intersectf (macro).
• map-intersectf (macro).
• map-unionf (macro).
• pop-first (macro).
• pop-last (macro).
• prependf (macro).
• push-first (macro).
• push-last (macro).
• removef (macro).
• set-differencef (macro).
• unionf (macro).

Internals

• +master-type-ordering+ (symbol macro).
• check-three-arguments (macro).
• check-two-arguments (macro).
• logandc2f (macro).
• logiorf (macro).
• logxorf (macro).
• postincf (macro).
• xconcat (function).
• ximage (function).

---

4.1.5 fset/Code/order.lisp

Dependency

macros.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• bag (structure).
• bag? (function).
• collection (structure).
• collection? (function).
• compare (generic function).
• compare-lexicographically (generic function).
• equal? (function).
• identity-ordering-mixin (class).
• map (structure).
• map-default (reader).
• (setf map-default) (writer).
• map? (function).
• replay-map (structure).
• replay-map? (function).
• replay-set (structure).
• replay-set? (function).
• seq (structure).
• seq? (function).
• set (structure).
• set? (function).
• tuple (structure).
• tuple? (function).

Internals

• +package-original-name+ (symbol macro).
• compare-lists-lexicographically (function).
• compare-strings (function).
• greater-than? (function).
• less-than? (function).
• replay-map-default (function).
• (setf replay-map-default) (function).
• seq-default (reader).
• (setf seq-default) (writer).
• serial-number (reader method).
• (setf serial-number) (writer method).

---

4.1.6 fset/Code/hash.lisp

Dependency

order.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

define-comparison-slots (macro).

Internals

• hash-slots (macro).
• hash-value (generic function).

---

4.1.7 fset/Code/wb-trees.lisp

Dependency

hash.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• print-object (method).
• print-object (method).
• print-object (method).
• print-object (method).

Internals

• *wb-tree-max-string-length* (special variable).
• *wb-tree-max-vector-length* (special variable).
• +wb-tree-max-depths-with-values+ (symbol macro).
• +wb-tree-max-depths-without-values+ (symbol macro).
• bag-value-size (function).
• copy-equivalent-bag (function).
• copy-equivalent-map (function).
• copy-equivalent-set (function).
• copy-wb-bag-tree-node (function).
• copy-wb-map-tree-node (function).
• copy-wb-seq-tree-node (function).
• copy-wb-set-tree-node (function).
• do-wb-bag-tree-pairs (macro).
• do-wb-map-tree-pairs (macro).
• do-wb-seq-tree-members (macro).
• do-wb-seq-tree-members-gen (macro).
• do-wb-set-tree-members (macro).
• equivalent-bag (structure).
• equivalent-bag-alist (reader).
• (setf equivalent-bag-alist) (writer).
• equivalent-bag-compare (function).
• equivalent-bag-difference (function).
• equivalent-bag-intersect (function).
• equivalent-bag-product (function).
• equivalent-bag-subbag? (function).
• equivalent-bag-sum (function).
• equivalent-bag-union (function).
• equivalent-bag? (function).
• equivalent-map (structure).
• equivalent-map-alist (reader).
• (setf equivalent-map-alist) (writer).
• equivalent-map-compare (function).
• equivalent-map-difference (function).
• equivalent-map-intersect (function).
• equivalent-map-less (function).
• equivalent-map-restrict (function).
• equivalent-map-restrict-not (function).
• equivalent-map-union (function).
• equivalent-map-with (function).
• equivalent-map? (function).
• equivalent-set (structure).
• equivalent-set-compare (function).
• equivalent-set-difference (function).
• equivalent-set-disjoint? (function).
• equivalent-set-intersect (function).
• equivalent-set-members (reader).
• (setf equivalent-set-members) (writer).
• equivalent-set-subset? (function).
• equivalent-set-union (function).
• equivalent-set? (function).
• hedge-negative-infinity (constant).
• hedge-positive-infinity (constant).
• make-equivalent-bag (function).
• make-equivalent-map (function).
• make-equivalent-set (function).
• make-raw-wb-bag-tree-node (function).
• make-raw-wb-map-tree-node (function).
• make-raw-wb-seq-tree-node (function).
• make-raw-wb-set-tree-node (function).
• make-wb-bag-tree-iterator (function).
• make-wb-bag-tree-iterator-internal (function).
• make-wb-bag-tree-node (function).
• make-wb-bag-tree-pair-iterator (function).
• make-wb-bag-tree-pair-iterator-internal (function).
• make-wb-map-tree-iterator (function).
• make-wb-map-tree-iterator-internal (function).
• make-wb-map-tree-node (function).
• make-wb-seq-tree-iterator (function).
• make-wb-seq-tree-iterator-internal (function).
• make-wb-seq-tree-node (function).
• make-wb-set-tree-iterator (function).
• make-wb-set-tree-iterator-internal (function).
• make-wb-set-tree-node (function).
• make-wb-tree-iterator (function).
• map-key-size (function).
• set-value-size (function).
• string-insert (function).
• string-remove-at (function).
• string-seq-to-set (function).
• string-subseq (function).
• string-subseq-insert (function).
• string-update (function).
• vector-insert (function).
• vector-insert-from-string (function).
• vector-pair-bag-diff (function).
• vector-pair-bag-intersect (function).
• vector-pair-bag-product (function).
• vector-pair-bag-subbag? (function).
• vector-pair-bag-sum (function).
• vector-pair-bag-union (function).
• vector-pair-diff-2 (function).
• vector-pair-intersect (function).
• vector-pair-restrict (function).
• vector-pair-restrict-not (function).
• vector-pair-union (function).
• vector-remove-at (function).
• vector-seq-to-set (function).
• vector-set-binary-search (function).
• vector-set-binary-search-cfn (function).
• vector-set-binary-search-hi (function).
• vector-set-binary-search-lo (function).
• vector-set-diff (function).
• vector-set-diff-2 (function).
• vector-set-disjoint? (function).
• vector-set-intersect (function).
• vector-set-subset? (function).
• vector-set-union (function).
• vector-subseq (function).
• vector-subseq-insert (function).
• vector-update (function).
• vector-update-from-string (function).
• wb-bag-tree (type).
• wb-bag-tree-arb-pair (function).
• wb-bag-tree-build-node (function).
• wb-bag-tree-compare (function).
• wb-bag-tree-compare-rng (function).
• wb-bag-tree-concat (function).
• wb-bag-tree-diff (function).
• wb-bag-tree-diff-rng (function).
• wb-bag-tree-find-equivalent (function).
• wb-bag-tree-from-list (function).
• wb-bag-tree-greatest-pair (function).
• wb-bag-tree-intersect (function).
• wb-bag-tree-intersect-rng (function).
• wb-bag-tree-iterator-canonicalize (function).
• wb-bag-tree-iterator-done? (function).
• wb-bag-tree-iterator-get (function).
• wb-bag-tree-join (function).
• wb-bag-tree-least-pair (function).
• wb-bag-tree-less (function).
• wb-bag-tree-less-minimum (function).
• wb-bag-tree-minimum-pair (function).
• wb-bag-tree-multiplicity (function).
• wb-bag-tree-node (structure).
• wb-bag-tree-node-count (reader).
• (setf wb-bag-tree-node-count) (writer).
• wb-bag-tree-node-left (reader).
• (setf wb-bag-tree-node-left) (writer).
• wb-bag-tree-node-print (function).
• wb-bag-tree-node-right (reader).
• (setf wb-bag-tree-node-right) (writer).
• wb-bag-tree-node-size (reader).
• (setf wb-bag-tree-node-size) (writer).
• wb-bag-tree-node-total-count (reader).
• (setf wb-bag-tree-node-total-count) (writer).
• wb-bag-tree-node-value (reader).
• (setf wb-bag-tree-node-value) (writer).
• wb-bag-tree-node? (function).
• wb-bag-tree-pair-iterator-canonicalize (function).
• wb-bag-tree-pair-iterator-done? (function).
• wb-bag-tree-pair-iterator-get (function).
• wb-bag-tree-product (function).
• wb-bag-tree-product-rng (function).
• wb-bag-tree-rank (function).
• wb-bag-tree-rank-pair (function).
• wb-bag-tree-rank-pair-internal (function).
• wb-bag-tree-rank-trim (function).
• wb-bag-tree-size (function).
• wb-bag-tree-split (function).
• wb-bag-tree-subbag? (function).
• wb-bag-tree-subbag?-rng (function).
• wb-bag-tree-sum (function).
• wb-bag-tree-sum-rng (function).
• wb-bag-tree-to-set-tree (function).
• wb-bag-tree-total-count (function).
• wb-bag-tree-trim (function).
• wb-bag-tree-union (function).
• wb-bag-tree-union-rng (function).
• wb-bag-tree-vector-pair-sum (function).
• wb-bag-tree-vector-pair-union (function).
• wb-bag-tree-verify (function).
• wb-bag-tree-verify-rng (function).
• wb-bag-tree-with (function).
• wb-map-tree (type).
• wb-map-tree-arb-pair (function).
• wb-map-tree-build-node (function).
• wb-map-tree-compare (function).
• wb-map-tree-compare-rng (function).
• wb-map-tree-compose (function).
• wb-map-tree-concat (function).
• wb-map-tree-concat-maybe (function).
• wb-map-tree-diff-2 (function).
• wb-map-tree-diff-2-rng (function).
• wb-map-tree-domain (function).
• wb-map-tree-find-equivalent (function).
• wb-map-tree-greatest-pair (function).
• wb-map-tree-intersect (function).
• wb-map-tree-intersect-rng (function).
• wb-map-tree-iterator-canonicalize (function).
• wb-map-tree-iterator-done? (function).
• wb-map-tree-iterator-get (function).
• wb-map-tree-join (function).
• wb-map-tree-least-pair (function).
• wb-map-tree-less (function).
• wb-map-tree-less-minimum (function).
• wb-map-tree-lookup (function).
• wb-map-tree-minimum-pair (function).
• wb-map-tree-node (structure).
• wb-map-tree-node-key (reader).
• (setf wb-map-tree-node-key) (writer).
• wb-map-tree-node-left (reader).
• (setf wb-map-tree-node-left) (writer).
• wb-map-tree-node-print (function).
• wb-map-tree-node-right (reader).
• (setf wb-map-tree-node-right) (writer).
• wb-map-tree-node-size (reader).
• (setf wb-map-tree-node-size) (writer).
• wb-map-tree-node-value (reader).
• (setf wb-map-tree-node-value) (writer).
• wb-map-tree-node? (function).
• wb-map-tree-rank (function).
• wb-map-tree-rank-pair (function).
• wb-map-tree-rank-pair-internal (function).
• wb-map-tree-rank-trim (function).
• wb-map-tree-restrict (function).
• wb-map-tree-restrict-not (function).
• wb-map-tree-restrict-not-rng (function).
• wb-map-tree-restrict-rng (function).
• wb-map-tree-size (function).
• wb-map-tree-split (function).
• wb-map-tree-trim (function).
• wb-map-tree-union (function).
• wb-map-tree-union-rng (function).
• wb-map-tree-vector-pair-union (function).
• wb-map-tree-verify (function).
• wb-map-tree-verify-rng (function).
• wb-map-tree-with (function).
• wb-seq-tree (type).
• wb-seq-tree-append (function).
• wb-seq-tree-build-node (function).
• wb-seq-tree-compare (function).
• wb-seq-tree-compare-lexicographically (function).
• wb-seq-tree-compare-rng (function).
• wb-seq-tree-concat (function).
• wb-seq-tree-from-list (function).
• wb-seq-tree-from-vector (function).
• wb-seq-tree-insert (function).
• wb-seq-tree-iterator-canonicalize (function).
• wb-seq-tree-iterator-done? (function).
• wb-seq-tree-iterator-get (function).
• wb-seq-tree-node (structure).
• wb-seq-tree-node-left (reader).
• (setf wb-seq-tree-node-left) (writer).
• wb-seq-tree-node-print (function).
• wb-seq-tree-node-right (reader).
• (setf wb-seq-tree-node-right) (writer).
• wb-seq-tree-node-size (reader).
• (setf wb-seq-tree-node-size) (writer).
• wb-seq-tree-node? (function).
• wb-seq-tree-remove (function).
• wb-seq-tree-reverse (function).
• wb-seq-tree-size (function).
• wb-seq-tree-subscript (function).
• wb-seq-tree-subseq (function).
• wb-seq-tree-to-list (function).
• wb-seq-tree-to-set-tree (function).
• wb-seq-tree-to-string (function).
• wb-seq-tree-to-vector (function).
• wb-seq-tree-trim (function).
• wb-seq-tree-verify (function).
• wb-seq-tree-with (function).
• wb-set-tree (type).
• wb-set-tree-arb (function).
• wb-set-tree-build-node (function).
• wb-set-tree-compare (function).
• wb-set-tree-compare-rng (function).
• wb-set-tree-concat (function).
• wb-set-tree-diff (function).
• wb-set-tree-diff-2 (function).
• wb-set-tree-diff-2-rng (function).
• wb-set-tree-diff-rng (function).
• wb-set-tree-disjoint? (function).
• wb-set-tree-disjoint?-rng (function).
• wb-set-tree-find-equal (function).
• wb-set-tree-find-equivalent (function).
• wb-set-tree-find-rank (function).
• wb-set-tree-from-cl-sequence (function).
• wb-set-tree-from-list (function).
• wb-set-tree-greatest (function).
• wb-set-tree-intersect (function).
• wb-set-tree-intersect-rng (function).
• wb-set-tree-iterator-canonicalize (function).
• wb-set-tree-iterator-done? (function).
• wb-set-tree-iterator-get (function).
• wb-set-tree-join (function).
• wb-set-tree-least (function).
• wb-set-tree-less (function).
• wb-set-tree-less-minimum (function).
• wb-set-tree-member? (function).
• wb-set-tree-member?-cfn (function).
• wb-set-tree-minimum-value (function).
• wb-set-tree-node (structure).
• wb-set-tree-node-left (reader).
• (setf wb-set-tree-node-left) (writer).
• wb-set-tree-node-print (function).
• wb-set-tree-node-right (reader).
• (setf wb-set-tree-node-right) (writer).
• wb-set-tree-node-size (reader).
• (setf wb-set-tree-node-size) (writer).
• wb-set-tree-node-value (reader).
• (setf wb-set-tree-node-value) (writer).
• wb-set-tree-node? (function).
• wb-set-tree-rank (function).
• wb-set-tree-rank-element (function).
• wb-set-tree-rank-element-internal (function).
• wb-set-tree-rank-trim (function).
• wb-set-tree-size (function).
• wb-set-tree-split (function).
• wb-set-tree-split-above (function).
• wb-set-tree-split-below (function).
• wb-set-tree-subset? (function).
• wb-set-tree-subset?-rng (function).
• wb-set-tree-to-bag-tree (function).
• wb-set-tree-trim (function).
• wb-set-tree-union (function).
• wb-set-tree-union-rng (function).
• wb-set-tree-vector-union (function).
• wb-set-tree-verify (function).
• wb-set-tree-verify-rng (function).
• wb-set-tree-with (function).
• wb-tree-balance-factor (constant).
• wb-tree-max-depth (function).
• wb-tree-precomputed-max-depths (constant).
• wb-tree-true-max-depth (function).

---

4.1.8 fset/Code/champ.lisp

Dependency

wb-trees.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Internals

• bit-indices (function).
• ch-map-node-entry-mask (function).
• (setf ch-map-node-entry-mask) (function).
• ch-map-node-hash-value (function).
• (setf ch-map-node-hash-value) (function).
• ch-map-node-header-size (constant).
• ch-map-node-size (function).
• (setf ch-map-node-size) (function).
• ch-map-node-subnode-mask (function).
• (setf ch-map-node-subnode-mask) (function).
• ch-map-tree-hash-value (function).
• ch-map-tree-less (function).
• ch-map-tree-lookup (function).
• ch-map-tree-size (function).
• ch-map-tree-verify (function).
• ch-map-tree-with (function).
• ch-set-node-entry-mask (function).
• (setf ch-set-node-entry-mask) (function).
• ch-set-node-hash-value (function).
• (setf ch-set-node-hash-value) (function).
• ch-set-node-header-size (constant).
• ch-set-node-size (function).
• (setf ch-set-node-size) (function).
• ch-set-node-subnode-mask (function).
• (setf ch-set-node-subnode-mask) (function).
• ch-set-tree-arb (function).
• ch-set-tree-compare (function).
• ch-set-tree-contains? (function).
• ch-set-tree-disjoint? (function).
• ch-set-tree-hash-value (function).
• ch-set-tree-index-element (function).
• ch-set-tree-intersection (function).
• ch-set-tree-less (function).
• ch-set-tree-size (function).
• ch-set-tree-union (function).
• ch-set-tree-verify (function).
• ch-set-tree-with (function).
• champ-hash-bits-per-level (constant).
• champ-hash-level-mask (constant).
• champ-node-radix (constant).
• do-bit-indices (macro).
• do-ch-map-tree-pairs (macro).
• do-ch-set-tree-members (macro).
• hash-value-fixnum (function).
• make-ch-map-node (function).
• make-ch-set-node (function).
• vector-ins-1-rem-1 (function).
• vector-ins-2-rem-1 (function).
• vector-insert-2 (function).
• vector-rem-1-ins-1 (function).
• vector-rem-2-ins-1 (function).
• vector-remove-2-at (function).
• vector-remove-n-at (function).

---

4.1.9 fset/Code/reader.lisp

Dependency

champ.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• *fset-readtable* (special variable).
• bag (macro).
• ch-map (macro).
• ch-set (macro).
• dyn-tuple (macro).
• fset-setup-readtable (function).
• map (macro).
• replay-map (macro).
• replay-set (macro).
• seq (macro).
• set (macro).
• tuple (macro).
• wb-bag (macro).
• wb-map (macro).
• wb-replay-map (macro).
• wb-replay-set (macro).
• wb-seq (macro).
• wb-set (macro).

Internals

• #$-reader (function).
• #%-reader (function).
• #[-reader (function).
• #{-reader (function).
• #~-reader (function).
• *fset-rereading-readtable* (special variable).
• expand-bag-constructor-form (function).
• expand-map-constructor-form (function).
• expand-seq-constructor-form (function).
• expand-set-constructor-form (function).
• expand-tuple-constructor-form (function).
• fset-setup-rereading-readtable (function).
• rereading-#[-reader (function).
• rereading-#{-reader (function).
• rereading-#~-reader (function).

---

4.1.10 fset/Code/fset.lisp

Dependency

reader.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• (setf @) (setf expander).
• arb (generic function).
• at-index (method).
• at-rank (generic function).
• bag-difference (generic function).
• bag-product (generic function).
• bag-sum (generic function).
• ch-map (structure).
• ch-set (structure).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare-lexicographically (method).
• compose (generic function).
• concat (generic function).
• contains? (generic function).
• convert (generic function).
• count (generic function).
• count-if (generic function).
• count-if-not (generic function).
• disjoint? (generic function).
• domain (generic function).
• domain-contains? (generic function).
• empty-bag (function).
• empty-ch-map (function).
• empty-ch-set (function).
• empty-map (function).
• empty-seq (function).
• empty-set (function).
• empty-wb-bag (function).
• empty-wb-map (function).
• empty-wb-seq (function).
• empty-wb-set (function).
• empty? (generic function).
• every (function).
• filter (generic function).
• filter-pairs (generic function).
• find (generic function).
• find-if (generic function).
• find-if-not (generic function).
• first (generic function).
• greatest (generic function).
• head (function).
• image (generic function).
• insert (generic function).
• intersection (generic function).
• iterator (generic function).
• last (generic function).
• lastcons (function).
• least (generic function).
• less (generic function).
• less-first (generic function).
• less-last (generic function).
• (setf lookup) (setf expander).
• lookup (generic function).
• make-load-form (method).
• make-load-form (method).
• make-load-form (method).
• make-load-form (method).
• make-load-form (method).
• map-difference-2 (generic function).
• map-intersection (generic function).
• map-union (generic function).
• member? (function).
• multiplicity (generic function).
• nonempty? (function).
• notany (function).
• notevery (function).
• partition (generic function).
• position (generic function).
• position-if (generic function).
• position-if-not (generic function).
• print-object (method).
• print-object (method).
• print-object (method).
• print-object (method).
• print-object (method).
• print-object (method).
• proper-subbag? (function).
• proper-subset? (function).
• range (generic function).
• range-contains? (generic function).
• rank (generic function).
• reduce (generic function).
• remove (generic function).
• remove-if (generic function).
• remove-if-not (generic function).
• restrict (generic function).
• restrict-not (generic function).
• reverse (generic function).
• set-difference (generic function).
• set-difference-2 (generic function).
• set-size (generic function).
• size (generic function).
• some (function).
• sort (generic function).
• sort-and-group (generic function).
• splice (generic function).
• split-above (method).
• split-below (method).
• split-from (method).
• split-through (method).
• stable-sort (generic function).
• subbag? (generic function).
• subseq (generic function).
• subset? (generic function).
• substitute (generic function).
• substitute-if (generic function).
• substitute-if-not (generic function).
• tail (function).
• union (generic function).
• update (compiler macro).
• update (function).
• wb-bag (structure).
• wb-map (structure).
• wb-seq (structure).
• wb-set (structure).
• with (generic function).
• with-default (generic function).
• with-first (generic function).
• with-last (generic function).

Internals

• *empty-ch-map* (special variable).
• *empty-ch-set* (special variable).
• *empty-wb-bag* (special variable).
• *empty-wb-map* (special variable).
• *empty-wb-seq* (special variable).
• *empty-wb-set* (special variable).
• bag-filter (function).
• bag-filter-pairs (function).
• bag-from-list (function).
• bag-image (function).
• bag-reduce (function).
• ch-map-contents (reader).
• (setf ch-map-contents) (writer).
• ch-map-default (function).
• (setf ch-map-default) (function).
• ch-map? (function).
• ch-set-contents (reader).
• (setf ch-set-contents) (writer).
• ch-set-filter (function).
• ch-set-image (function).
• ch-set? (function).
• coerce-to-function (function).
• coerce-to-function-or-equal? (function).
• default (generic function).
• empty-instance-form (method).
• empty-instance-form (method).
• empty-instance-form (method).
• empty-instance-form (method).
• empty-instance-form (method).
• empty-instance-form (method).
• empty-instance-form (method).
• empty-map-instance-form (method).
• empty-map-instance-form (method).
• empty-map-instance-form (method).
• internal-do-bag-pairs (generic function).
• internal-do-map (generic function).
• internal-do-seq (generic function).
• internal-do-set (generic function).
• list-partition (function).
• make-ch-map (function).
• make-ch-set (function).
• make-wb-bag (function).
• make-wb-map (function).
• make-wb-seq (function).
• make-wb-set (function).
• map-fn-compose (function).
• map-reduce (function).
• print-ch-map (function).
• print-ch-set (function).
• print-wb-bag (function).
• print-wb-map (function).
• print-wb-seq (function).
• print-wb-set (function).
• seq-filter (function).
• seq-image (function).
• seq-partition (function).
• seq-reduce (function).
• set-reduce (function).
• simple-program-error (condition).
• split (function).
• wb-bag-contents (reader).
• (setf wb-bag-contents) (writer).
• wb-bag? (function).
• wb-map-contents (reader).
• (setf wb-map-contents) (writer).
• wb-map-default (function).
• (setf wb-map-default) (function).
• wb-map-filter (function).
• wb-map-from-cl-sequence (function).
• wb-map-from-list (function).
• wb-map-image (function).
• wb-map? (function).
• wb-seq-contents (reader).
• (setf wb-seq-contents) (writer).
• wb-seq-default (function).
• (setf wb-seq-default) (function).
• wb-seq? (function).
• wb-set-contents (reader).
• (setf wb-set-contents) (writer).
• wb-set-filter (function).
• wb-set-image (function).
• wb-set-partition (function).
• wb-set? (function).

---

4.1.11 fset/Code/replay.lisp

Dependency

fset.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• arb (method).
• arb (method).
• compare (method).
• contains? (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• domain (method).
• domain-contains? (method).
• empty-replay-map (function).
• empty-replay-set (function).
• empty-wb-replay-map (function).
• empty-wb-replay-set (function).
• empty? (method).
• empty? (method).
• intersection (method).
• iterator (method).
• iterator (method).
• less (method).
• less (method).
• lookup (method).
• lookup (method).
• print-object (method).
• print-object (method).
• size (method).
• size (method).
• union (method).
• wb-replay-map (structure).
• wb-replay-map? (function).
• wb-replay-set (structure).
• wb-replay-set? (function).
• with (method).
• with (method).
• with-default (method).

Internals

• *empty-wb-replay-map* (special variable).
• *empty-wb-replay-set* (special variable).
• empty-instance-form (method).
• empty-map-instance-form (method).
• empty-map-instance-form (method).
• internal-do-map (method).
• internal-do-set (method).
• make-wb-replay-map (function).
• make-wb-replay-set (function).
• print-wb-replay-map (function).
• print-wb-replay-set (function).
• wb-replay-map-contents (reader).
• (setf wb-replay-map-contents) (writer).
• wb-replay-map-default (function).
• (setf wb-replay-map-default) (function).
• wb-replay-map-ordering (reader).
• (setf wb-replay-map-ordering) (writer).
• wb-replay-set-contents (reader).
• (setf wb-replay-set-contents) (writer).
• wb-replay-set-ordering (reader).
• (setf wb-replay-set-ordering) (writer).

---

4.1.12 fset/Code/tuples.lisp

Dependency

replay.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• compare (method).
• compare (method).
• compare (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• def-tuple-key (macro).
• define-tuple-key (macro).
• do-tuple (macro).
• domain (method).
• dyn-tuple (structure).
• empty-dyn-tuple (function).
• empty-tuple (function).
• get-tuple-key (function).
• image (method).
• image (method).
• lookup (method).
• make-load-form (method).
• print-object (method).
• print-object (method).
• restrict (method).
• restrict-not (method).
• size (method).
• tuple-key-name (reader).
• (setf tuple-key-name) (writer).
• tuple-key? (function).
• tuple-merge (generic function).
• with (method).

Internals

• +tuple-desc-next-serial-number+ (symbol macro).
• +tuple-desc-next-serial-number-lock+ (symbol macro).
• +tuple-descriptor-map+ (symbol macro).
• +tuple-key-lock+ (symbol macro).
• +tuple-key-name-map+ (symbol macro).
• +tuple-key-seq+ (symbol macro).
• +tuple-random-value+ (symbol macro).
• copy-tuple-desc (function).
• copy-tuple-key (function).
• do-tuple-internal (macro).
• dyn-tuple-contents (reader).
• (setf dyn-tuple-contents) (writer).
• dyn-tuple-descriptor (reader).
• (setf dyn-tuple-descriptor) (writer).
• dyn-tuple-from-list (function).
• dyn-tuple? (function).
• internal-do-tuple (generic function).
• make-dyn-tuple (function).
• make-tuple-desc (function).
• make-tuple-desc-internal (function).
• make-tuple-key (function).
• print-dyn-tuple (function).
• print-tuple-key (function).
• tuple-contents-ref (macro).
• tuple-desc (structure).
• tuple-desc-key-set (reader).
• (setf tuple-desc-key-set) (writer).
• tuple-desc-lock (reader).
• (setf tuple-desc-lock) (writer).
• tuple-desc-next-desc-map (reader).
• (setf tuple-desc-next-desc-map) (writer).
• tuple-desc-p (function).
• tuple-desc-pairs (reader).
• (setf tuple-desc-pairs) (writer).
• tuple-desc-reorder-map-map (reader).
• (setf tuple-desc-reorder-map-map) (writer).
• tuple-desc-serial-number (reader).
• (setf tuple-desc-serial-number) (writer).
• tuple-get-reorder-map (function).
• tuple-key (structure).
• tuple-key-default-fn (reader).
• (setf tuple-key-default-fn) (writer).
• tuple-key-number (reader).
• (setf tuple-key-number) (writer).
• tuple-lookup (function).
• tuple-make-reorder-map (function).
• tuple-random-value (function).
• tuple-reorder-frequency (constant).
• tuple-reorder-keys (function).
• tuple-reorder-score-threshold (special variable).
• tuple-value-chunk-bits (constant).
• tuple-value-chunk-size (constant).
• tuple-window-size (macro).
• tuple-with (function).

---

4.1.13 fset/Code/testing.lisp

Dependency

tuples.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• adjust-sequence (method).
• compare (method).
• (setf elt) (method).
• elt (method).
• length (method).
• make-sequence-like (method).

Internals

• *champ-map-test-pairs* (special variable).
• *champ-set-test-values* (special variable).
• +k0+ (symbol macro).
• +k1+ (symbol macro).
• +k2+ (symbol macro).
• +k3+ (symbol macro).
• +k4+ (symbol macro).
• add-to-front (function).
• alist-assign (function).
• alist-bag-combine (function).
• alist-bag-difference (function).
• alist-bag-intersection (function).
• alist-bag-product (function).
• alist-bag-remove (function).
• alist-bag-size (function).
• alist-bag-sum (function).
• alist-bag-union (function).
• alist-remove (function).
• copy-my-integer (function).
• eqv (function).
• hash-value (method).
• list-insert (function).
• list-remove (function).
• list-set-elt (function).
• make-my-integer (function).
• map-compare (function).
• map-sort-and-group (function).
• my-identity-ordered-obj (class).
• my-identity-ordered-obj-value (reader method).
• (setf my-identity-ordered-obj-value) (writer method).
• my-integer (structure).
• my-integer-p (function).
• my-integer-value (reader).
• (setf my-integer-value) (writer).
• my-sequence (class).
• my-sequence-actual (reader method).
• (setf my-sequence-actual) (writer method).
• my-unhandled-obj (class).
• my-unhandled-obj-value (reader method).
• (setf my-unhandled-obj-value) (writer method).
• pick (function).
• random-test (function).
• run-test-suite (function).
• seq-compare (function).
• seq-position (function).
• set-compare (function).
• test-2-relations (function).
• test-bag-operations (function).
• test-bounded-sets (function).
• test-champ-maps (function).
• test-champ-sets (function).
• test-cl-generic-sequence-ops (function).
• test-compare-lexicographically (function).
• test-complement-sets (function).
• test-equivalent-sets (function).
• test-functional-deep-update (function).
• test-list-relations (function).
• test-map-operations (function).
• test-misc-0 (function).
• test-misc-1 (function).
• test-misc-2 (function).
• test-misc-3 (function).
• test-modify-macros (function).
• test-reader (function).
• test-rereader (function).
• test-seq-operations (function).
• test-set-operations (function).
• test-tuple-operations (function).
• test-type-dispatch-speed (function).
• time-index (function).
• time-seq-iter (function).
• tuple-keys (symbol macro).
• verify (generic function).

---

4.1.14 fset/Code/interval.lisp

Dependency

testing.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• compare (method).
• compare (method).
• compare (method).
• empty? (method).
• intersection (method).
• less (method).
• print-object (method).
• print-object (method).
• set-difference (method).
• size (method).
• union (method).
• with (method).

Internals

• compare-intervals (function).
• empty-interval-set (function).
• interval (structure).
• interval-kind (reader).
• (setf interval-kind) (writer).
• interval-kind-symbol (function).
• interval-lower (reader).
• (setf interval-lower) (writer).
• interval-lower-closed? (function).
• interval-set (structure).
• interval-set-contents (reader).
• (setf interval-set-contents) (writer).
• interval-set? (function).
• interval-upper (reader).
• (setf interval-upper) (writer).
• interval-upper-closed? (function).
• interval? (function).
• less-interval (generic function).
• make-interval (function).
• make-interval-set (function).
• make-raw-interval (function).
• print-interval (function).
• print-interval-set (function).
• with-interval (generic function).

---

4.1.15 fset/Code/relations.lisp

Dependency

interval.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• 2-relation (macro).
• 2-relation (structure).
• 2-relation? (function).
• all-queries (method).
• arb (method).
• arb (method).
• arity (generic function).
• assertion-db (structure).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compare (method).
• compose (method).
• compose (method).
• compose (method).
• compose (method).
• compose (method).
• conflicts (generic function).
• contains? (method).
• contains? (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• convert (method).
• do-2-relation (macro).
• do-all-queries (macro).
• do-list-relation (macro).
• domain (method).
• empty-2-relation (function).
• empty-assertion-db (function).
• empty-list-relation (function).
• empty-query-registry (function).
• empty-wb-2-relation (function).
• empty-wb-assertion-db (function).
• empty-wb-list-relation (function).
• empty? (method).
• empty? (method).
• greatest (method).
• intersection (method).
• inverse (generic function).
• iterator (method).
• join (generic function).
• least (method).
• less (method).
• less (method).
• less (method).
• less (method).
• list-relation (structure).
• list-relation? (function).
• lookup (method).
• lookup (method).
• lookup-inv (generic function).
• lookup-multi (method).
• print-object (method).
• print-object (method).
• print-object (method).
• query (generic function).
• query-multi (generic function).
• query-multi-restricted (generic function).
• query-registry (structure).
• range (method).
• relation (structure).
• relation? (function).
• size (method).
• size (method).
• union (method).
• wb-2-relation (macro).
• wb-2-relation (structure).
• wb-2-relation? (function).
• wb-list-relation (structure).
• wb-list-relation? (function).
• with (method).
• with (method).
• with (method).
• with (method).

Internals

• *empty-wb-2-relation* (special variable).
• 2-relation-fn-compose (function).
• 2-relation-to-wb-map (function).
• assertion-db? (function).
• copy-query-registry (function).
• expand-2-relation-constructor-form (function).
• get-indices (method).
• get-inverse (function).
• internal-do-2-relation (generic function).
• internal-do-all-queries (method).
• internal-do-list-relation (generic function).
• list-to-wb-2-relation (function).
• make-query-registry (function).
• make-wb-2-relation (function).
• make-wb-assertion-db (function).
• make-wb-list-relation (function).
• map-to-sets-to-wb-2-relation (function).
• map-to-wb-2-relation (function).
• masked-tuple (function).
• pattern-mask (function).
• prepare-pattern (function).
• print-wb-2-relation (function).
• print-wb-assertion-db (function).
• print-wb-list-relation (function).
• query-registry-list-relations (reader).
• (setf query-registry-list-relations) (writer).
• query-registry-p (function).
• reduced-tuple (function).
• set-transitive-closure (function).
• transitive-closure (generic function).
• verify (method).
• wb-2-relation-map0 (reader).
• (setf wb-2-relation-map0) (writer).
• wb-2-relation-map1 (reader).
• (setf wb-2-relation-map1) (writer).
• wb-2-relation-size (reader).
• (setf wb-2-relation-size) (writer).
• wb-assertion-db (structure).
• wb-assertion-db-list-rels (reader).
• (setf wb-assertion-db-list-rels) (writer).
• wb-assertion-db? (function).
• wb-list-relation-arity (reader).
• (setf wb-list-relation-arity) (writer).
• wb-list-relation-indices (reader).
• (setf wb-list-relation-indices) (writer).
• wb-list-relation-tuples (reader).
• (setf wb-list-relation-tuples) (writer).

---

4.1.16 fset/Code/complement-sets.lisp

Dependency

relations.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• arb (method).
• compare (method).
• compare (method).
• compare (method).
• complement (generic function).
• contains? (method).
• disjoint? (method).
• disjoint? (method).
• disjoint? (method).
• full-set (function).
• intersection (method).
• intersection (method).
• intersection (method).
• less (method).
• print-object (method).
• set-difference (method).
• set-difference (method).
• set-difference (method).
• size (method).
• subset? (method).
• subset? (method).
• subset? (method).
• union (method).
• union (method).
• union (method).
• with (method).

Internals

• complement-set (structure).
• complement-set-complement (reader).
• (setf complement-set-complement) (writer).
• complement-set? (function).
• internal-do-set (method).
• make-complement-set (function).
• print-complement-set (function).

---

4.1.17 fset/Code/bounded-sets.lisp

Dependency

complement-sets.lisp (file).

Source

fset.asd.

Parent Component

code (module).

Public Interface

• arb (method).
• bounded-set (structure).
• bounded-set-contents (function).
• compare (method).
• compare (method).
• compare (method).
• complement (method).
• contains? (method).
• convert (method).
• disjoint? (method).
• empty? (method).
• intersection (method).
• less (method).
• make-bounded-set (function).
• print-object (method).
• set-difference (method).
• size (method).
• subset? (method).
• union (method).
• with (method).

Internals

• bounded-set-complement? (reader).
• (setf bounded-set-complement?) (writer).
• bounded-set-set (reader).
• (setf bounded-set-set) (writer).
• bounded-set-universe (reader).
• (setf bounded-set-universe) (writer).
• bounded-set? (function).
• internal-do-set (method).
• make-bounded-set-internal (function).
• print-bounded-set (function).

---

6.1.1 Special variables

Special Variable: *fset-readtable* ¶

A copy of the standard readtable with FSet reader macros installed.

Package

fset.

Source

reader.lisp.

---

6.1.2 Macros

Macro: 2-relation (&rest args) ¶

Constructs a 2-relation of the default implementation according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a 2-relation, all of whose mappings will be included in the result. Also, each of ’key-expr’ and ’value-expr’ can be of the form ($ ‘expression’), in which case the expression must evaluate to a set, and the elements of the set are used individually to form pairs; for example, the result of

(2-relation (($ (set 1 2)) ($ (set ’a ’b))))

contains the pairs <1, a>, <1, b>, <2, a>, and <2, b>.

Package

fset.

Source

relations.lisp.

Macro: @ (fn-or-collection &rest args) ¶

A little hack with two purposes: (1) to make it easy to make FSet maps behave like Lisp functions in certain contexts; and (2) to somewhat lessen the pain of writing higher-order code in a two-namespace Lisp like Common Lisp. The idea is that you can write ‘(@ fn arg)’, and if ‘fn’ is a Lisp function, it will be funcalled on the argument; otherwise ‘lookup’ (q.v.) will be called on ‘fn’ and ‘arg’. To allow for ‘@’ to be used in more contexts, it actually can take any number of ‘args’, though ‘lookup’ always takes exactly two. Thus you can write ‘(@ fn arg1 arg2 ...)’ when you just want a shorter name for ‘funcall’. As a matter of style, it is suggested that ‘@’ be used only for side-effect-free functions. Also, though this doc string has spoken only of FSet maps, ‘@’ can be used with any type that ‘lookup’ works on. Can be used with ‘setf’, but only on collections, not functions, of course.

Package

fset.

Source

macros.lisp.

Setf expander for this macro

(setf @).

Macro: adjoinf (place &rest item-or-tuple) ¶

(adjoinf coll . args) –> (setf coll (with coll . args))

Package

fset.

Source

macros.lisp.

Macro: appendf (place seq) ¶

Package

fset.

Source

macros.lisp.

Macro: bag (&rest args) ¶

Constructs a bag of the default implementation according to the supplied argument subforms. Each argument subform can be an expression, whose value will be added to the bag with multiplicity 1; or a list of the form
($ ‘expression’), in which case the expression must evaluate to a bag (or a set), which is bag-summed into the result; or a list of the form
(% ‘expression1’ ‘expression2’) (called a "multi-arg"), which indicates that the value of ‘expression1’ is bag-summed into the result with multiplicity given by the value of ‘expression2’. That is, the multiplicity of each member of the result bag is the sum of its multiplicities as supplied by each of the argument subforms.

Package

fset.

Source

reader.lisp.

Macro: ch-map (&rest args) ¶

Constructs a ch-map according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a map, denoting all its mappings; or the symbol ‘:default’, in which case the next argument subform is a form whose value will become the map’s default. The result is constructed from the denoted mappings in left-to-right order; so if a given key is supplied by more than one argument subform, its associated value will be given by the rightmost such subform.

Package

fset.

Source

reader.lisp.

Macro: ch-set (&rest args) ¶

Constructs a ch-set according to the supplied argument subforms. Each argument subform can be an expression, whose value will be a member of the result set; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a set, all of whose members become members of the result set.

Package

fset.

Source

reader.lisp.

Macro: compare-slots (obj1 obj2 &rest accessors) ¶

A handy macro for writing the bodies of ‘compare’ methods for user classes. Returns the result of comparing the two objects by comparing the results of calling each of ‘accessors’, in order, on the objects. Despite the name, an accessor can actually be any function on the class in question; it can also be a symbol, which will be used to access the slot via ‘slot-value’. For example, if class ‘frob’ has accessor ‘frob-foo’ and slot ‘bar’:

(defmethod compare ((f1 frob) (f2 frob))
(compare-slots f1 f2 #’frob-foo ’bar))

If the symbol ‘:eql’ is supplied as the last accessor, then if the comparisons by the other supplied accessors all return ‘:equal’ but ‘obj1’ and ‘obj2’ are not eql, this returns ‘:unequal’.

Package

fset.

Source

macros.lisp.

Macro: compare-slots-no-unequal (obj1 obj2 &rest accessors) ¶

A handy macro for writing the bodies of ‘compare’ methods for user classes, in the case when you know the comparison will never need to return ‘:unequal’ (a case handled correctly by ‘compare-slots’, but with a slight time cost).

Returns the result of comparing the two objects by comparing the results of calling each of ‘accessors’, in order, on the objects, using a nested call to ‘compare’. Despite the name, an accessor can actually be any function on the class in question; it can also be a symbol, which will be used to access the slot via ‘slot-value’. For example, if class ‘frob’ has accessor ‘frob-foo’ and slot ‘bar’:

(defmethod compare ((f1 frob) (f2 frob))
(compare-slots-no-unequal f1 f2 #’frob-foo ’bar))

Additionally, an accessor can be a list of the form ‘(:compare acc less-fn)’, in which ‘acc‘ is an accessor as defined above, and ‘less-fn’ is a function to be used to compare the two values, returning true iff the first is less than the second. This feature allows you to avoid the nested call to ‘compare’. For example, if your objects have an ‘id’ slot that holds a unique integer:

(defmethod compare ((f1 frob) (f2 frob))
(compare-slots-no-unequal f1 f2 (:compare ’id #’<))

Package

fset.

Source

macros.lisp.

Macro: composef (place fn) ¶

Package

fset.

Source

macros.lisp.

Macro: def-tuple-key (name &optional default-fn) ¶

Deprecated; use ‘define-tuple-key’.

Package

fset.

Source

tuples.lisp.

Macro: define-comparison-slots (class &rest slots/accessors) ¶

A handy macro for generating ‘compare’ and ‘hash’ methods for user classes. The comparison or hashing is done by comparing or hashing the results of calling each of ‘slots/accessors’, in order, on the object(s). For best performance (at least on SBCL), it is recommended to supply slot names as symbols for standard classes – these will turn into ‘slot-value’ forms – but accessor names as functions (e.g. "#’point-x") for structure classes. Arbitrary functions on the class may also be supplied.

If the symbol ‘:eql’ is supplied as the last accessor, then if the comparisons by the other supplied accessors all return ‘:equal’ but ‘obj1’ and ‘obj2’ are not eql, the generated ‘compare’ method returns ‘:unequal’.

Package

fset.

Source

hash.lisp.

Macro: define-cross-type-compare-methods (type) ¶

Generates cross-type comparison methods for ‘type’ against the types on which the macro has previously been invoked. This macro is intended to be invoked at the top level of a source file. You should make sure that calls to this macro are always compiled in the same order; if you don’t, you could possibly get a "master type ordering out of sync" error, at which point you should delete all your fasls, restart your Lisp session, and recompile. However, the implementation tries very hard to prevent this.

Package

fset.

Source

macros.lisp.

Macro: define-tuple-key (name &optional default-fn doc-string) ¶

Defines a tuple key named ‘name’ as a global lexical variable (see ‘deflex’). If ‘default-fn’ is supplied, it is used to compute a value for lookups where the tuple has no explicit pair with this key; it is called with one argument, the tuple. To supply a doc string without a default-fn, supply ‘nil’ for ‘default-fn’.

Package

fset.

Source

tuples.lisp.

Macro: do-2-relation ((key val br &optional value) &body body) ¶

Enumerates all pairs of the relation ‘br’, binding them successively to ‘key’ and ‘val’ and executing ‘body’.

Package

fset.

Source

relations.lisp.

Macro: do-all-queries ((query reg &optional value) &body body) ¶

Package

fset.

Source

relations.lisp.

Macro: do-bag ((value-var bag &optional value) &body body) ¶

For each member of ‘bag’, binds ‘value-var’ to it and and executes ‘body’ a number of times equal to the member’s multiplicity. When done, returns ‘value’.

Package

fset.

Source

macros.lisp.

Macro: do-bag-pairs ((value-var mult-var bag &optional value) &body body) ¶

For each member of ‘bag’, binds ‘value-var’ and ‘mult-var’ to the member and its multiplicity respectively, and executes ‘body’. When done, returns ‘value’.

Package

fset.

Source

macros.lisp.

Macro: do-list-relation ((tuple rel &optional value) &body body) ¶

Package

fset.

Source

relations.lisp.

Macro: do-map ((key-var value-var map &optional value) &body body) ¶

For each pair of ‘map’, binds ‘key-var’ and ‘value-var’ and executes ‘body’. When done, returns ‘value’.

Package

fset.

Source

macros.lisp.

Macro: do-map-domain ((key-var map &optional value) &body body) ¶

For each pair of ‘map’, binds ‘key-var’ and executes ‘body’. When done, returns ‘value’.

Package

fset.

Source

macros.lisp.

Macro: do-seq ((var seq &key start end from-end? index value) &body body) ¶

For each element of ‘seq’, possibly restricted by ‘start’ and ‘end’, and in reverse order if ‘from-end?’ is true, binds ‘var’ to it and executes ‘body’. If ‘index’ is supplied, it names a variable that will be bound at each iteration to the index of the current element of ‘seq’. When done, returns ‘value’.

Package

fset.

Source

macros.lisp.

Macro: do-set ((var set &optional value) &body body) ¶

For each member of ‘set’, binds ‘var’ to it and executes ‘body’. When done, returns ‘value’.

Package

fset.

Source

macros.lisp.

Macro: do-tuple ((key-var value-var tuple &optional value) &body body) ¶

For each pair of ‘tuple’, binds ‘key-var’ and ‘value-var’ and executes ‘body’. When done, returns ‘value’.

Package

fset.

Source

tuples.lisp.

Macro: dyn-tuple (&rest args) ¶

Constructs a dyn-tuple according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a tuple, denoting all its mappings. The result is constructed from the denoted mappings in left-to-right order; so if a given key is supplied by more than one argument subform, its associated value will be given by the rightmost such subform.

Package

fset.

Source

reader.lisp.

Macro: excludef (place &rest item-or-tuple) ¶

(excludef coll . args) –> (setf coll (less coll . args))

Package

fset.

Source

macros.lisp.

Macro: imagef (place fn) ¶

Package

fset.

Source

macros.lisp.

Macro: includef (place &rest item-or-tuple) ¶

(includef coll . args) –> (setf coll (with coll . args))

Package

fset.

Source

macros.lisp.

Macro: intersectf (place set) ¶

Package

fset.

Source

macros.lisp.

Macro: map (&rest args) ¶

Constructs a map of the default implementation according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a map, denoting all its mappings; or the symbol ‘:default’, in which case the next argument subform is a form whose value will become the map’s default. The result is constructed from the denoted mappings in left-to-right order; so if a given key is supplied by more than one argument subform, its associated value will be given by the rightmost such subform.

Package

fset.

Source

reader.lisp.

Macro: map-intersectf (place map &rest stuff) ¶

Package

fset.

Source

macros.lisp.

Macro: map-unionf (place map &rest stuff) ¶

Package

fset.

Source

macros.lisp.

Macro: pop-first (seq) ¶

Removes the first element from ‘seq’ and returns it.

Package

fset.

Source

macros.lisp.

Macro: pop-last (seq) ¶

Removes the last element from ‘seq’ and returns it.

Package

fset.

Source

macros.lisp.

Macro: prependf (place seq) ¶

Package

fset.

Source

macros.lisp.

Macro: push-first (place val) ¶

(push-first seq val) –> (setf seq (with-first seq val))

Package

fset.

Source

macros.lisp.

Macro: push-last (place val) ¶

(push-last seq val) –> (setf seq (with-last seq val))

Package

fset.

Source

macros.lisp.

Macro: removef (place &rest item-or-tuple) ¶

(removef coll . args) –> (setf coll (less coll . args))

Package

fset.

Source

macros.lisp.

Macro: replay-map (&rest args) ¶

Constructs a replay-map of the default implementation according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a map, denoting all its mappings; or the symbol ‘:default’, in which case the next argument subform is a form whose value will become the map’s default. The result is constructed from the denoted mappings in left-to-right order; so if a given key is supplied by more than one argument subform, its associated value will be given by the rightmost such subform.

Package

fset.

Source

reader.lisp.

Macro: replay-set (&rest args) ¶

Constructs a replay-set of the default implementation according to the supplied argument subforms. Each argument subform can be an expression, whose value will be a member of the result set; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a set, all of whose members become members of the result set.

Package

fset.

Source

reader.lisp.

Macro: seq (&rest args) ¶

Constructs a seq of the default implementation according to the supplied argument subforms. Each argument subform can be an expression whose value is to appear in the sequence; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a sequence, all of whose values appear in the result sequence. The order of the result sequence reflects the order of the argument subforms.

Package

fset.

Source

reader.lisp.

Macro: set (&rest args) ¶

Constructs a set of the default implementation according to the supplied argument subforms. Each argument subform can be an expression, whose value will be a member of the result set; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a set, all of whose members become members of the result set.

Package

fset.

Source

reader.lisp.

Macro: set-differencef (place set) ¶

Package

fset.

Source

macros.lisp.

Macro: tuple (&rest args) ¶

Constructs a tuple of the default implementation according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a tuple, denoting all its mappings. The result is constructed from the denoted mappings in left-to-right order; so if a given key is supplied by more than one argument subform, its associated value will be given by the rightmost such subform.

Package

fset.

Source

reader.lisp.

Macro: unionf (place set) ¶

Package

fset.

Source

macros.lisp.

Macro: wb-2-relation (&rest args) ¶

Constructs a wb-2-relation according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a 2-relation, all of whose mappings will be included in the result. Also, each of ’key-expr’ and ’value-expr’ can be of the
form ($ ‘expression’), in which case the expression must evaluate to a set, and the elements of the set are used individually to form pairs; for example, the result of

(wb-2-relation (($ (set 1 2)) ($ (set ’a ’b))))

contains the pairs <1, a>, <1, b>, <2, a>, and <2, b>.

Package

fset.

Source

relations.lisp.

Macro: wb-bag (&rest args) ¶

Constructs a wb-bag according to the supplied argument subforms. Each argument subform can be an expression, whose value will be added to the bag with multiplicity 1; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a bag (or a set), which is bag-summed into the result; or a list of the form (% ‘expression1’ ‘expression2’) (called a "multi-arg"), which indicates that the value of ‘expression1’ is bag-summed into the result with multiplicity given by the value of ‘expression2’. That is, the multiplicity of each member of the result bag is the sum of its multiplicities as supplied by each of the argument subforms.

Package

fset.

Source

reader.lisp.

Macro: wb-map (&rest args) ¶

Constructs a wb-map according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a map, denoting all its mappings; or the symbol ‘:default’, in which case the next argument subform is a form whose value will become the map’s default. The result is constructed from the denoted mappings in left-to-right order; so if a given key is supplied by more than one argument subform, its associated value will be given by the rightmost such subform.

Package

fset.

Source

reader.lisp.

Macro: wb-replay-map (&rest args) ¶

Constructs a wb-replay-map according to the supplied argument subforms. Each argument subform can be a list of the form (‘key-expr’ ‘value-expr’), denoting a mapping from the value of ‘key-expr’ to the value of ‘value-expr’; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a map, denoting all its mappings; or the symbol ‘:default’, in which case the next argument subform is a form whose value will become the map’s default. The result is constructed from the denoted mappings in left-to-right order; so if a given key is supplied by more than one argument subform, its associated value will be given by the rightmost such subform.

Package

fset.

Source

reader.lisp.

Macro: wb-replay-set (&rest args) ¶

Constructs a wb-replay-set according to the supplied argument subforms. Each argument subform can be an expression, whose value will be a member of the result set; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a set, all of whose members become members of the result set.

Package

fset.

Source

reader.lisp.

Macro: wb-seq (&rest args) ¶

Constructs a wb-seq according to the supplied argument subforms. Each argument subform can be an expression whose value is to appear in the sequence; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a sequence, all of whose values appear in the result sequence. The order of the result sequence reflects the order of the argument subforms.

Package

fset.

Source

reader.lisp.

Macro: wb-set (&rest args) ¶

Constructs a wb-set according to the supplied argument subforms. Each argument subform can be an expression, whose value will be a member of the result set; or a list of the form ($ ‘expression’), in which case the expression must evaluate to a set, all of whose members become members of the result set.

Package

fset.

Source

reader.lisp.

---