A Comparison Between my two Word Game Solvers

I've the unfinished parts of an Ada Wordle solver before me, but question whether I'll find the will
to finish it.  The APL would originally mimic the Common Lisp, before it became much more, and yet I
foresee no such thing happening with the Ada, which is likely to heavily resemble the Common Lisp if
I finish it and therefore impart little wisdom to me by the act.  That APL was very revealing, yet I
may have squeezed all of that wisdom obtainable through this exercise by writing it, which suits me.

My Common Lisp solver uses a function named CHECK-WORD returning an array of symbolic results, which
are then processed one-at-a-time.  The APL performs the function of CHECK-WORD and its processor all
at once, on one line, without symbolism.  The plain nature of APL revealed to me simplicities in the
problem which the Common Lisp obscured.  That Common Lisp implementation is slightly flawed in a way
the APL isn't: It miscalculates the minimum letter count in the case where two letters be present in
the word when both are guessed in the wrong positions, reporting the minimum as one rather than two:

(WORDLE::CHECK-WORD "messy" "salts")
#((:SOME #\s 6 1) (:NONE #\a) (:NONE #\l) (:NONE #\t) (:SOME #\s 6 1))

The clarity of the APL made me notice the proper function to determine this count is simple minimum.
This is, as far as I've seen, the only flaw in the Common Lisp solver, and minor at that, but still.
The Ada would show a similar approach to this problem, but not one so fundamentally different as the
two which already are.  Automatic and extreme typechecking during program run is nice, nicer than in
Common Lisp in many ways, but not so nice so as to make new realizations, so perhaps I won't bother.
.