Is the first line in the body executable?

  (LAMBDA (A) 
    (DECLARE (SYSTEM::SOURCE-LEVEL #<EQ Hash Table{0} 81D03EFF03>)) 
    (DECLARE (LAMBDA-NAME FOO)) 
    (PRINT (QUOTE HEY)) 
    (PRINT A))

If not, one would probably need to do a bit of fiddling to tear away the function from the symbol if one should feel a sudden urge to do so.

Perhaps similar to this:

    : (de myfun (D)(prinl "heyo") (prinl D))
    -> myfun
    : myfun
    -> ((D) (prinl "heyo") (prinl D))
    : (mapcar '((D) (prinl "heyo") (prinl D)) '("world"))
    heyo
    world
    -> ("world")
    : (mapcar '(NIL (prinl "hey")) '(lel))
    hey
    -> ("hey")
    : (car myfun)
    -> (D)
    : (cdr myfun)
    -> ((prinl "heyo") (prinl D))
    : (cons (car myfun) (cdr myfun))
    -> ((D) (prinl "heyo") (prinl D))
    : (mapcar (cons (car myfun) (cdr myfun)) '("world"))
    heyo
    world
    -> ("world")

Mostly I use this to get at an implementation so I can test it or a portion of it against some particular value, or just to see how something works. Most builtins are implemented in assembler and their symbols only return a pointer, but for example 'doc is implemented in Picolisp:

    : doc
    -> ((Sym Browser) (raw T) (call (or Browser (sys "BROWSER") "w3m") (pack "file:" (and (= 47 (char (path "@"))) "//") (path (if (get Sym 'doc) (pack @ "#" Sym) "@doc/ref.html")))) (raw NIL))
    : de
    -> 270351
    : macro
    -> ("Prg" (run (fill "Prg")))

I really like the Picolisp 'match (https://software-lab.de/doc/refM.html#match ) function. What's the easiest way to do the same in Common Lisp? If it's not obvious from the examples there, it can also be used with character lists, i.e. transient symbols, i.e. strings, chopped up into a list of UTF-8 characters. It's similar to unification in logic programming, which is something Picolisp supports.

LispWorks:

    CL-USER 130 > (defun myfun (d) (print "heyo") (print d))
    MYFUN

    CL-USER 131 > (let ((source (function-lambda-expression #'myfun)))
                    (mapcar (eval (list* 'lambda
                                         (second source)
                                         (nthcdr 4 source)))
                            '("world")))

    "heyo" 
    "world" 
    ("world")

Above can in some ways done in many Lisp implementations. It's in this form simply not widely used. For most applications it's more interesting to use macros to manipulate code, which then can be compiled to efficient code.

Pattern matching is much implemented in Lisp.

I had adopted this code for a pattern matcher from a book (LISP, Winston/Horn), probably >30 years ago:

    CL-USER 115 > (pmatch:match '(#$a is #$b) '(this is a test))
    ((B (A TEST)) (A (THIS)))

    CL-USER 116 > (pmatch:match '(#$X (d #$Y) #$Z) '((a b c) (d (e f) g) h i))
    ((Z (H I)) (Y ((E F) G)) (X ((A B C))))

Not to say, that Picolisp isn't great for you, but it is not the only language where lists can be manipulated.

"Not to say, that Picolisp isn't great for you, but it is not the only language where lists can be manipulated."

Don't think I've made this claim.

Can the #$a &c. be used as variables?

    : (and (match '("h" "e" "l" "l" "o" @A ~(chop "ld")) (chop "helloworld")) @A) 
    -> ("w" "o" "r")

> Don't think I've made this claim.

That's true, but it sounds a bit as if Lisp interpreters are something very unusual. The syntax and other details may differ, but the general idea of executing source code via an interpreter is very old, often implemented - similar also the idea that the code can be mutable. It's just not very fashionable, since some Lisp dialects are designed such that one wants the compiler to be able to statically check the code for various things, before runtime.

In Common Lisp we would not want to introduce variables into an outer scope by enclosed functions. One would explicitly set up a scope.

Example: this is a macro example, which creates a scope, where the matching match-variables are also Lisp variables.

    CL-USER 165 > (pmatch:when-match (append (coerce "hello" 'list)
                                             '(#$a)
                                             (coerce "ld" 'list))
                      (coerce "helloworld" 'list)
                      (length a))

    3