Maxima: creating a function that acts on parts of a string

Context: I'm using Maxima on a platform that also uses KaTeX. For various reasons related to content management, this means that we are regularly using Maxima functions to generate the necessary KaTeX commands.

I'm currently trying to develop a group of functions that will facilitate generating different sets of strings corresponding to KaTeX commands for various symbols related to vectors.

Problem

I have written the following function makeKatexVector(x), which takes a string, list or list-of-lists and returns the same type of object, with each string wrapped in \vec{} (i.e. makeKatexVector(string) returns \vec{string} and makeKatexVector(["a","b"]) returns ["\vec{a}", "\vec{b}"] etc).

/* Flexible Make KaTeX Vector Version of List Items */
makeKatexVector(x):= block([ placeHolderList : x ],
            if stringp(x)   /* Special Handling if x is Just a String */
            then placeHolderList : concat("\vec{", x, "}")
            else        if listp(x[1])   /* check to see if it is a list of lists */
                    then        for j:1 thru length(x) 
                            do placeHolderList[j] : makelist(concat("\vec{", k ,"}"), k, x[j] ) 
                        else        if  listp(x)   /* check to see if it is just a list */
                            then  placeHolderList    : makelist(concat("\vec{", k, "}"), k, x) 
                            else    placeHolderList : "makeKatexVector error: not a list-of-lists, a list or a string", 
        return(placeHolderList));

Although I have my doubts about the efficiency or elegance of the above code, it seems to return the desired expressions; however, I would like to modify this function so that it can distinguish between single- and multi-character strings.

In particular, I'd like multi-character strings like x_1 to be returned as \vec{x}_1 and not \vec{x_1}.

In fact, I'd simply like to modify the above code so that \vec{} is wrapped around the first character of the string, regardless of how many characters there may be.

My Attempt

I was ready to tackle this with brute force (e.g. transcribing each character of a string into a list and then reassembling); however, the real programmer on the project suggested I look into "Regular Expressions". After exploring that endless rabbit hole, I found the command regex_subst; however, I can't find any Maxima documentation for it, and am struggling to reproduce the examples in the related documentation here.

Once I can work out the appropriate regex to use, I intend to implement this in the above code using an if statement, such as:

if slength(x) >1 
then {regex command}
else {regular treatment}

If anyone knows of helpful resources on any of these fronts, I'd greatly appreciate any pointers at all.

Solution

Looks like you got the regex approach working, that's great. My advice about handling subscripted expressions in TeX, however, is to avoid working with names which contain underscores in Maxima, and instead work with Maxima expressions with indices, e.g. foo[k] instead of foo_k. While writing foo_k is a minor convenience in Maxima, you'll run into problems pretty quickly, and in order to straighten it out you might end up piling one complication on another.

E.g. Maxima doesn't know there's any relation between foo, foo_1, and foo_k -- those have no more in common than foo, abc, and xyz. What if there are 2 indices? foo_j_k will become something like foo_{j_k} by the preceding approach -- what if you want foo_{j, k} instead? (Incidentally the two are foo[j[k]] and foo[j, k] when represented by subscripts.) Another problematic expression is something like foo_bar_baz. Does that mean foo_bar[baz], foo[bar_baz] or foo_bar_baz?

The code for tex(x_y) yielding x_y in TeX is pretty old, so it's unlikely to go away, but over the years I've come to increasing feel like it should be avoided. However, the last time it came up and I proposed disabling that, there were enough people who supported it that we ended up keeping it.

Something that might be helpful, there is a function texput which allows you to specify how a symbol should appear in TeX output. For example:

(%i1) texput (v, "\\vec{v}");
(%o1)                       "\vec{v}"
(%i2) tex ([v, v[1], v[k], v[j[k]], v[j, k]]);
$$\left[ \vec{v} , \vec{v}_{1} , \vec{v}_{k} , \vec{v}_{j_{k}} , 
 \vec{v}_{j,k} \right] $$
(%o2)                         false

texput can modify various aspects of TeX output; you can take a look at the documentation (see ? texput).