(rapid list)

(xcons d a)

(cons* first . #<undef>)

(circular-list val1)

(proper-list? x)

(dotted-list? x)

(circular-list? x)

(not-pair? x)

(null-list? l)

(list= = . lists)

(length+ x)

(zip list1 . more-lists)

second

third

fourth

(fifth x)

(sixth x)

(seventh x)

(eighth x)

(ninth x)

(tenth x)

(car+cdr pair)

(take lis k)

(drop lis k)

(take! lis k)

(take-right lis k)

(drop-right lis k)

(drop-right! lis k)

(split-at x k)

(split-at! x k)

(last lis)

(last-pair lis)

(unzip1 lis)

(unzip2 lis)

(unzip3 lis)

(unzip4 lis)

(unzip5 lis)

(append! . #<undef>)

(append-reverse rev-head tail)

(append-reverse! rev-head tail)

(concatenate lists)

(concatenate! lists)

(%cdrs lists)

(count pred list1 . lists)

(unfold-right p f g seed . maybe-tail)

(unfold p f g seed . maybe-tail-gen)

(fold kons knil lis1 . lists)

(fold-right kons knil lis1 . lists)

(pair-fold-right f zero lis1 . lists)

(pair-fold f zero lis1 . lists)

(reduce f ridentity lis)

(reduce-right f ridentity lis)

(append-map f lis1 . lists)

(append-map! f lis1 . lists)

(really-append-map who appender f lis1 lists)

(pair-for-each proc lis1 . lists)

(map! f lis1 . lists)

(filter-map f lis1 . lists)

(map-in-order f lis1 . lists)

(filter! pred lis)

(partition pred lis)

(partition! pred lis)

(remove pred l)

(remove! pred l)

(delete x lis)

(delete! x lis)

(delete-duplicates! lis maybe-=)

(alist-copy alist)

(alist-delete key alist)

(alist-delete! key alist)

(find pred list)

(find-tail pred list)

(take-while pred lis)

(drop-while pred lis)

(take-while! pred lis)

(span pred lis)

(span! pred lis)

(break pred lis)

(break! pred lis)

(any pred lis1 . lists)

(every pred lis1 . lists)

(list-index pred lis1 . lists)

(reverse! lis)

(lset<= = . lists)

(lset= = . lists)

(lset-adjoin = lis . elts)

(lset-union = . lists)

(lset-union! = . lists)

(lset-intersection = lis1 . lists)

(lset-intersection! = lis1 . lists)

(lset-difference = lis1 . lists)

(lset-difference! = lis1 . lists)

(lset-xor = . lists)

(lset-xor! = . lists)

(lset-diff+intersection = lis1 . lists)

(lset-diff+intersection! = lis1 . lists)