Updated status to reflect that MERGE has been written.

Remaining special versions of MERGE.

Main function for MERGE.

Updated status to reflect existing condition types.

Four more specialized versions of MERGE.

More specialized versions of MERGE, and more comments.

Finalized docstring for MERGE.

More text in the docstring for MERGE, but it is not finished yet.

Updated status to reflect recent docstrings.

Supplied partial docstring for MERGE.

Supplied docstring for CONCATENATE.

Updated status to reflect the existence of more docstrings.

Supplied docstring for REPLACE.

Supplied docstring for MISMATCH.

Fixed a typo in the docstring for SEARCH.

Added a phrase stating the existence of docstrings.

Fixed a typo in the lambda list of the docstring for REPLACE.

Added MISMATCH to the list of shadowed/exported symbols.

Embryonic definitions of MISMATCH and MERGE, only to get
the docstrings on those definitions.

Replaced the phrase "neither a vector nor a list" (or equivalent)
by "not a sequence" to allow for other sequences than vectors
and lists.

Finalized docstring for SEARCH.

Untabified the code, which generated "false" diff lines.

Embryonic docstrings for MISMATCH, REPLACE, CONCATENATE, and MERGE.

Fixed a few typos.

Supplied embryonic docstring for SEARCH.

Supplied docstrings for SORT and STABLE-SORT.

Fixed minor bugs in *key* and *bounding-indexes*.

Supplied docstring for REDUCE.

Supplied docstrings for REVERSE and NREVERSE.

Supplied docstring for MAP-INTO.

Modified the docstring for MAP so as to make references to
any sequence of SEQUENCES more obvious.

Supplied docstring for MAP.

Finished docstring for SUBSEQ.

Finished docstrings for REMOVE-DUPLICATES and DELETE-DUPLICATES.

Supplied embryonic docstrings for SUBSEQ, REMOVE-DUPLICATES, and
DELETE-DUPLICATES.

Supplied docstring for LENGTH.

Introduced an experimental paragraph "Portability notes" in the
docstring.  The idea is that the docstring otherwise reflect a real
implementation and the new paragraph warns the programmer not to rely
on implementation specific behavior.

Supplied a docstring for MAKE-SEQUENCE.

Renamed description of error that might happen about invalid bounding
indexes.

Introduced a description of error that always happens when bounding
indexes are invalid.

Introduced parameter descriptions for just a sequence and just a
sequence index.

Supplied docstrings for ELT and FILL.

Supplied docstring for COPY-SEQ.

Supplied docstrings for NSUBSTITUTE, NSUBSTITUTE-IF,
and NSUBSTITUTE-IF-NOT.

Supplemented the wording about the test being applied in any order,
so that it also mentions that the test can be applied several times
to an element.  Added the new wording to places where it was missing.

Supplied docstrings for SUBSTITUTE, SUBSTITUTE-IF,
and SUBSTITUTE-IF-NOT.

Supplied docstrings for DELETE, DELETE-IF, and DELETE-IF-NOT.

Supplied docstrings for REMOVE, REMOVE-IF, and REMOVE-IF-NOT.

Fixed the description of FIND, FIND-IF and FIND-IF-NOT so that
it applies to all three functions.

Added docstrings for POSITION, POSITION-IF, and POSITION-IF-NOT.

Factored out description of FIND, FIND-IF, and FIND-IF-NOT.

Factored out description of COUNT, COUNT-IF, and COUNT-IF-NOT.

Added a description of the PREDICATE SEQUENCE pair of arguments.

Renamed the description of satisfying the test to reflect that
it is a two-argument test.

Added descriptions of satisfying one argument tests, a positive test
and a negative test.

Added docstrings for FIND-IF, FIND-IF-NOT.

Added docstrings for COUNT-IF, COUNT-IF-NOT.

Factored out exceptional situation for bounding indexes.

Added docstring for COUNT.

Fixed a conflict detected by GIT.

I made an attempt to factor the information in the docstrings.
Hopefully, this will give more maintainable and more consistent
docstrings.

