Common Lisp Package: STDUTILS

README:

STDUTILS

Yet Another Common Lisp Standard Utilities Library

This is my home grown standard utilities library on which langutils and the registry projects depend so I've made it publically available. I'm sure documentation would be helpful and if there is demand someday I may generate auto-docs.

FUNCTION

Public

ACCUMULATE-LIST (FN LIST)

Map a binary operation over a list, accumulating the incremental results fn(fn(1,2),3)...

ADD-MATRIX (&REST MATRICES)

Add matrices

AFTER (X Y LST &KEY (TEST #'EQL))

Returns true if any y occurs before the first x in lst

APPEND-SUBLISTS (LIST)

Takes a list of lists and appends all sublists

AREC (REC &OPTIONAL BASE)

Walks an array as in lrec, base case is end of array

BEFORE (X Y LST &KEY (TEST #'EQL))

Returns true if an x occurs before the first y in lst

BEST (FN LST)

Get the best element from list using fn as a comparison of list elements. fn returns nul if first object fails or the object if it wins.

BREAK-LIST (ITEM LIST &KEY (KEY #'IDENTITY) (TEST #'EQ) (DISCARD NIL))

Destructive version of split-list

CHARHEX (CH)

convert hex character to decimal

CLEAR-MATRIX (MATRIX VALUE)

Set every element of matrix to an initial-value

COLLAPSE-WHITESPACE (S)

Convert multiple whitespace characters to a single space character.

COLLECT

cons together non-nil results

COMBINATIONS (&REST LISTS)

Create a list for each combination formed of an element from each provided list. ie (list-combinations '(a b c) '(d e)) => '((a d) (a e) (b d) (b e) (c d) (c e))

COMPOSE (&REST FNS)

Function composition.

CONS->LIST (LIST)

Convert a list of cons cells to a list of two-element lists, i.e. (a . b) => (a b)

COPY-MATRIX (MATRIX)

Return a copy of the matrix.

COUNT-LISP-FILES (DIRECTORY &KEY (EXTENSION lisp) IGNORE-COMMENTS IGNORE-STRINGS PRINT-FILES PRINT-DIRS (IGNORE-DIRS '(_darcs .svn .cvs .hg)))

Line count for all lisp files under provided directory

COUNT-STRING-CHAR (S C)

Return a count of the number of times a character appears in a string

COUNT-STRING-CHAR-IF (PRED S)

Return a count of the number of times a predicate is true for characters in a string

DECODE-URI-STRING (QUERY)

Unescape non-alphanumeric characters for URI fields

DELIMITED-STRING-TO-LIST (STRING &OPTIONAL (SEPARATOR ) SKIP-TERMINAL)

split a string with delimiter

DIRECTORY-PATHNAME (FILE)

Return the path of the directory of the file.

DISJUNCTION (SET1 SET2)

Compute the non-intersecting elements of set1 and set2

DISTINCT (LIST &KEY (TEST #'EQL) (KEY #'IDENTITY))

Create a reduced list which groups all equal terms in the original into sublists (1 2 2 3 3 3 4) => ((1) (2 2) (3 3 3) (4))

DISTRIBUTE (ROWS)

distributes each element of each row into a separate contiguous list, like inverting an array

ELIMINATE-MATRIX (MATRIX ROWS COLS)

Gaussian elimination with partial pivoting.

ENCODE-URI-STRING (QUERY)

Escape non-alphanumeric characters for URI fields

ESCAPE-XML-STRING (STRING)

Escape invalid XML characters

EXCHANGE-ROWS (MATRIX ROW-I ROW-J)

Exchange row-i and row-j of a matrix

EXPLODE (SYM)

Turn a symbol into a list of the constitutent characters of its name

EXTRACT-TOKENS (STR TEST &OPTIONAL (START 0))

Returns a list of the subsequences satisfying test, characters failing the test are treated as whitespace.

FAST-ARRAY-COPY (A1 A2 START COUNT)

Unsafe array copy

FILTER (FN LST)

Extract elements on which fn returns true

FILTER-TEXT (TEXT FILTERS &KEY (DEBUG NIL))

Successively applies a filter function from list to text and the next filter to the result of the prior

FIND2 (FN LST)

returns two values, the first element in lst on which fn returns a non-null value and the value so returned.

FIRST-NONWHITE-CHAR (STRING)

Find the first non-whitespace character on this line

FLATTEN (X)

Turn a cons tree in to a list

FLATTEN1 (X)

Flatten a list by removing only one level

FN-SEQUENCE (&REST FNS)

Function sequencing with shared args

GATHER (&REST COLUMNS)

Gathers top elements from each column in columns and groups them in order, like inverting an array

GENSYMS (NUM &KEY (LAST (GENSYM)))

Returns a list of 'num' gensysms

GENSYMS-IGNORABLE (SYMLIST)

Generates ignorable declarations for a list of gensyms

GROUP (LIST NUM)

Returns a list of sub-lists, each sublist being the next 'num' of the source list. Lists that are not multiples of 'num' will have a truncated final list.

HASH-ITEMS (HASH)

Return the alist with the same data as the hash-table. Like alist->hash-table but the first element is not the test: '(key0 . val0) (key1 . val1).

INTEGER-COMBINATIONS (N M)

(n C m) from classic combinatorics. Number of unique ordered sets

INTEGER-PERMUTATIONS (N M &AUX (P 1))

(n P m) from classic combinatorics. Number of unique unordered sets

INTEGER-PERMUTATIONS-REPEATED (N M REPEATS)

Permutations with repeated elements. Repeats is the number of subsets of N that are counted as identical under permutation

INTEGER-STRING (NUM LEN)

Outputs a string of LEN digit with an optional initial character PCHAR. Leading zeros are present.

INVERT-MATRIX (MATRIX &OPTIONAL (DESTRUCTIVE T))

Find the inverse of a matrix. By default this operation is destructive. If you want to preserve the original matrix, call this function with an argument of NIL to destructive.

IS-STRING-WHITESPACE (STR)

Return t if string is all whitespace

KEEP-KEYWORDS (LIST KEYWORDS)

Keep only specified keywords from a keylist

LEX-STRING (STRING &KEY (WHITESPACE '( )))

Separates a string at whitespace and returns a list of strings

LIST-TO-STRING (LST)

Converts a list to a string, doesn't include any delimiters between elements

LONGER (X Y)

Is x longer than y?

LREC (REC &OPTIONAL BASE)

Guides a list recursion process and takes recursive functions of x = car and fn = recursive call the terminal end of list case returns the value of base. Beware of non-tail recursive implementation

MAKE-IDENTITY-MATRIX (SIZE)

Make an identity matrix of the specified size.

MAKE-MATRIX (ROWS &OPTIONAL (COLS ROWS))

Create a matrix filled with zeros. If only one parameter is specified the matrix will be square.

MAKE-TAGLIST (&OPTIONAL (TEST #'EQL))

Simple data structure 'taglist'. This function creates an object that can provide a unique tag for each unique object as determined under test. Conceptually a uniqueified alist intended for small sets of objects

MAP-ALL-COMBINATIONS (FUNCTION &REST LISTS)

Applies function to every combination of the elements of the lists provided. (function) should recieve a single list as a parameter. Don't count on the order of application. Beware! This is an n^(huge) power function! Use carefully.

MATRIXP (MATRIX)

Test whether the argument is a matrix

MERGE-OR-REGEX-STRINGS (LIST &OPTIONAL (OPERATION |))

Combine multiple strings by concatenting a separator, such as an OR for or'ing together regular expressions.

MKLIST (OBJ)

Make into list if atom

MOST (FN LST)

Get the highest scoring element from list using fn as the scoring routine. If there are multiple elements with the highest score this gets the first.

MOSTN (FN LST)

Get the highest scoring elements from list using fn as the scoring routine.

MULTIPLY-MATRIX (&REST MATRICES)

Multiply matrices

NDISTINCT (LIST &KEY (TEST #'EQL) (KEY #'IDENTITY))

Like distinct, but performs a destructive sort on the original list

NMERGE-DUPLICATES (FUNC LIST &KEY (TEST #'EQ))

Destructively walks the list and when test applies between the head and any remaining element it applies func to the two elements, makes that the newly accumulated value (replacing all instances of matches to the head) and then compares the original element again to the remainder of the list. The choice of 'head' comparison with the original head value is for numerical quantities, ie: (nmerge-duplicates #'+ '(1 2 3 1 2 3 4 5 5 4) :test #'=) ==> '(2 4 6 8 10)

NSTRING-TRIM-LAST-CHARACTER (S)

Return the string less the last character

NUM-COLS (MATRIX)

Return the number of rows of a matrix

NUM-ROWS (MATRIX)

Return the number of rows of a matrix

PAIRS (LIST)

Take each set of two elements in the list and make a list one half the size containing a pair of each two items

PREFIXED-FIXNUM-STRING (NUM PCHAR LEN)

Outputs a string of LEN digit with an optional initial character PCHAR. Leading zeros are present.

RANDOM-ELEMENT (LIST)

Choose a random element from the list and return it

RANDOM-ORDER (LIST)

Return a new list in a random order; This may not be 'truely' random

RANDOM-STRING (&KEY (LENGTH 10) (SET LOWER-ALPHA))

Returns a random lower-case string.

RANDOM-SUBSET (LIST SIZE)

Extract a random subset by percent (size < 1) and return two values, the subset and the remainder set - order is not maintained

RECOGNIZE-FMT (STRM FMT-LST)

STRM is an input stream to parse. FMT-LST is list of terms from fmt string.

REM-KEYWORDS (LIST KEYWORDS)

Remove keywords from a keylist

REMOVE-SUBLIST (LIST SUBLIST &KEY (TEST #'EQ) (SPLIT NIL))

Finds and removes the first occurances of sublist in list

REPEAT (E N)

repeat element e n times into a list

REPEAT-FN (FN N)

repeat thunk fn n times, results are returned in a list, car is the result of the first call

RFIND-IF (FN TREE)

Find first atom in tree on which fn returns true

RFIND-NODE-IF (FN TREE)

Recurse cons-based tree structure until a matching subtree is found

SEED-RANDOM-GENERATOR

Evaluate a random number of items

SELECT-IF (FF LST &KEY KEY)

Extract only the elements from the lst that satisfy the predicate ff

SHUFFLE (X Y)

Mix x and y element for element into a single list

SLURP-FILE (FILENAME)

Read a file's contents to a string

SOLVE-MATRIX (MATRIX &OPTIONAL (DESTRUCTIVE T) PRINT-SOLN)

Solve a matrix using Gaussian elimination Matrix must be N by N+1 Assume solution is stored as the N+1st column of the matrix

SORT-B-ACCORDING-TO-A (ALIST BLIST PREDICATE &OPTIONAL (KEY #'FIRST))

Sorts blist according to the reordering of alist and returns the newly ordered blist. Non-destructive to alist and blist

SORT-ORDERING-BY (ORDER ELEMENTS KEY)

Simple n squared order b according to a

SPLIT-ALPHANUMERIC-STRING (STRING)

Separates a string at any non-alphanumeric chararacter

SPLIT-LIST (ITEM LIST &KEY (KEY #'IDENTITY) (TEST #'EQ) (DISCARD NIL))

Walks list to first match of item and returns two fresh lists; one up to the item and the remainder including the item.

SQUARE-MATRIX? (MATRIX)

Is the matrix a square matrix?

STRING-DELIMITED-STRING-TO-LIST

splits a string delimited by substr into a list of strings

STRING-INVERT

Invert case of a string

STRING-SUBSTITUTE (STRING SUBSTRING REPLACEMENT-STRING)

String substitute by Larry Hunter. Obtained from Google

STRING-TO-LIST-SKIP-DELIMITER (STR &OPTIONAL (DELIM ))

Return a list of strings, delimited by spaces, skipping spaces.

STRING-TRIM-LAST-CHARACTER (S)

Return the string less the last character

SUBSTITUTE-CHARS-STRINGS (STR REPL-ALIST)

Replace all instances of a chars with a string. repl-alist is an assoc list of characters and replacement strings.

SUBSTITUTE-STRING-FOR-CHAR (PROCSTR MATCH-CHAR SUBST-STR)

Substitutes a string for a single matching character of a string

SUBTRACT-MATRIX (&REST MATRICES)

Subtract matrices

SYMBOL-NAME-EQUAL (SRC TARGET &KEY KEY (TEST #'EQUAL))

Compare two symbols independant of package, can treat target as a complex structure using key

TAGLIST-OBJECT (TAG TAGLIST)

Given a tag and a taglist return the object designated by the tag

TAGLIST-TAG (OBJECT TAGLIST)

Take an arbitrary object and a 'taglist' data structure and return a unique integer id that can be used to retrieve that object.

TICKER-PRINT-ELAPSED (TICKER &KEY (STREAM T))

Print time elapsed, in microseconds or another n parts per second time base

TRANSPOSE-MATRIX (MATRIX)

Transpose a matrix

TRIM-NON-ALPHANUMERIC (WORD)

Strip non-alphanumeric characters from beginning and end of a word.

UNIQUE-PAIRS (LIST)

Produce all unique pairings of the provided list

UNSHUFFLE (N X)

Create n lists, each getting the successive element of x. Returns a list of lists. Retains order.

WSEQ-NAME (WSEQ)

Return the concatenated string this wseq represents. Duplicates words in memory

WSEQ-WORDLIST (WSEQ)

Return the ordered list of words represented by this string. Do not side effect these strings.

Undocumented

=WSEQ (WS1 WS2)

>WSEQ (WS1 WS2)

ACCUM (FN INIT &REST LISTS)

ADD-SQL-QUOTES (S)

ANAPHEX (ARGS EXPR)

ANAPHEX1 (ARGS CALL)

ANAPHEX2 (OP ARGS)

ANAPHEX3 (OP ARGS)

APPEND1 (LST OBJ)

ARRAY->LIST (ARRAY &AUX LIST)

ASSOC-FIND (VALUE LIST &OPTIONAL (TEST #'EQ))

ASSOC-GET (KEY LIST &OPTIONAL (TEST #'EQ))

ASSOC-PUT (KEY VALUE LIST &OPTIONAL (TEST #'EQ))

ASSOC-REM (VALUE LIST)

CARS (LIST)

CDDRS (LIST)

CDRS (LIST)

COLLECT-OFFSETS (LIST)

COLLECTN

COMPILE-PATTERN (PATTERN &KEY (ELT 'AREF) (CMP '=) (ATOM-TYPE INTEGER))

CONC1 (LST OBJ)

CONCAT-SEPARATED-STRINGS (SEPARATOR &REST LISTS)

CONSTITUENT (C)

COUNT-LEAVES (TREE &KEY (COUNT-LAST-NIL NIL))

COUNT-LISP-LINES (FILENAME &KEY IGNORE-COMMENTS IGNORE-STRINGS)

COUNT-STRING-WORDS (STR)

CREATE-SET-METHOD-IF

CURRY (FN ARG)

CURRY2 (FN ARG)

DBIND-EX (BINDS BODY)

DT-ARGS (LEN REST SRC)

DUPLICATE (OBJ LST &KEY (TEST #'EQL))

ENSURE-STRING (V)

ESCAPE-BACKSLASHES (S)

EXTRACT-TAGGED-WORDS (TAGSPEC SENTENCE)

EXTRACT-WORDS (STR &OPTIONAL (START 0))

FACTORIAL (N)

FIND-ALL-PATTERNS (PATTERN VECTOR)

FIRST-CHAR (S)

FN-COMPOSE (&REST FNS)

FORCE-WSEQ-WORD (WORD)

FORMAT-TIME-STRING (STRM FMT &OPTIONAL (UT (GET-UNIVERSAL-TIME)) (ZONE *DEFAULT-ZONE*) (LANGUAGE *DEFAULT-LANGUAGE*))

GATHER-PAIRS (LIST1 LIST2)

HASH-CONTAINS (THIS KEY)

HASH-EMPTY? (HASH)

HASH-EQ? (H1 H2)

HASH-GET_LENGTH (THIS)

HASH-GET_REHASH_SIZE (THIS)

HASH-GET_TEST (THIS)

HASH-KEYS (HASH)

HASH-NEW_COPY (THIS)

HASH-PUSH (HASH KEY VALUE)

HASH-SURE_GET (THIS KEY)

HASH-SURE_SET (THIS KEY VALUE)

HASH-VALUES (HASH)

HASHSET-POPULATE (HSET LIST &KEY (KEY #'IDENTITY))

HEXCHAR (N)

INIT-WSEQ

INTERSECTIONS (&REST SETS)

IS-CHAR-WHITESPACE (C)

IS-STRING-EMPTY (STR)

LAST-CHAR (S)

LAST1 (LST)

LIMIT-MAX (LIMIT VALUE)

LIMIT-MIN (LIMIT VALUE)

LIST->ARRAY (LIST &KEY (ADJUSTABLE NIL) (TYPE T))

LIST-MAX (LIST)

LIST-STRUCTURE (LIST)

LIST-TO-DELIMITED-STRING (LIST &OPTIONAL (SEPARATOR ))

LOCALIZE-EXPRESSION (EXP &KEY (PACKAGE *PACKAGE*) EXCEPTIONS)

LOCALIZE-SYMBOL (SYM &KEY (PACKAGE *PACKAGE*) EXCEPTIONS (IGNORE-KEYWORDS T))

MAKE-TICKER (&OPTIONAL (TICKS-PER-SEC (TICKER-TICKS-PER-SECOND)))

MAKE-TIMER

MAKE-TIMER-REMAINING-BY-COUNT (TOTAL)

MAKE-USB8-ARRAY (LEN)

MAKE-WSEQ

MAPCAR-IDX (FN LIST)

MAPCARS (FN &REST LSTS)

MAPPEND (FN &REST LSTS)

MATCH (X Y &OPTIONAL BINDS)

MAX-ARRAY (ARRAY &OPTIONAL (START 0))

MAXMIN (ARGS)

MEMOIZE (FN)

MEMOIZE1 (FN)

MKKEYSYM (TEXT)

MKSTR (&REST ARGS)

MKSYMBOL (&REST COMPONENT-NAMES)

MKUPSYMBOL (&REST COMPONENT-NAMES)

MVDO-GEN (BINDS REBINDS TEST BODY)

MVDO-REBIND-GEN (REBINDS)

NEQ (A B)

NEQL (A B)

NEQUAL (A B)

NEQUALP (A B)

NFLATTEN (TREE)

NON-ALPHANUMERICP (CH)

ONLY-NULL-LIST-ELEMENTS-P (LST)

PARALLEL-EXPAND (KEYWORD BODY)

PARSE-TIME-STRING (STR &OPTIONAL (RECOGNIZERS *DEFAULT-RECOGNIZERS*))

POP-SYMBOL (SYM)

POSITION-CHAR (CHAR STRING START MAX)

POSITION-NOT-CHAR (CHAR STRING START MAX)

PRUNE (TEST TREE)

QUOTE-TOKENIZE (STRING)

RANDOM-CHAR (&OPTIONAL (SET LOWER-ALPHA))

RANDOM-FRACTION-LIST (PRECISION N)

RANDOM-INTEGER-LIST (LOWER UPPER N)

READ2 (&OPTIONAL (STR *STANDARD-INPUT*))

REMOVE-GENERIC-FUNCTION-METHOD (SPEC)

REMOVE-NULLS (LIST)

REPLACED-STRING-LENGTH (STR REPL-ALIST)

RESET-TICKER (TICKER)

RESET-TIMER (TIMER)

RMAPCAR (FN &REST ARGS)

SAFE-SUBSEQ (SEQUENCE START &OPTIONAL END)

SAME-LENGTH (A B)

SELECT-KEYWORDS (LIST)

SET-DIFFERENCES (SET &REST OUTS)

SET-EQUAL (SET1 SET2)

SHRINK-VECTOR (STR SIZE)

SINGLE (LST)

SPLIT-IF (FN LST)

STRCAT (&REST STRINGS)

STRING->LIST (STRING)

STRING-ELIDE (STR MAXLEN POSITION)

STRING-HASH (STR &OPTIONAL (BITMASK 65535))

STRING-LEFT-TRIM-WHITESPACE (STR)

STRING-MAYBE-SHORTEN (STR MAXLEN)

STRING-REMOVE-CHARACTERS (STRING CHAR-LIST)

STRING-RIGHT-TRIM-ONE-CHAR (CHAR STR)

STRING-RIGHT-TRIM-WHITESPACE (STR)

STRING-STARTS-WITH (START STR)

STRING-STRIP-ENDING (STR ENDINGS)

STRING-TO-USB8-ARRAY (STR)

STRING-TRIM-WHITESPACE (STR)

STRLIST->QUOTED-SUBSTRINGS (LIST)

STRNCMP (STRING1 STRING2 COUNT START)

STRNCMP-END2 (STRING1 STRING2 COUNT START)

SUBSTITUTE-MATRIX (MATRIX ROWS COLS)

SUM-ARRAY (ARRAY &OPTIONAL (START 0))

SYMB (&REST ARGS)

TAGS-FROM-WORDS (WORDS TAGLIST &KEY (TAGF #'TAGLIST-TAG))

TICKER-ELAPSED (TICKER)

TICKER-TICKS-PER-SECOND

TIMER-ELAPSED (TIMER)

TIMER-PRINT-ELAPSED (TIMER &OPTIONAL (STREAM T))

TIMER-RBC-ITEMS-REMAINING (TIMER)

TIMER-RBC-PRINT-TIME-REMAINING (TIMER)

TIMER-RBC-TIME-REMAINING (TIMER)

TIMER-RBC-UPDATE (TIMER REMAINING)

TREC (REC &OPTIONAL (BASE #'IDENTITY))

UNIONS (&REST SETS)

UNSPLIT-WORDS (LIST)

UPDATE-HASH (HASH KEY VALUE &OPTIONAL (FN #'(LAMBDA (X Y) (DECLARE (IGNORE X)) Y)))

UPDATE-HASH-HASH (HASH HASH2 &OPTIONAL (FN #'(LAMBDA (X Y) (DECLARE (IGNORE X)) Y)))

UPDATE-HASH-LIST (HASH ALIST &OPTIONAL (FN #'(LAMBDA (X Y) (DECLARE (IGNORE X)) Y)))

USB8-ARRAY-TO-STRING (VEC)

USE-PACKAGE-NOSHADOW-EXPORTED (SRC-PACKAGE &OPTIONAL (TARGET-PACKAGE *PACKAGE*))

VARS-IN-PAT (EXPR &OPTIONAL (ATOM? #'ATOM))

VECTOR-1D-LSHIFT

VECTOR-1D-RSHIFT

WALK-DIRECTORIES (ROOTDIR &REST ARGS &KEY FILEF DIRF HIDDEN (ON-ENTRY T) (IGNORE-DOTFILES T) IGNORE-DIRS)

WALK-HEIRARCHY (ROOT &KEY NEXT-LEVEL (ORDER BEFORE) (NODE-ACTION NIL) (LEAF-ACTION NIL) (KEY NIL))

WORDS-FROM-TAGS (TAGS TAGLIST &KEY (TAGF #'TAGLIST-OBJECT))

WPLAC-EX (BINDS BODY)

WSEQ-SUBSEQ (SUBSEQ TARGET)

WSEQ-WORD (INT)

Private

BROKEN-TIME-AMPM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-DD (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-DOW (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-DST? (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-HH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-MM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-MO (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-SS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-YR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TIME-ZONE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BROKEN-TO-UT (X)

Given a BROKEN time structure, conver them to a universal time & return the universal time. All of the date-&-time components must be present in the BROKEN time.

COLLECT-TOKEN (WIDTH GOOD-CHAR? STRM)

Collect characters from character input stream STRM until we have WIDTH characters or the next character is not acceptable according to GOOD-CHAR?, which is a function. Return the characters we collected, as a string.

CONVERT-FMT-STRING-TO-LIST (FMT)

Given a FMT string for FORMAT-TIME, return a list of substrings parsed from the FMT string.

CREATE-BROKEN (X)

Return a new BROKEN with members initialized from X. X may be a universal time or an association list.

END-OF-STREAM? (STRM)

Return true if STRM is at its end. Does not consume characters. STRM is a character input stream.

MAKE-NUMERIC-PARSER (WIDTH MIN MAX FIELD)

Return a function which parses a numeric token of at most WIDTH digits, translating to a number not less than MIN & not more than MAX. For example, if WIDTH, MIN, & MAX are 4, 100, & 9000, you get a function which parses at most 4 digits that form a number N in the range 100 <= N <= 9000.

MAKE-WORD-PARSER (WIDTH HT FIELD)

Return a function which parses consecutive alpha- & numeric characters, up to WIDTH of them, & then converts them to a Lisp object via the HT hash table.

NEXT-FN (STRM FN)

Consume & collect characters from STRM as long as they satisfy FN. FN is a function of one argument which should be a character.

NEXT-NUMBER (STRM)

Consume characters from STRM as long as they are digits. Then convert to a number & return the number.

NEXT-WORD (STRM)

Consume & collect characters from STRM as long as they are alphanumeric. Converts all characters to upper case. Returns the token as a string. Return NIL if the stream is already at the end when you call this function.

NORMALIZE-BROKEN (X)

Given a BROKEN-TIME, some components of which may be missing, some of which may be screwy -- like a 2-digit year, this function inserts all missing components, possibly performs some other adjustments, & returns a new BROKEN-TIME. An exception is time-zone; if it's missing, it won't be inserted.

PARSE-LITERAL (LITERAL STRM)

Match & consume the literal characters in the string LITERAL from the input stream STRM. If all the charactrs in LITERAL match the next characters from STRM, return CONS :LITERAL LITERAL. Otherwise, Nil.

PARSE-PERCENT-PERCENT (STRM)

Recognize the literal '%' character. This is for the '%%' format token.

PARSE-TIME (STR &OPTIONAL (RECOGNIZERS *DEFAULT-RECOGNIZERS*))

Parse a string containing a date-&-time. Return a universal time. If the string can't be recognized, return NIL.

PARSE-TIME-ZONE (STRM)

Jeezus fucking Krist I hate time zones. A bitch to parse. And a stupid idea to begin with. Fuuuuuck. Recognize a time zone token from STRM. If the next character is + or -, we expect a two-digit number of hours to follow, such as 7 or 5. After those numbers, the next character may be ':' (which is ignored), & then two-digit number of minutes. If the first token of STRM is alpha instead of + or -, we collect alpha-numeric characters into a token, then translate them to a numeric time zone via a hash table.

PARSE-TIME-ZONE-MINUS (STRM)

Parse the rest of a time zone assuming it begins with a - character. It starts with a two-digit hour.

PARSE-TIME-ZONE-MINUS-HOUR (STRM HOUR)

Parse the minutes, assuming we've already parsed the hour.

PARSE-TIME-ZONE-PLUS (STRM)

Parse a time zone assuming the first character of it was a + character.

RANDOM-CHOICE-DIST (LIST DIST)

A random choice from list using the enumerated probability distribution in dist

RECOGNIZE-MINIMAL-ISO (STR)

The string is minimal ISO if, after trimming leading & trailing crap, the string is 14 characters & they are all digits.

RECOGNIZE-NOW (STR TOKENS)

Parse the string 'now', in any mix of case & with or without leading or trailing crap ... er, I mean whitespace characters. NOW is the current time with resolution to the second.

RECOGNIZE-TEE-ISO (STR)

Tee-ISO is like minimal ISO except that is has a T character in the middle of it.

RECOGNIZE-TODAY (STR TOKENS)

Parse the string 'today', in any mix of case & with or without leading or trailing crap ... er, I mean whitespace characters. Today is the current year, month, & day, the default hour, 0 for minutes, & 0 for seconds. It assumes GMT so that today executed at the same time in different time zones will give you the same universal time.

RECOGNIZE-YYYYMMDD-NW (STR TOKENS)

Recognize YYYY MM DD, with only whitespace separating the tokens. There is no time zone.

SAMPLED-DIST (FN ITERS &OPTIONAL VALUES)

Compute an estimated probability over equal comparable values from successive no-arg calls to fn over iters. Returns of an alist of (value . prob)

SPLIT-FILE (INFILE OUTFILE1 OUTFILE2 &KEY (TYPE HALF))

Allows you to split a file by :alternate lines or to split it in half by length

TIME-ZONE-CHAR? (X)

Return true if & only if X is a character & is acceptable in a time zone.

TOKENIZE (STR)

Return a list of tokens. Where possible & convenient, tokens are converted to symbols & numbers. Otherwise, tokens are strings or single characters, always upper case.

XDIGIT? (X)

Return true if X is a character AND is a digit.

Undocumented

>CASEX (G CL)

BINDING (X BINDS)

SETFBROKEN-TIME-AMPM (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-DD (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-DOW (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-DST? (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-HH (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-MM (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-MO (NEW-VALUE INSTANCE)

BROKEN-TIME-P (OBJECT)

SETFBROKEN-TIME-SS (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-YR (NEW-VALUE INSTANCE)

SETFBROKEN-TIME-ZONE (NEW-VALUE INSTANCE)

BUILD-CALL (OP FNS)

BUILD-COMPOSE (FNS)

BUILD-SOP (INPUT-EXPR ARGS)

CONDLET-BINDS (VARS CL)

CONDLET-CLAUSE (VARS CL BODFN)

COPY-BROKEN-TIME (INSTANCE)

CREATE-RANGE (DIST &OPTIONAL (PRIOR-SUM 0))

DESTRUC (PAT SEQ &OPTIONAL (ATOM? #'ATOM) (N 0))

EXPAND-EXPR (TEMPLATE ARGUMENT)

FIF (IF THEN &OPTIONAL ELSE)

FINT (FN &REST FNS)

FORMAT-TIME (STRM FMT &OPTIONAL (UT (GET-UNIVERSAL-TIME)) (ZONE *DEFAULT-ZONE*) (LANGUAGE *DEFAULT-LANGUAGE*))

FUN (FN &REST FNS)

GEN-MATCH (REFS THEN ELSE)

GENSYM? (S)

IS-DAY? (X)

IS-HOUR? (X)

IS-MINUTE? (X)

IS-SECOND? (X)

IS-YEAR? (X)

JOIN-OP (INTERP LIST)

LENGTH-TEST (PAT REST)

LIST-OR-STRUCT (LIST COUNT)

LOOKUP-OP (NAME)

LOOKUP-OPREC (NAME)

MAKE-BROKEN-TIME (&KEY ((SS DUM12) 0) ((MM DUM13) 0) ((HH DUM14) 0) ((DD DUM15) 0) ((MO DUM16) 0) ((YR DUM17) 0) ((DOW DUM18) NIL) ((DST? DUM19) NIL) ((ZONE DUM20) NIL) ((AMPM DUM21) NIL))

MAKE-FMT-RECOGNIZER (FMT)

MAKE-MONTH (X)

MAKE-WSEQ-OLD (STR)

MAKE-ZONE (X)

MATCH-ARRAYS (OFFSET PATTERN &KEY (ELT 'AREF) (CMP 'EQ) (ATOM-TYPE SYMBOL))

MATCH1 (REFS THEN ELSE)

MAX-ARRAY-TR (ARRAY START)

NEXT-TOKEN (STRM)

NORMALIZE-HOUR (BROKEN)

PARSE-METHOD-SPEC (SPEC)

RBUILD (EXPR)

RECOGNIZE-VERBOSE-ISO (STR TOKENS)

SIMPLE? (X)

UNIQUE-WORD-ID

VARSYM? (X)

MACRO

Public

AAND (&REST ARGS)

Makes the prior element in an and available to the next

AAREC (REC &OPTIONAL BASE)

Anaphoric recursion template over arrays

ABBREV (SHORT LONG)

Create an abbreviation for an existing function or macro via macro instantiation

ABBREVS (&BODY NAMES)

Map abbrev over a list of name pairs: (ab nam ab nam ...)

ACOND (&REST CLAUSES)

Anaphoric cond

ACOND-MV (&REST CLAUSES)

If the second value of a multiple-value return from a clause is true, it is bound to the primary value

ACOND2-MV (&REST CLAUSES)

If the primary value of a multiple-value return from a clause is true, 'it' is bound to the second value

ALAMBDA (ARGS &BODY BODY)

Allow recursive calls using captured variable 'self'

ALIST-BIND (NAMES ALIST &BODY BODY)

Bind names to associated values in assoc-list or nil

ALREC (REC &OPTIONAL BASE)

Anaphoric recursion templates

CASE-MATCH-BIND (DATA &REST CASES)

Produces an expression that when evaluated takes the value of 'data' and tries to perform a match using the static patterns in the car of each case in cases. If the pattern matches, it's variable names are bound to the matched values in the environment of the body expression of that case. (setf var '(1 2 3)) (case-match-bind var ((?A) ?A) ((?A ?B) ?B)) ==> 2 (setf pat1 '(?A)) (case-match-bind var (pat1 ?A) ((?A ?B) ?B)) ==> error

DEFCLASS-EXPORTED (CLASSNAME SUPERCLASSES SLOTS &REST OPTIONS)

Exports the class name and all defined accessors using reflection

DEFSTRUCT-EXPORTED (STRUCTNAME SUPERCLASSES SLOTS &REST OPTIONS)

Exports the structure and related accessors using reflection

DEFTAGLIST (NAME &KEY (TEST #'EQL))

A def macro form for the defun make-taglist

DEFUN-MEMO (FN ARGS &BODY BODY)

Define a memoized function

DEFUN-MEMO1 (FN ARGS &BODY BODY)

Define a memoized function

DO-COLLECT-VECTOR-MATCHES ((START-LABEL END-LABEL PATTERN) (&REST VECTORS) &REST BODY)

The pattern must be state, ie a quoted list or a previously-defined variable

DOLIST-TIMES ((VAR LIST TIMES &OPTIONAL (RESULT NIL)) &REST BODY)

Iterate over a list up to 'times' times

DOSEQ ((VAR SEQ &OPTIONAL (RESULT NIL)) &REST BODY)

Iterate over a sequence assigning var the value of each subsequent element

DOTIMES-UNROLLED ((VAR INIT COUNTFORM BLOCKING &OPTIONAL RESULTFORM) &BODY BODY)

An unrolling macro that speeds up do loops by writing an unrolled version, blocking determines the unrolled block size in original loop statements.

DOWORDS ((VAR WSEQ &OPTIONAL (RESULT NIL)) &REST BODY)

(dowords (var result) seq &rest body) This macro iterates through the string representation of the words in wseq.

ENSURE-A-VALUE (PLACE VALUE)

Ensures that place, if nil, has value

FILTER-IF (FF LST &KEY KEY)

Remove the elements from the list that satisfy predicate. Filter here is in the signal processing sense, filter away

GEN-EVERYP (PRED)

Creates a predicate that ensures pred is satisfied for all elements in a list

INTERN-FORMAT (FORMAT-STRING &REST FORMAT-ARGS)

This interns a string defined by format-string into the current package

INTERN-FORMAT-PKG (PKG FORMAT-STRING &REST FORMAT-ARGS)

This takes an explicit package and interns a string defined by format-string

MAC1 (EXPR)

Abbreviation for macroexpand-1

MAP-> (FN START TEST-FN SUCC-FN)

A general map function to assemble a map operation over arbitrary sequences. It takes an initial value 'start', a completion test function and a successor function which computes the next value

MAP0-N (FN N)

map over the integers from 0 to n

MAPA-B (FN A B &OPTIONAL (STEP 1))

map over the integers from a to b

MULTIPLE-INTERSECTION (PASSED-LISTS &REST REST)

Takes the intersection of one or more lists. If one list is passed, returns that list. Keylist accepts :key, :test, and :test-not

MVRETN (NUM EXPR)

Returning the num'th value from a multi value returning expression, expr

NAND (&REST FORMS)

Return nil iff all are non-nil

NOR (&REST FORMS)

Return true iff all nil

NORET (&BODY BODY)

Execute form and return t for any value or nil

NULLIT (EXPR)

Good for interaction at the repl; return null to the invoking expression regardless of the return value of expr

ON-ARRAY (REC BASE &REST ARRAYS)

Utility to build functions that walk arrays

ON-CDRS (REC BASE &REST LSTS)

Utility to defun anaphoric recursion functions over lists

ONE-ONLY (&BODY EXPRS)

If only one-value is non-nil, return that value

POPLAST (PLACE)

Remove the last element from the list and return it

PROPMACRO (PROPNAME)

Create a macro that gets a specific property from the property list of a symbol

PROPMACROS (&REST PROPS)

Create multiple property get macros

RANDOM-CHOICE (&REST EXPRS)

A random choice from a set of expressions

VCURRY (FN PATTERN &REST ORIG-ARGS)

Pattern determines the calling arglist over fn where nils are replaced with arguments to the new lambda in order and vars are replaced with the arguments in args in order

VECTOR-MATCH1 (PATTERN VECTOR &OPTIONAL (START-INDEX 0))

Match pattern over vector starting at start-index.

WITH-ASSOCS (NAMES ALIST &BODY BODY)

Associates a symbol with it's equivalent in the alist. Also matches keyword versions of the symbol to make it simpler for parsing most static datastructures you might want to use this for Beware if this isn't what you want.

WITH-KEYWORDS (NAMES LIST &BODY BODY)

Bind keyword names to values from a list of alternating keyword value pairs

WITH-PRINT-ELAPSED-TIME ((&KEY (BASE-UNITS 1) (NORM-F #'IDENTITY) (UNIT-NAME units)) &REST BODY)

Does not handle bodies that return multiple values. Returns seconds elapsed unless you set base-units to 1/N seconds

WITH-STRING-STREAM ((LABEL) &REST BODY)

Binds label to a string output stream and returns the string representing the writes to that stream

XOR (&REST FORMS)

Return the non-nil value iff only one value is true

Undocumented

ABLOCK (TAG &REST ARGS)

ACCUMULATE (FN &REST LISTS)

ACCUMULATE-INIT (FN INIT &REST LISTS)

ACCUMULATE-INT (FN &REST LISTS)

ACOND2 (&REST CLAUSES)

AIF (TEST-FORM THEN-FORM &OPTIONAL ELSE-FORM)

AIF-RET (TEST-FORM &BODY ELSE-FORM)

AIF2 (TEST &OPTIONAL THEN ELSE)

AIF2-RET (TEST-FORM &REST ELSE-FORM)

AIF2T (TEST &OPTIONAL THEN ELSE)

APROG1 (RESULT-FORM &BODY BODY)

APUSH (KEY VALUE PLACE)

APUSHNEW (KEY VALUE PLACE)

AS-FUNCTIONS (NAMES &BODY BODY)

ASETF (ACCESSOR-EXP NEW-VAL-EXPR)

ASSOC-DEL (VALUE PLACE)

ASSOC-SETF (PLACE KEY VALUE &OPTIONAL (TEST #'EQ))

ATREC (REC &OPTIONAL (BASE 'IT))

AWHEN (TEST-FORM &BODY BODY)

AWHEN-NULL (TEST-FORM DEFAULT-VALUE)

AWHEN0 (TEST-FORM WHEN-ZERO-FORM)

AWHEN2 (TEST &BODY BODY)

AWHEN2T (TEST &BODY BODY)

AWHILE (EXPR &BODY BODY)

AWHILE2 (TEST &BODY BODY)

CLEAR-TAG (PLACE TAG)

COPY-SLOTS ((SRC TARGET) &REST ALIST)

CREATE-OBJECT-CACHE (&REST REST &KEY (TYPE 'OBJECT-CACHE-H-Q) (SIZE 1000) (TEST #'EQL) &ALLOW-OTHER-KEYS)

CREATE-SET-METHOD-INST (OP-TYPE NAME ARGS LIST-FORM HASH-FORM)

DBIND (BINDS CALL &BODY BODY)

DEF-SIMPLE-ACCESSOR (NAME ARGS BODY)

DEFANAPH (NAME &OPTIONAL CALLS)

DEFCLASS+ (NAME SUPERCLASSES SLOTS &REST OPTIONS)

DEFCLASS+-EXPORTED (NAME SUPERCLASSES SLOTS &REST OPTIONS)

DEFCONSTANT-EXPORTED (NAME &REST ARGS)

DEFEXPORT (DEFDEF NAME &REST REST)

DEFGENERIC-EXPORTED (NAME LAMBDA-LIST &REST ARGS)

DEFMACRO-EXPORTED (NAME PATTERN &BODY BODY)

DEFMETHOD+ (TYPE METHOD ARGS &REST BODY)

DEFMETHOD+-EXPORTED (TYPE METHOD ARGS &REST BODY)

DEFMETHOD-EXPORTED (METHOD-SPEC LAMBDA-LIST &BODY BODY)

DEFSETF-EXPORTED (NAME FUNCTION)

DEFSUBST (FUNCTION LAMBDA-LIST &BODY BODY)

DEFSUBST-EXPORTED (FUNCTION LAMBDA-LIST &BODY BODY)

DEFUN-EXPORTED (FUNCTION-SPEC LAMBDA-LIST &BODY BODY)

DEFUN-REC (NAME PARMS &BODY BODY)

DEFVAR-EXPORTED (NAME &REST ARGS)

DIS1 (ARGS &BODY BODY)

DO-CONTENTFUL-LINES ((LABEL STREAM &KEY (COUNT NIL)) &REST BODY)

DO-COUNT-CONTENTFUL-LINES ((LINE-VAR COUNT-VAR STREAM) &REST BODY)

DO-FILE (FILENAME &BODY BODY)

DO-HASH ((K V HASH) &BODY BODY)

DO-MATRIX ((ROW COL MATRIX) &BODY BODY)

DO-MATRIX-COLUMNS ((COL MATRIX) &BODY BODY)

DO-MATRIX-ROWS ((ROW MATRIX) &BODY BODY)

DO-STREAM-LINES ((LABEL STREAM) &REST BODY)

DO-TUPLES/C (PARMS SOURCE &BODY BODY)

DO-TUPLES/O (PARMS SOURCE &BODY BODY)

DOHASH ((ELEM HASH) &BODY BODY)

ERROR-ON-NULL (EXP &REST ERROR-ARGS)

FOR ((VAR START STOP) &BODY BODY)

HAS-KEY? (HASH KEY)

HAS-TAG (PLACE TAG)

HASH (&KEY (TEST NIL) (REHASH-SIZE 10) (KEYVALS NIL) (HASH NIL))

HASH-CLEAR (HASH)

HASH-CLR (HASH)

HASH-GET (HASH KEY)

HASH-MAPULATE (HASH F VALUES)

HASH-MAPULATE-VALUE (HASH F KEYS)

HASH-POPULATE (HASH KVLIST)

HASH-PUT (HASH KEY VALUE)

HASH-REM (HASH KEY)

HASHSET-DIFFERENCE (HSET1 HSET2)

HASHSET-INTERSECTION (HSET1 HSET2)

HASHSET-UNION (HSET1 HSET2)

IF* (&REST ARGS)

IF-MATCH (PAT SEQ THEN &OPTIONAL ELSE)

IFRET (TEST-FORM &REST ELSE-FORM)

MAKE-REGEX-REPLACE-FILTER (REGEX SUBST &OPTIONAL (COMMENT ))

MAKE-REGEX-VERIFY-FILTER (REGEX &OPTIONAL (COMMENT ))

MAP-ACROSS (FN ARRAY)

MAP-ACROSS-IDX (FN ARRAY)

MAP-ACROSS-N (FN ARRAY N)

MAPWORDS (FN WSEQ)

MVBIND (BINDS CALL &BODY BODY)

MVDO (BINDS (TEST &REST RESULT) &BODY BODY)

MVDO* (PARM-CL TEST-CL &BODY BODY)

MVPSETQ (&REST ARGS)

MVSETQ (&BODY ARGS)

NCURRY (FN &REST DEF-ARGS)

NHASHSET-UNION (HSET1 HSET2)

NIF (EXPR POS ZERO NEG)

ON-TREES (REC BASE &REST TREES)

PARALET (ASSIGNMENTS &BODY BODY)

PROD-LIST (LIST)

PUSHLAST (VALUE PLACE)

RETSET (VARIABLE FORM)

ROTATE (PLACE)

SET-TAG (PLACE TAG)

STRING-APPEND (OUTPUTSTR &REST ARGS)

SUM-LIST (LIST)

TILL (TEST &BODY BODY)

WHEN-BIND ((VAR EXPR) &BODY BODY)

WHEN-BIND* (BINDS &BODY BODY)

WHILE (TEST &BODY BODY)

WITH-ACCESSORS+ (SLOTS &REST BODY)

WITH-ARRAY (PAT AR &BODY BODY)

WITH-GENSYMS (SYMS &BODY BODY)

WITH-MATRIX (PATS AR &BODY BODY)

WITH-PRINT-CLOCK-CYCLES ((CPU-GHZ &KEY (NORM-F #'IDENTITY) (UNIT-NAME units)) &REST BODY)

WITH-SLOTS+ (SLOTS &REST BODY)

WITH-STRUCT ((NAME . FIELDS) STRUCT &BODY BODY)

WITH-STRUCT-SLOTS ((NAME . FIELDS) STRUCT &BODY BODY)

Private

IN (OBJ &REST CHOICES)

Test whether object is a eql to any of the remaining arguments, faster form of (member obj choices :test #'eql)

INQ (OBJ &REST ARGS)

Same as in but quote the arguments during macroexpansion

Undocumented

>CASE (EXPR &REST CLAUSES)

_F (OP PLACE &REST ARGS)

ALLF (VAL &REST ARGS)

CONC1F (PLACE OBJ &ENVIRONMENT ENV)

CONCF (PLACE OBJ &ENVIRONMENT ENV)

CONCNEW (PLACE OBJ &REST ARGS &ENVIRONMENT ENV)

CONDLET (CLAUSES &BODY BODY)

FN (EXPR)

IF3 (TEST T-CASE NIL-CASE ?-CASE)

IN-IF (FN &REST CHOICES)

NILF (&REST ARGS)

PAT-MATCH (PAT SEQ THEN ELSE)

POPN (N PLACE)

PULL (OBJ PLACE &REST ARGS)

PULL-IF (TEST PLACE &REST ARGS)

SOP (STRING &REST ARGS)

SORTF (OP &REST PLACES)

TF (&REST ARGS)

TOGGLE (&REST ARGS)

TOGGLE2 (PLACE &ENVIRONMENT ENV)

GENERIC-FUNCTION

Public

DROP (STRUCT KEY)

This function drops a keyed value from a collection

Undocumented

CACHE-MAX-OBJECTS (C)

CACHE-OBJECTS (C)

DEQUEUE (Q)

DROP-ENTRY (C KEY)

ENQUEUE (Q DATUM)

FLUSH-CACHE (C)

INDEX-DROP (BIDX ID)

INDEX-GET-BY-ID (BIDX ID)

INDEX-GET-BY-OBJ (BIDX OBJ)

INDEX-GET-ID-OBJ-MAP (BIDX)

INDEX-PUT (BIDX ID OBJ)

INITIALIZE (C &REST REST)

LIST-INSERT (Q QE NEW)

LIST-QUEUE-LIST (QUEUE)

LIST-REMOVE (Q QE)

MAP-CACHE (C FN &KEY OLDEST-FIRST)

MAP-QUEUE (Q FN &KEY REVERSE)

NEW-ID (IDGEN)

PEEK (Q &KEY (LOCATION TOP))

PREDECESSOR (Q &OPTIONAL ITEM)

PUSH-FRONT (Q DATUM)

QUEUE-CLEAR (QUEUE)

QUEUE-ELEMENT-TO-FRONT (QUEUE ELEMENT)

QUEUE-EMPTY-P (QUEUE)

READ-CACHE (C KEY)

REGISTER (REGISTRY OBJECT)

RESIZE (C NEW-SIZE)

SEARCH-FOR-ENTRY (Q ITEM &KEY (TEST #'EQ) KEY HEAD &ALLOW-OTHER-KEYS)

SHOW-CACHE (C &KEY OLDEST-FIRST)

SUCCESSOR (Q &OPTIONAL ITEM)

VALID-ID-P (IDGEN ID)

WRITE-CACHE (C KEY OBJECT &KEY FORCE)

Private

Undocumented

SET-EXPAND (SET)

SLOT-ACCESSOR

Public

Undocumented

QUEUE-HEAD (OBJECT)

SETFQUEUE-HEAD (NEW-VALUE OBJECT)

QUEUE-SIZE (OBJECT)

SETFQUEUE-SIZE (NEW-VALUE OBJECT)

Private

Undocumented

BIDIR-INDEX-BY-ID (OBJECT)

SETFBIDIR-INDEX-BY-ID (NEW-VALUE OBJECT)

BIDIR-INDEX-BY-OBJ (OBJECT)

SETFBIDIR-INDEX-BY-OBJ (NEW-VALUE OBJECT)

GET-DATA (OBJECT)

SETFGET-DATA (NEW-VALUE OBJECT)

ID-GENERATOR-ID (OBJECT)

SETFID-GENERATOR-ID (NEW-VALUE OBJECT)

OBJECT-CACHE-H-Q-INDEX (OBJECT)

SETFOBJECT-CACHE-H-Q-INDEX (NEW-VALUE OBJECT)

OBJECT-CACHE-H-Q-MAX-SIZE (OBJECT)

SETFOBJECT-CACHE-H-Q-MAX-SIZE (NEW-VALUE OBJECT)

OBJECT-CACHE-H-Q-QUEUE (OBJECT)

SETFOBJECT-CACHE-H-Q-QUEUE (NEW-VALUE OBJECT)

OBJECT-CACHE-H-Q-SIZE (OBJECT)

SETFOBJECT-CACHE-H-Q-SIZE (NEW-VALUE OBJECT)

OBJECT-REGISTRY-ID (OBJECT)

SETFOBJECT-REGISTRY-ID (NEW-VALUE OBJECT)

OBJECT-REGISTRY-NAME (OBJECT)

SETFOBJECT-REGISTRY-NAME (NEW-VALUE OBJECT)

PRED (OBJECT)

SETFPRED (NEW-VALUE OBJECT)

SET-MEMBERSHIP (OBJECT)

SETFSET-MEMBERSHIP (NEW-VALUE OBJECT)

SET-REP (OBJECT)

SETFSET-REP (NEW-VALUE OBJECT)

SET-TYPE (OBJECT)

SETFSET-TYPE (NEW-VALUE OBJECT)

SUCC (OBJECT)

SETFSUCC (NEW-VALUE OBJECT)

VARIABLE

Public

*DEFAULT-DAY*

Function which returns the day of month to assume when there is no day of month. The default value of *DEFAULT-DAY* is a function which returns today's day of month.

*DEFAULT-HOUR*

Function which returns the hour to assume when there is no hour. The default value of *DEFAULT-HOUR* is a function which returns noon, which is 12.

*DEFAULT-MONTH*

Function which returns the month to assume when there is no month. The default value of *DEFAULT-MONTH* is a function which returns the current month.

*DEFAULT-YEAR*

Function which returns the year to assume when there is no year. The default value of *DEFAULT-YEAR* is a function which returns the current year.

*FORMAT-TIME-DATE*

Format list for FORMAT-TIME to print a date in a compact, human readable format. It's the day-of-month, abbreviated month name, & the year.

*FORMAT-TIME-FULL*

It's like ISO format except that it's supposed to be readable by humans.

*FORMAT-TIME-ISO8601-LONG*

Format list for FORMAT-TIME to print a date-&-time in the verbose ISO 8061 format. It's verbose because it separates the fields of the date with -, fields of the time with :, & the date from the time with T. So it is arguably human-readable.

*FORMAT-TIME-ISO8601-SHORT*

Format list for FORMAT-TIME to print a date-&-time in the compact ISO 8061 format. It's compact because it's all numbers (as required by the ISO format), & there are no field separators except for the T between the date & the time.

*FORMAT-TIME-TIME*

Format list for FORMAT-TIME to print a human-readable time. The hours are on a 24-hour clock.

Undocumented

*DEFAULT-LANGUAGE*

*DEFAULT-MINUTE*

*DEFAULT-RECOGNIZERS*

*DEFAULT-SECOND*

*DEFAULT-ZONE*

SELF

Private

*AMPM*

Map AM, PM, & O'CLOCK strings to symbols for use when figuring the universal time from a broken time.

*MONTHS*

Map month names & abbreviations to their numbers.

*TERM-PARSERS*

Maps format descriptors to the functions that parse them. Keys are format descriptors, which are strings such as '%Y'. Values are functions which extract & return a CONS for an assoc-list or NIL.

*WEEKDAYS*

Map weekday names & abbreviations to truth. We don't use the weekday when figuring the universal time, so we don't map to anything other than true. The true simply indicates that we recognize the term as a weekday name.

Undocumented

*DEBUG*

*FORMAT-TIME-FNS*

*FORMAT-TIME-MONTHS*

*FORMAT-TIME-WEEKDAYS*

*IDS-WORD*

*SCALABLE-SET-THRESHOLD*

*SET-INTERFACE-DEFINITION*

*STRING-OPS*

*WHITESPACE-CHARS*

*WORD-COUNT*

*WORD-IDS*

*ZONES*

+HEX-CHARS+

+UNAMBIGUOUS-CHARSET+

IF*-KEYWORD-LIST

CLASS

Public

LIST-QUEUE

Queue object, contains the head element and some stats

LIST-QUEUE-ELT

An element forming a queue, the provided element is treated as a head for push/pop operations

OBJECT-CACHE-H-Q

A cache of objects using arbitrary keys

Undocumented

BIDIR-INDEX

ID-GENERATOR

OBJECT-REGISTRY

SAFE-LIST-QUEUE

SCALABLE-SET

Private

Undocumented

BROKEN-TIME

SAFE-LIST-MIXIN

SAFE-QUEUE-MIXIN

CONSTANT

Private

Undocumented

+CHAR-CODE-0+

+CHAR-CODE-LOWER-A+

+CHAR-CODE-UPPER-A+

+UNAMBIGUOUS-LENGTH+