/[gcl]/gcl/info/sequence.texi
ViewVC logotype

Diff of /gcl/info/sequence.texi

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by wfs, Mon Dec 6 22:44:05 1999 UTC revision 1.2 by camm, Sun Feb 3 18:44:07 2002 UTC
# Line 26  Returns a copy of SEQUENCE. Line 26  Returns a copy of SEQUENCE.
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
# Line 62  upper-case, and remaining characters in Line 60  upper-case, and remaining characters in
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
# Line 75  SEQUENCE may be destroyed. Line 71  SEQUENCE may be destroyed.
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
# Line 95  BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or Line 90  BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or
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
# Line 123  Returns STRING with all lower case chara Line 116  Returns STRING with all lower case chara
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
# Line 152  Returns the length of AXIS-NUMBER of ARR Line 143  Returns the length of AXIS-NUMBER of ARR
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
# Line 163  such element exists. Line 152  such element exists.
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.
# Line 182  right end. Line 169  right end.
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
# Line 193  satisfying TEST from SEQUENCE. Line 178  satisfying TEST from SEQUENCE.
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.
# Line 203  Returns a copy of SEQUENCE with elements Line 186  Returns a copy of SEQUENCE with elements
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.
# Line 213  Returns T if the two strings are charact Line 194  Returns T if the two strings are charact
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
# Line 243  INITIAL-ELEMENT. Line 222  INITIAL-ELEMENT.
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
# Line 255  except that OLDITEMs are replaced with N Line 231  except that OLDITEMs are replaced with N
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,
# Line 267  string2 (using char-equal). Line 241  string2 (using char-equal).
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.
# Line 277  Similar to STRING<=, but ignores cases. Line 249  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
# Line 296  Returns T if X is a string; NIL otherwis Line 266  Returns T if X is a string; NIL otherwis
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
# Line 315  Returns T if X is a simple string; NIL o Line 283  Returns T if X is a simple string; NIL o
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.
# Line 341  Returns a list whose elements are the di Line 307  Returns a list whose elements are the di
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
# Line 377  extends VECTOR rather then simply return Line 341  extends VECTOR rather then simply return
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
# Line 389  SEQUENCE. Line 350  SEQUENCE.
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.
# Line 438  Creates and returns a hash table. Line 396  Creates and returns a hash table.
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,
# Line 449  returns the index to the longest common Line 405  returns the index to the longest common
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.
# Line 467  Returns the INDEX-th element of SEQUENCE Line 421  Returns the INDEX-th element of SEQUENCE
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-
# Line 506  nil, will cause the array body to be non Line 457  nil, will cause the array body to be non
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.
# Line 515  characters converted to lowercase. Line 465  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.
# Line 542  otherwise. Line 491  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.
# Line 569  Returns T if X is an array; NIL otherwis Line 516  Returns T if X is an array; NIL otherwis
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
# Line 598  Removes all entries of HASH-TABLE and re Line 543  Removes all entries of HASH-TABLE and re
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
# Line 609  except that all elements satisfying TEST Line 552  except that all elements satisfying TEST
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
# Line 642  the fill pointer is 0. Line 582  the fill pointer is 0.
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
# Line 727  BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or Line 664  BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or
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.
# Line 753  The exclusive upper bound on the rank of Line 689  The exclusive upper bound on the rank of
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.
# Line 780  and remaining characters in the word con Line 714  and remaining characters in the word con
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
# Line 792  of INITIAL-ELEMENT depends on ELEMENT-TY Line 723  of INITIAL-ELEMENT depends on ELEMENT-TY
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
# Line 858  PREDICATE; NIL otherwise. Line 786  PREDICATE; NIL otherwise.
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;
# Line 885  Returns the bit from BIT-ARRAY at SUBSCR Line 812  Returns the bit from BIT-ARRAY at SUBSCR
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.
# Line 955  Returns T if X is a vector; NIL otherwis Line 880  Returns T if X is a vector; NIL otherwis
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
# Line 991  Returns the total number of elements of Line 914  Returns the total number of elements of
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
# Line 1001  TEST; NIL if no such element exists. Line 923  TEST; NIL if no such element exists.
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
# Line 1011  SEQUENCE. Line 932  SEQUENCE.
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.
# Line 1022  Returns the resulting sequence. Line 941  Returns the resulting sequence.
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
# Line 1049  Returns T if every elements of SEQUENCEs Line 967  Returns T if every elements of SEQUENCEs
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.
# Line 1059  If INITIAL-VALUE is supplied, it is logi Line 976  If INITIAL-VALUE is supplied, it is logi
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.

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26