Common Lisp Package: UTILS-KT

README:

FUNCTION

Public

Undocumented

-1?1 (X)

ABBREV$ (LONG$ MAX)

ALPHA$ (S)

ASSOCD (X Y)

BRK (&REST ARGS)

CC$ (CODE)

CHAR$ (CHAR)

CLASS-PROTO (C)

CLOCK (&REST KEYS &AUX (NOW (GET-INTERNAL-REAL-TIME)))

CLOCK-0 (KEY &AUX (NOW (GET-INTERNAL-REAL-TIME)))

CLOCK-OFF (KEY)

COLLECT (X LIST &KEY (KEY 'IDENTITY) (TEST 'EQL))

COLLECT-IF (TEST LIST)

CONC$ (&REST SS)

CONC-LIST$ (SS)

COUNT-OF (KEY)

DD-MMM-YY (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

DOWN$ (S)

EMPTY$ (S)

EQUAL$ (S1 S2)

FIFO-ADD (Q NEW)

FIFO-CLEAR (Q)

FIFO-DATA (Q)

FIFO-DELETE (Q DEAD)

FIFO-EMPTY (Q)

FIFO-LENGTH (Q)

FIFO-MAP (Q FN)

FIFO-PEEK (Q)

FIFO-POP (Q)

FIND-AFTER (X L)

FIND-BEFORE (X L)

HASHTABLE-ASSOC (H)

HOUR-MIN-OF-DAY (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

INSERT$ (S C &OPTIONAL (OFFSET (LENGTH S)))

INTERN$ (&REST STRINGS)

LAST1 (THING)

LEFT$ (S N)

LIST-FLATTEN! (&REST LIST)

LIST-INSERT-AFTER (LIST AFTER NEW)

LOWER$ (S)

M/D/Y (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

MAKE$ (&OPTIONAL (SIZE 0) (CHAR ))

MAKE-FIFO-QUEUE (&REST INIT-DATA)

MAPHASH* (F H)

MATCH-LEFT$ (A B)

MDYY-YYMD (D)

MID$ (S OFFSET LENGTH)

MIN$ (&REST SS)

MM-SS (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

MM/DD (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

MMM-DD-YYYY (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

MONTH-ABBREVIATION (MONTH)

MPT (&REST ARGS)

NORMALIZE$ (S)

NOW

NUMERIC$ (S &OPTIONAL TRIMMED)

OS-TICKCOUNT

PACKED-FLAT! (&REST U-NAMEIT)

PAIR-OFF (LIST &OPTIONAL (TEST 'EQL))

PRIME? (N)

PROJECT-PATH

RASSOCA (X Y)

REMOVE$ (S OFFSET)

RIGHT$ (S N)

SEG$ (S OFFSET END)

SHUFFLE (LIST &KEY (TEST 'IDENTITY))

SPACE$ (SIZE)

SPLIT-SEQUENCE (DELIMITER SEQ &KEY (COUNT NIL) (REMOVE-EMPTY-SUBSEQS NIL) (FROM-END NIL) (START 0) (END NIL) (TEST NIL TEST-SUPPLIED) (TEST-NOT NIL TEST-NOT-SUPPLIED) (KEY NIL KEY-SUPPLIED))

STRLOC$ (SUBSTR STR)

SUBSEQ-EX (SEQ START END)

TEST-INIT (&OPTIONAL DRIB)

TEST-PREP (&OPTIONAL DRIB)

TEST-SETUP (&OPTIONAL DRIB)

TIME-IN-ZONE (INZONE &OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

TIME-OF-DAY (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

TREE-FLATTEN (TREE)

TREE-INCLUDES (SOUGHT TREE &KEY (TEST 'EQL))

TREE-INTERSECT (T1 T2 &KEY (TEST 'EQL))

TREE-TRAVERSE (TREE FN)

TRIM$ (S)

TRUE (IT)

TRUNC$ (S CHAR)

U-DATE (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

U-DAY (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

U-TIME (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

UP$ (S)

UPPER$ (S)

UTILS-KT-RESET

WEEK-TIME (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

WEEKDAY-ABBREVIATION (DAY)

WITHOUT-REPEATING (KEY ALL &OPTIONAL (DECENT-INTERVAL (FLOOR (LENGTH ALL) 2)))

XOR (C1 C2)

YMDHMSH (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

YYYY-MM-DD (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

Private

Undocumented

BASIC$

CALL-COUNT-IT (&REST KEYS)

COUNT-CLEAR (ANNOUNCE &REST MSG)

FALSE (IT)

FIFO-BROWSE (Q FN)

HYPHENATED-TIME-STRING

MAX-IF (&REST VALUES)

MIN-IF (V1 V2)

MIN-MAX-OF (V1 V2)

RESET-WITHOUT-REPEATING

SHOW-COUNT (CLEARP &REST MSG &AUX ANNOUNCED)

SOURCE-LINE-COUNT (PATH NO-SEMIS)

SPLIT-SEQUENCE-IF (PREDICATE SEQ &KEY (COUNT NIL) (REMOVE-EMPTY-SUBSEQS NIL) (FROM-END NIL) (START 0) (END NIL) (KEY NIL KEY-SUPPLIED))

SPLIT-SEQUENCE-IF-NOT (PREDICATE SEQ &KEY (COUNT NIL) (REMOVE-EMPTY-SUBSEQS NIL) (FROM-END NIL) (START 0) (END NIL) (KEY NIL KEY-SUPPLIED))

STOP-CHECK (&OPTIONAL (WHERE UNSPECIFIED))

U-DAY3 (&OPTIONAL (I-TIME (GET-UNIVERSAL-TIME)))

WITHOUT-REPEATING-GENERATOR (DECENT-INTERVAL ALL)

MACRO

Public

DEFINE-CONSTANT (NAME VALUE &OPTIONAL DOCSTRING)

Define a constant properly. If NAME is unbound, DEFCONSTANT it to VALUE. If it is already bound, and it is EQUAL to VALUE, reuse the SYMBOL-VALUE of NAME. Otherwise, DEFCONSTANT it again, resulting in implementation-specific behavior.

Undocumented

ASSOC$ (ITEM ALIST &REST KWS)

B-IF (BINDVAR BOUNDFORM YUP &OPTIONAL NOPE)

B-WHEN (BINDVAR BOUNDFORM &BODY BODY)

B1 ((BINDVAR BOUNDFORM) &BODY BODY)

BIF ((BINDVAR BOUNDFORM) YUP &OPTIONAL NOPE)

BWHEN ((BINDVAR BOUNDFORM) &BODY BODY)

CASE$ (STRING-FORM &REST CASES)

CASE-STRING-EQUAL (STRING-FORM &REST CASES)

CC-DEFSTRUCT (HEADER &REST SLOTS)

COUNT-IT (&REST KEYS)

COUNT-IT! (&REST KEYS)

DSB (B F &BODY BOD)

EO (X Y)

EVAL-NOW! (&BODY BODY)

EXPORT! (&REST SYMBOLS)

FIND$ (IT WHERE &REST ARGS)

LIST-INSERTF (PLACE ITEM &KEY AFTER)

MAPTIMES ((NVAR COUNT) &BODY BODY)

MEMBER$ (ITEM LIST &REST KWS)

MULTIPLE-VALUE-BIND (VARS VALUE-FORM &BODY BODY)

MVB (B F &BODY BOD)

PUSH-END (ITEM PLACE)

TIMEX ((ONP &REST TRCARGS) &BODY BODY)

WDBG (&BODY BODY)

WITH-COUNTS ((ONP &REST MSG) &BODY BODY)

WITH-DYNAMIC-FN ((FN-NAME (&REST FN-ARGS) &BODY FN-BODY) &BODY BODY)

WITH-FIFO-MAP ((POP-VAR Q) &BODY BODY)

WITH-GENSYMS ((&REST SYMBOLS) &BODY BODY)

WITH-METRICS ((COUNTP TIMEP &REST TRCARGS) FORM-MEASURED &BODY POSTLUDE)

Private

Undocumented

UNTIL (TEST &BODY BODY)

WHILE (TEST &BODY BODY)

GENERIC-FUNCTION

Public

Undocumented

INSTANCE-SLOTS (SELF)

NUM$ (N)

SHORTC (OTHER)

Private

Undocumented

EMPTY (NADA)

LONGC (OTHER)

VARIABLE

Public

Undocumented

*COUNT*

*STOP*

Private

Undocumented

*COUNTING*

*LF$*

*MPSTART*

*RETURN$*

*STOPPED*

*WITHOUT-REPEATING-GENERATORS*