The language is improved.
[Tiny] The parameter name FN is changed to OP.

I call all of function, macro and special operators as ``operators'' in
one piece. I'm now planning to modify the PAPPLY macro series to accept
other than functions as its first parameter.

Actually speaking, it was planned when I wrote APAPPLY macro and
therefore the parameter that takes a function is named OP in APAPPLY
macro.
Macros and special operators are valid first arguments of PAPPLY series.

The first argument of PAPPLY macro series, the operators, can now accept
macros and special operators.
Concretely speaking, forms like #'(if (some _ lst) lst 'none) is now
made acceptable.

Since macros and special operators are not able to partial apply in a
straightforward way, the current implementation requires to be passed
forms for all the required parameters. Following form is not valid for
example:

    (p (if (some _ lst)))

In this case, what the user have to write is as follows:

    (p (if (some _ lst) _))

or

    (p (if (some _ lst) _ _))

the former one is applicable because the third parameter of IF special
operator is an optional parameter not a required parameter.

Please be aware that what the user wanted to express by the first
invalid form is almost completely incarnated by the second or third one.
If the number of arguments the user want to pass to the returned
function varies, then there is no way to make such function by PAPPLY
macro series. If the first argument is a function, then it is possible
of course.

    (p (find _ lst))

This function can be used with, for example, :test keyword argument if
we want. If that is not needed, then we can pass only one argument.

    (funcall (p (find _ lst)) 1)
    (funcall (p (find _ lst)) 2 : :test #'<)

However, follwing form is not valid.

    (funcall (p (find _ lst) _ _) 1)

While the next one is valid.

    (funcall (p (find _ lst) _ _) 1 :test #'<)

Macros and Special operators accept only this type of form. They
requires to explicitly express the arguments (by _ or anaphoras) which
will be passed, and PAPPLY series force to pass all the explicitly
expressed arguments when the generated function is called. Following
form is invalid even though LIST function accepts an arbitrary number of
arguments.

    (funcall (p (lst _ _)) 1)