I've been making use of the LLA linear algebra package (from https://github.com/tpapp/lla).  Last year it was working fine for me, but I returned to it today and have been getting errors.  I've recently upgraded to SBCL 1.2.1 (Windows), so that may be the source of the errors, or it might be something else entirely.

When I run the LLA test suite, I get a number of unknown type specifier errors:
    TESTS -> LINEAR-ALGEBRA-SUITE: (Test Suite)
        [...]
        INVERT: unknown type specifier: LLA::MATRIX
A simple test case that causes the error is "(lu (make-array '(2 2)))".  Unfortunately the debug trace is (at least to me) not very helpful:

unknown type specifier: MATRIX
   [Condition of type SIMPLE-ERROR]

Restarts:
 0: [RETRY] Retry SLIME REPL evaluation request.
 1: [*ABORT] Return to SLIME's top level.
 2: [ABORT] Abort thread (#<THREAD "repl-thread" RUNNING {100AA90063}>)

Backtrace:
  0: (SB-KERNEL::%%TYPEP #2A((3.0d0 4.0d0) (0.3333333333333333d0 0.6666666666666667d0)) #<SB-KERNEL:UNKNOWN-TYPE MATRIX> T)
  1: ((LAMBDA (SB-PCL::|.P0.| SB-PCL::|.P1.|)) #<unavailable argument> #<unavailable argument>)
  2: (SB-INT:SIMPLE-EVAL-IN-LEXENV (LU X) #<NULL-LEXENV>)
  3: (EVAL (LU X))

My main tool for isolating errors is trace, and unfortunately for me the LLA package has many complicated and nested macros, so trace doesn't work very well.  I also couldn't find anything specific in the LLA code that looked related to this, and "matrix" is unbound in the LLA package.   I'll append the definition of LU below, but I'm wondering if anyone has some hints on how to isolate / understand this error.  I'm hoping I'm just ignorant of some approach.

Thanks for any help!

-- Scott Turner
 

LU is

(defmethod lu ((a array))
  (let+ (((a0 a1) (array-dimensions a)))
    (lapack-call ("getrf" (common-float-type a)
                          (make-instance 'lu :lu lu :ipiv-internal ipiv-internal))
      (&integers a0 a1)
      (&array-in/out
          (:input a :transpose? t)
          (:output (&new lu) :transpose? t))
      (&integer a0) (&array-out (&new ipiv-internal) :dimensions (min a0 a1) :type +integer+)
      (&info :condition nil))))

and lapack-call is

(defmacro lapack-call ((name type value) &body forms &environment env)
  "LAPACK call, takes an &info argument.  NAME is either a string or a list of two strings (real/complex).  TYPE (internal-type) selects the function to call.  VALUE is the form returned after the call."
  (let* ((type-var (gensym "TYPE"))
         (arguments (process-forms forms env))
         (parameters `(:default-type ,type-var)))
    (assert-single-lapack-info arguments)
    `(let ((,type-var ,type))
       ,(wrap-arguments
         arguments 'bindings parameters
         `(progn
            ,(wrap-arguments
              arguments 'main parameters
              (wrap-arguments arguments 'call parameters
                              (blas-lapack-call-form type-var name
                                                     arguments)))
            ,value)))))

and then it is macros all the way down.