Fixed a few tests that inadvertently assumed that small integers
are eq.  Thanks to _3b on #lisp for spotting this.

Merge branch 'master' of common-lisp.net:/project/sicl/public_html/git/SICL

Fixed an incorrect test.

near-final version

Merge branch 'master' of common-lisp.net:/project/sicl/public_html/git/SICL

Conflicts:
Code/Sequences/sequences.lisp

Minor modifications

ELS 2011 slides

More tests for the `and' and `or' macros.

Changed the implementation of the `and' and `or' macros so
that it checks eagarly for an improper list of forms.

More tests for the cond macro.

Tests for the or macro.

Tests for the and macro.

Tests for the cond macro.

Fixed the heading comment.

Added name-mixin to conditions.

Moved condition reporters to a separate file.

Moved package definition to a separate file.

Added (empty for now) file for English language documentation strings.

Broke out package definitions into a separate file.

Added description for the module.

Added ASDF system definition file.

Broke out English-language condition reporters into a separate file.

Introduced conditions for syntax and semantic analysis.

Implemented a function for checking the order of clauses.

Replaced `named-clause' by `name-clause' to conform to the HyperSpec.

Modified the parsing code so that all clauses are parsed with no
concern about the order.  Later, we need to check the order and
generate appropriate error messages if they are out of order.
Modified the definition of the class loop-body to contain this new
list of all the clauses.  Introduced a function parse-any-clause that
parses any clause.

Modified the code generation to take the new list of all clauses into
account.

Removed the function parse-variable-clause, because it is no longer
needed with the new way of parsing clauses.

Removed the function parse-main-clause, because it is no longer needed
with the new way of parsing clauses.

Added a comment about the HyperSpec definition of the conditional
clause.  Renamed existing function `parse-conditional' to
`parse-conditional-remaining' and introduced a "normal" parser called
`parse-conditional' that just does an alternative parse of if/when and
unless.

Added a comment about the HyperSpec definition of the termination-test
clause.  Renamed existing function `parse-termination-test' to
`parse-termination-test-remaining' and introduced a "normal" parser
called `parse-termination-test' that just does an alternative parse of
if/when and unless.

All tests pass (there are not very many, but still).

