26 |
|
|
27 |
@end defun |
@end defun |
28 |
|
|
29 |
@defun POSITION (item sequence |
@defun POSITION (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (key #'identity)) |
|
30 |
Package:LISP |
Package:LISP |
31 |
|
|
32 |
Returns the index of the first element in SEQUENCE that satisfies TEST with |
Returns the index of the first element in SEQUENCE that satisfies TEST with |
60 |
|
|
61 |
@end defun |
@end defun |
62 |
|
|
63 |
@defun NSUBSTITUTE-IF-NOT (new test sequence |
@defun NSUBSTITUTE-IF-NOT (new test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
64 |
Package:LISP |
Package:LISP |
65 |
|
|
66 |
Returns a sequence of the same kind as SEQUENCE with the same elements |
Returns a sequence of the same kind as SEQUENCE with the same elements |
71 |
|
|
72 |
@end defun |
@end defun |
73 |
|
|
74 |
@defun FIND-IF (test sequence |
@defun FIND-IF (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
75 |
Package:LISP |
Package:LISP |
76 |
|
|
77 |
Returns the index of the first element in SEQUENCE that satisfies TEST; NIL if |
Returns the index of the first element in SEQUENCE that satisfies TEST; NIL if |
90 |
|
|
91 |
@end defun |
@end defun |
92 |
|
|
93 |
@defun STRING< (string1 string2 |
@defun STRING< (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
94 |
Package:LISP |
Package:LISP |
95 |
|
|
96 |
If STRING1 is lexicographically less than STRING2, then returns the longest |
If STRING1 is lexicographically less than STRING2, then returns the longest |
116 |
|
|
117 |
@end defun |
@end defun |
118 |
|
|
119 |
@defun STRING>= (string1 string2 |
@defun STRING>= (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
120 |
Package:LISP |
Package:LISP |
121 |
|
|
122 |
If STRING1 is lexicographically greater than or equal to STRING2, then returns |
If STRING1 is lexicographically greater than or equal to STRING2, then returns |
143 |
|
|
144 |
@end defun |
@end defun |
145 |
|
|
146 |
@defun FIND (item sequence |
@defun FIND (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (key #'identity)) |
|
147 |
Package:LISP |
Package:LISP |
148 |
|
|
149 |
Returns the first element in SEQUENCE satisfying TEST with ITEM; NIL if no |
Returns the first element in SEQUENCE satisfying TEST with ITEM; NIL if no |
152 |
|
|
153 |
@end defun |
@end defun |
154 |
|
|
155 |
@defun STRING-NOT-EQUAL (string1 string2 |
@defun STRING-NOT-EQUAL (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
156 |
Package:LISP |
Package:LISP |
157 |
|
|
158 |
Similar to STRING=, but ignores cases. |
Similar to STRING=, but ignores cases. |
169 |
|
|
170 |
@end defun |
@end defun |
171 |
|
|
172 |
@defun DELETE-IF-NOT (test sequence |
@defun DELETE-IF-NOT (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
173 |
Package:LISP |
Package:LISP |
174 |
|
|
175 |
Returns a sequence formed by destructively removing the elements not |
Returns a sequence formed by destructively removing the elements not |
178 |
|
|
179 |
@end defun |
@end defun |
180 |
|
|
181 |
@defun REMOVE-IF-NOT (test sequence |
@defun REMOVE-IF-NOT (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
182 |
Package:LISP |
Package:LISP |
183 |
|
|
184 |
Returns a copy of SEQUENCE with elements not satisfying TEST removed. |
Returns a copy of SEQUENCE with elements not satisfying TEST removed. |
186 |
|
|
187 |
@end defun |
@end defun |
188 |
|
|
189 |
@defun STRING= (string1 string2 |
@defun STRING= (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
190 |
Package:LISP |
Package:LISP |
191 |
|
|
192 |
Returns T if the two strings are character-wise CHAR=; NIL otherwise. |
Returns T if the two strings are character-wise CHAR=; NIL otherwise. |
194 |
|
|
195 |
@end defun |
@end defun |
196 |
|
|
197 |
@defun NSUBSTITUTE-IF (new test sequence |
@defun NSUBSTITUTE-IF (new test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
198 |
Package:LISP |
Package:LISP |
199 |
|
|
200 |
Returns a sequence of the same kind as SEQUENCE with the same elements |
Returns a sequence of the same kind as SEQUENCE with the same elements |
222 |
|
|
223 |
@end defun |
@end defun |
224 |
|
|
225 |
@defun NSUBSTITUTE (newitem olditem sequence |
@defun NSUBSTITUTE (newitem olditem sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (count most-positive-fixnum) |
|
|
(key #'identity)) |
|
226 |
Package:LISP |
Package:LISP |
227 |
|
|
228 |
Returns a sequence of the same kind as SEQUENCE with the same elements |
Returns a sequence of the same kind as SEQUENCE with the same elements |
231 |
|
|
232 |
@end defun |
@end defun |
233 |
|
|
234 |
@defun STRING-EQUAL (string1 string2 |
@defun STRING-EQUAL (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
235 |
Package:LISP |
Package:LISP |
236 |
|
|
237 |
Given two strings (string1 and string2), and optional integers start1, |
Given two strings (string1 and string2), and optional integers start1, |
241 |
|
|
242 |
@end defun |
@end defun |
243 |
|
|
244 |
@defun STRING-NOT-GREATERP (string1 string2 |
@defun STRING-NOT-GREATERP (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
245 |
Package:LISP |
Package:LISP |
246 |
|
|
247 |
Similar to STRING<=, but ignores cases. |
Similar to STRING<=, but ignores cases. |
249 |
|
|
250 |
@end defun |
@end defun |
251 |
|
|
252 |
@defun STRING> (string1 string2 |
@defun STRING> (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
253 |
Package:LISP |
Package:LISP |
254 |
|
|
255 |
If STRING1 is lexicographically greater than STRING2, then returns the |
If STRING1 is lexicographically greater than STRING2, then returns the |
266 |
|
|
267 |
@end defun |
@end defun |
268 |
|
|
269 |
@defun DELETE-IF (test sequence |
@defun DELETE-IF (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
270 |
Package:LISP |
Package:LISP |
271 |
|
|
272 |
Returns a sequence formed by removing the elements satisfying TEST |
Returns a sequence formed by removing the elements satisfying TEST |
283 |
|
|
284 |
@end defun |
@end defun |
285 |
|
|
286 |
@defun REMOVE-IF (test sequence |
@defun REMOVE-IF (test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
287 |
Package:LISP |
Package:LISP |
288 |
|
|
289 |
Returns a copy of SEQUENCE with elements satisfying TEST removed. |
Returns a copy of SEQUENCE with elements satisfying TEST removed. |
307 |
|
|
308 |
@end defun |
@end defun |
309 |
|
|
310 |
@defun SUBSTITUTE-IF-NOT (new test sequence |
@defun SUBSTITUTE-IF-NOT (new test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
311 |
Package:LISP |
Package:LISP |
312 |
|
|
313 |
Returns a sequence of the same kind as SEQUENCE with the same elements |
Returns a sequence of the same kind as SEQUENCE with the same elements |
341 |
|
|
342 |
@end defun |
@end defun |
343 |
|
|
344 |
@defun DELETE (item sequence |
@defun DELETE (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (count most-positive-fixnum) |
|
|
(key #'identity)) |
|
345 |
Package:LISP |
Package:LISP |
346 |
|
|
347 |
Returns a sequence formed by removing the specified ITEM destructively from |
Returns a sequence formed by removing the specified ITEM destructively from |
350 |
|
|
351 |
@end defun |
@end defun |
352 |
|
|
353 |
@defun REMOVE (item sequence |
@defun REMOVE (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (count most-positive-fixnum) |
|
|
(key #'identity)) |
|
354 |
Package:LISP |
Package:LISP |
355 |
|
|
356 |
Returns a copy of SEQUENCE with ITEM removed. |
Returns a copy of SEQUENCE with ITEM removed. |
396 |
|
|
397 |
@end defun |
@end defun |
398 |
|
|
399 |
@defun STRING/= (string1 string2 |
@defun STRING/= (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
400 |
Package:LISP |
Package:LISP |
401 |
|
|
402 |
Returns NIL if STRING1 and STRING2 are character-wise CHAR=. Otherwise, |
Returns NIL if STRING1 and STRING2 are character-wise CHAR=. Otherwise, |
405 |
|
|
406 |
@end defun |
@end defun |
407 |
|
|
408 |
@defun STRING-GREATERP (string1 string2 |
@defun STRING-GREATERP (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
409 |
Package:LISP |
Package:LISP |
410 |
|
|
411 |
Similar to STRING>, but ignores cases. |
Similar to STRING>, but ignores cases. |
421 |
|
|
422 |
@end defun |
@end defun |
423 |
|
|
424 |
@defun MAKE-ARRAY (dimensions |
@defun MAKE-ARRAY (dimensions &key (element-type t) initial-element (initial-contents nil) (adjustable nil) (fill-pointer nil) (displaced-to nil) (displaced-index-offset 0) static) |
|
&key (element-type t) initial-element (initial-contents nil) |
|
|
(adjustable nil) (fill-pointer nil) (displaced-to nil) |
|
|
(displaced-index-offset 0) static) |
|
425 |
Package:LISP |
Package:LISP |
426 |
|
|
427 |
Creates an array of the specified DIMENSIONS. The default for INITIAL- |
Creates an array of the specified DIMENSIONS. The default for INITIAL- |
457 |
|
|
458 |
@end defun |
@end defun |
459 |
|
|
460 |
@defun NSTRING-DOWNCASE (string &key |
@defun NSTRING-DOWNCASE (string &key (start 0) (end (length string))) |
|
(start 0) (end (length string))) |
|
461 |
Package:LISP |
Package:LISP |
462 |
Returns STRING with all upper case |
Returns STRING with all upper case |
463 |
characters converted to lowercase. |
characters converted to lowercase. |
465 |
|
|
466 |
@end defun |
@end defun |
467 |
|
|
468 |
@defun ARRAY-IN-BOUNDS-P (array |
@defun ARRAY-IN-BOUNDS-P (array &rest subscripts) |
|
&rest subscripts) |
|
469 |
Package:LISP |
Package:LISP |
470 |
Returns T if SUBSCRIPTS are valid subscripts for |
Returns T if SUBSCRIPTS are valid subscripts for |
471 |
ARRAY; NIL otherwise. |
ARRAY; NIL otherwise. |
491 |
|
|
492 |
@end defun |
@end defun |
493 |
|
|
494 |
@defun COUNT-IF-NOT (test |
@defun COUNT-IF-NOT (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
sequence |
|
|
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
495 |
Package:LISP |
Package:LISP |
496 |
|
|
497 |
Returns the number of elements in SEQUENCE not satisfying TEST. |
Returns the number of elements in SEQUENCE not satisfying TEST. |
516 |
|
|
517 |
@end defun |
@end defun |
518 |
|
|
519 |
@defun REPLACE (sequence1 sequence2 |
@defun REPLACE (sequence1 sequence2 &key (start1 0) (end1 (length sequence1)) (start2 0) (end2 (length sequence2))) |
|
&key (start1 0) (end1 (length sequence1)) |
|
|
(start2 0) (end2 (length sequence2))) |
|
520 |
Package:LISP |
Package:LISP |
521 |
|
|
522 |
Destructively modifies SEQUENCE1 by copying successive elements into it from |
Destructively modifies SEQUENCE1 by copying successive elements into it from |
543 |
|
|
544 |
@end defun |
@end defun |
545 |
|
|
546 |
@defun SUBSTITUTE-IF (newitem test sequence |
@defun SUBSTITUTE-IF (newitem test sequence &key (from-end nil) (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) |
|
|
(count most-positive-fixnum) (key #'identity)) |
|
547 |
Package:LISP |
Package:LISP |
548 |
|
|
549 |
Returns a sequence of the same kind as SEQUENCE with the same elements |
Returns a sequence of the same kind as SEQUENCE with the same elements |
552 |
|
|
553 |
@end defun |
@end defun |
554 |
|
|
555 |
@defun MISMATCH (sequence1 sequence2 |
@defun MISMATCH (sequence1 sequence2 &key (from-end nil) (test #'eql) test-not (start1 0) (start2 0) (end1 (length sequence1)) (end2 (length sequence2)) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start1 0) (start2 0) |
|
|
(end1 (length sequence1)) (end2 (length sequence2)) |
|
|
(key #'identity)) |
|
556 |
Package:LISP |
Package:LISP |
557 |
|
|
558 |
The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared |
The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared |
582 |
|
|
583 |
@end defun |
@end defun |
584 |
|
|
585 |
@defun SUBSTITUTE (newitem olditem sequence |
@defun SUBSTITUTE (newitem olditem sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (count most-positive-fixnum) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (count most-positive-fixnum) |
|
|
(key #'identity)) |
|
586 |
Package:LISP |
Package:LISP |
587 |
|
|
588 |
Returns a sequence of the same kind as SEQUENCE with the same elements |
Returns a sequence of the same kind as SEQUENCE with the same elements |
664 |
|
|
665 |
@end defun |
@end defun |
666 |
|
|
667 |
@defun COUNT-IF (test sequence |
@defun COUNT-IF (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
668 |
Package:LISP |
Package:LISP |
669 |
|
|
670 |
Returns the number of elements in SEQUENCE satisfying TEST. |
Returns the number of elements in SEQUENCE satisfying TEST. |
689 |
|
|
690 |
@end defvr |
@end defvr |
691 |
|
|
692 |
@defun COUNT (item sequence |
@defun COUNT (item sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (key #'identity)) |
|
693 |
Package:LISP |
Package:LISP |
694 |
|
|
695 |
Returns the number of elements in SEQUENCE satisfying TEST with ITEM. |
Returns the number of elements in SEQUENCE satisfying TEST with ITEM. |
714 |
|
|
715 |
@end defun |
@end defun |
716 |
|
|
717 |
@defun ADJUST-ARRAY (array dimensions |
@defun ADJUST-ARRAY (array dimensions &key (element-type (array-element-type array)) initial-element (initial-contents nil) (fill-pointer nil) (displaced-to nil) (displaced-index-offset 0)) |
|
&key (element-type (array-element-type array)) |
|
|
initial-element (initial-contents nil) (fill-pointer nil) |
|
|
(displaced-to nil) (displaced-index-offset 0)) |
|
718 |
Package:LISP |
Package:LISP |
719 |
|
|
720 |
Adjusts the dimensions of ARRAY to the given DIMENSIONS. The default value |
Adjusts the dimensions of ARRAY to the given DIMENSIONS. The default value |
723 |
|
|
724 |
@end defun |
@end defun |
725 |
|
|
726 |
@defun SEARCH (sequence1 sequence2 |
@defun SEARCH (sequence1 sequence2 &key (from-end nil) (test #'eql) test-not (start1 0) (start2 0) (end1 (length sequence1)) (end2 (length sequence2)) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start1 0) (start2 0) |
|
|
(end1 (length sequence1)) (end2 (length sequence2)) |
|
|
(key #'identity)) |
|
727 |
Package:LISP |
Package:LISP |
728 |
|
|
729 |
A search is conducted for the first subsequence of SEQUENCE2 which |
A search is conducted for the first subsequence of SEQUENCE2 which |
786 |
|
|
787 |
@end defun |
@end defun |
788 |
|
|
789 |
@defun POSITION-IF-NOT (test sequence |
@defun POSITION-IF-NOT (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
790 |
Package:LISP |
Package:LISP |
791 |
|
|
792 |
Returns the index of the first element in SEQUENCE that does not satisfy TEST; |
Returns the index of the first element in SEQUENCE that does not satisfy TEST; |
812 |
|
|
813 |
@end defun |
@end defun |
814 |
|
|
815 |
@defun STRING-NOT-LESSP (string1 string2 |
@defun STRING-NOT-LESSP (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
816 |
Package:LISP |
Package:LISP |
817 |
|
|
818 |
Similar to STRING>=, but ignores cases. |
Similar to STRING>=, but ignores cases. |
880 |
|
|
881 |
@end defun |
@end defun |
882 |
|
|
883 |
@defun STRING<= (string1 string2 |
@defun STRING<= (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
884 |
Package:LISP |
Package:LISP |
885 |
|
|
886 |
If STRING1 is lexicographically less than or equal to STRING2, then returns |
If STRING1 is lexicographically less than or equal to STRING2, then returns |
914 |
|
|
915 |
@end defun |
@end defun |
916 |
|
|
917 |
@defun FIND-IF-NOT (test sequence |
@defun FIND-IF-NOT (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
918 |
Package:LISP |
Package:LISP |
919 |
|
|
920 |
Returns the index of the first element in SEQUENCE that does not satisfy |
Returns the index of the first element in SEQUENCE that does not satisfy |
923 |
|
|
924 |
@end defun |
@end defun |
925 |
|
|
926 |
@defun DELETE-DUPLICATES (sequence &key (from-end nil) (test #'eql) test-not (start 0) |
@defun DELETE-DUPLICATES (sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) |
|
(end (length sequence)) (key #'identity)) |
|
927 |
Package:LISP |
Package:LISP |
928 |
|
|
929 |
Returns a sequence formed by removing duplicated elements destructively from |
Returns a sequence formed by removing duplicated elements destructively from |
932 |
|
|
933 |
@end defun |
@end defun |
934 |
|
|
935 |
@defun REMOVE-DUPLICATES (sequence |
@defun REMOVE-DUPLICATES (sequence &key (from-end nil) (test #'eql) test-not (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (test #'eql) test-not (start 0) |
|
|
(end (length sequence)) (key #'identity)) |
|
936 |
Package:LISP |
Package:LISP |
937 |
|
|
938 |
The elements of SEQUENCE are examined, and if any two match, one is discarded. |
The elements of SEQUENCE are examined, and if any two match, one is discarded. |
941 |
|
|
942 |
@end defun |
@end defun |
943 |
|
|
944 |
@defun POSITION-IF (test sequence |
@defun POSITION-IF (test sequence &key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity)) |
|
945 |
Package:LISP |
Package:LISP |
946 |
|
|
947 |
Returns the index of the first element in SEQUENCE that satisfies TEST; NIL |
Returns the index of the first element in SEQUENCE that satisfies TEST; NIL |
967 |
|
|
968 |
@end defun |
@end defun |
969 |
|
|
970 |
@defun REDUCE (function sequence |
@defun REDUCE (function sequence &key (from-end nil) (start 0) (end (length sequence)) initial-value) |
|
&key (from-end nil) (start 0) (end (length sequence)) initial-value) |
|
971 |
Package:LISP |
Package:LISP |
972 |
|
|
973 |
Combines all the elements of SEQUENCE using a binary operation FUNCTION. |
Combines all the elements of SEQUENCE using a binary operation FUNCTION. |
976 |
|
|
977 |
@end defun |
@end defun |
978 |
|
|
979 |
@defun STRING-LESSP (string1 string2 |
@defun STRING-LESSP (string1 string2 &key (start1 0) (end1 (length string1)) (start2 0) (end2 (length string2))) |
|
&key (start1 0) (end1 (length string1)) |
|
|
(start2 0) (end2 (length string2))) |
|
980 |
Package:LISP |
Package:LISP |
981 |
|
|
982 |
Similar to STRING<, but ignores cases. |
Similar to STRING<, but ignores cases. |