A Comparison Between my Comprehensive SHA Implementations

This is a continuation of my previous SHA comparison article which was written over three years ago.

I've by now implemented SHA1 and the SHA2 family of functions in APL, Common Lisp, and finally, Ada.
None of these comprehensive implementations differed much from their corresponding SHA224 and SHA256
predecessors, and it was mostly a matter of crossing the gap from partial to full function coverage.
I've by now had a lot of time to mull over the APL and Common Lisp code, far more than with the Ada,
and only the Ada pleases me at all; even so, I likely never would've finished the Ada without cause.
In all cases, SHA1 is supported with SHA2 code reuse where possible and bespoke code in other cases.

The APL grows to cover the entire SHA2 family through simple code duplication.  The APL is the least
practical and this allowed it to have the simplest design.  It was regardless easy enough to finish.

The Common Lisp continued to be in that uncomfortable land between purity and practicality.  I chose
to use CLOS, but picked a wrong way to cut up the design, leading to something too slow to be useful
for much.  I started to rewrite my code to use a better macro design, to clean up what I found to be
too much repetition, but never found the will to finish it.  It's deeply unsatisfying to look at it.

For the Ada code, I had a very particular interface in mind, and was unwilling to compromise on that
package specification.  The SHA package contains five packages, each with an identical basic design,
implementing each of the five functions.  The package specification pleases me greatly, even if what
implements it falls below my usual standards.  This has been the most frustrating Ada code I've ever
written, up to this point, which is why I bothered not to finish it for roughly three years.  I took
pains to write as little code as I could, but compromised on the package body by duplicating code to
get it finished at all.  Future work on this package body will be to eliminate such duplication.  In
my frustration, I glanced at other Ada implementations, to find even more grotesque duplication, and
suppose Ada's generics system isn't necessarily meant to compress code so; I'm glad that I ended it.

There's little for me to remark, in conclusion, besides my satisfaction at completing this exercise.
.