Fixed a problem where (form clause) was called on a do-clause, but
do-clause has multiple forms, so it should be `(progn ,(forms
clause)).

Another way of fixing this would have been to put the progn in the
clause instead.  I don't know what is best.

More comments relevant to clause syntax.

More comments related to HyperSpec grammar definitions of clauses.

Removed an incorrect definition of do-clause.  The correct one was
already in there.

More comments related to syntax of clauses.

Changed the file header comment to be more accurate.

Added comments to describe named-clause, d-var-spec type-spec,
simple-type-spec, destructured-type-spec, d-type-spec, and with-clause.

Added description of the project.

Merge branch 'master' of ssh://common-lisp.net//project/sicl/public_html/git/SICL

Started implementing code generation for following clauses:
while, until, repeat, with, initially, finally, collect, sum, do.

Removed comments that won't be valid after reorganization.

Reordered arguments and components of names of specialized versions of
remove and delete in order make argument order and naming more
uniform.

Made sure the tests that compare a stupid version with the real one
do not attempt to run a test where end < start.

English language condition reporter for condition to use when
end < start.

New condition to be used when end < start.

Modified more functions to use test-p and test-not-p.

Fixed a few problems reported by the compiler.

Put back code that was accidentally removed.

Merge branch 'master' of rstrandh@common-lisp.net:/project/sicl/public_html/git/SICL

Conflicts:
Code/Sequences/sequences.lisp

Started work on the nsubstitute function to get special versions
that specialize on everything except the sequence type.

Changed from-end=t to from-end=true everywhere so as to reflect the
fact that from-end can be any generalized boolean.

For count, count-if, and count-if-not: introduced special versions
that are specialized on all the keyword parameters, but not on the
sequence type, and changed the main functions to use those new
versions.  The reason for this is that the corresponding compiler
macros (that have not been written yet) will not be able to determine
the sequence type, but can determine they keyword parameters, so the
compiler macros will use these new specialized functions.  The result
is that only the sequence type will have to be determined at execution
time, or perhaps not even then if the compiler can determine the type
by using type inference.

Fixed a problem in tail-must-be-proper-list-with-end revealed
by latest tests.

Fixed a problem in copy-prefix revealed by latest tests.

Fixed some of the problems in remove, remove-if, and remove-if-not
revealed by the latest tests.

Fixed some of the problems revealed by the latest test of the
remove function.

Fixed some of the defects revealed by the latest test of the
remove function.  Many still remain.

Added tests for the remove function.  These tests compare the stupid
implementation of remove to the real one.  Several defects are
revealed.

Wrote a stupid version of remove to use for testing purposes.

Modified remove-if-not in the same spirit as remove-if.

Modified remove-if in the same spirit as remove.

Renamed parameters to remove-if from test/test-not to predicate.

Modified specialized versions of the remove function when count=other
and from-end=t to use the new method of scanning a list from the end.

Introduced a utility function named copy-prefix to use with the
remove-family functions when seq-type=list.  Also applied some code
factoring to use other utility functions.

Currently, the find-family functions are all wrong for from-end=true
and count=other, because they destructively reverse the interval to be
checked.  It does put it back later, but in the presence of threads,
the current behavior is probably not wanted.  The plan, instead, is to
use the new method for scanning lists from end without consuming too
much stack.

Did some significant code factoring in count, count-if, and
count-if-not.  Also applied new method for scanning list from the end
when this is called for in count-if and count-if-not.  There are no
cases where we can cheat in those functions because the predicate may
be any function.  We *could* guess some common predicates that have no
side effects, but it probably is not worth it.

Made the presentation less verbose when tests pass.

Fixed a problem in stupid-count-if and stupid-count-if-not that
made most of the tests fail, even though they should have passed.

New method for traversing lists from the end, which is required by
some sequence functions, in particular count when from-end is true.
This method uses recursion, and traverses during backtrack, but it
limits the stack depth to some fixed amount that can be set for
each implementation.

Modified existing specialized versions of count to take advantage of
the new method.  Some of them were correct in that they traversed from
end, using an auxiliary vector.  Some of them were wrong, because they
would scan from start to end even though key=other, so the key
function could have side effects, and so scanning from start to end
would have been a violation of the standard.

This new method gives us a very fast version of count when from-end is
true and either key is not identity or either test or test-not is
neither eql nor eq, i.e., when the test and/or the key might have side
effects.  We have observed execution times of only 1/3 of those of
SBCL on long lists.

Even though there is no requirement that the list be scanned from the
end when from-end is true in functions such as find, scanning from the
beginning can be penalizing when the test and/or the key functions are
costly to execute.  We might use our new method for those cases as
well, thus potentially saving a lot when the item looked for is close
to the end of the list.

More utility functions to use at the end of lists.

More renamings in order that the code conform to recent naming
conventions.

The entire code is in a limbo now.  Many tests fail.  This is work in
progress to get it back into a reasonable state.

Wrote tests for count, count-if, and count-if-not.  These tests
reveal several failures.

Introduced test-p and test-not-p into the count function,
so as to distinguish between the case where one of those
keyword argument is not given, or when an explicit nil is given.

Fixed a problem where the wrong specialized function was called when
neither test nor test-not were given.

Massive modifications due to several failures revealed by
improved tests.  Now all tests pass, but the coverage is still
low (around 15%).  But with the new testing strategy, this number
will now improve fairly rapidly.

Make it easier to identify the failed function.

Total change of strategy with respect to testing the sequence
functions.  It is just too time consuming and error prone to attempt
to list all relevant combinations of parameter values.  Instead, I now
automate the process by comparing values to a "stupid" version.

This strategy allows us to automatically generate many possible
combinations of arguments.

Unfortunately, this strategy makes lisp-unit less useful than it could
be.  I haven't made any decision as to whether to continue using it.

Many more tests for the position function.  Some fail.

Many more tests for the position function.