Can a string be converted into a function call inside a GUI?

I am trying to call upon a matlab GUI inside another matlab GUI. This matlab GUI has the name of a string which is available inside the GUI. I want to know how to change this string into a function, so that it can be called upon to open a GUI.

Thus my question is; how can I convert a string into a function so that it can call upon another GUI in matlab?

I am trying to build a GUI in matlab app designer. The idea is that the GUI startup function calls for a customized function called AutomaticUpdate. This function searches a specific shared directory for the newest version of itself. (e.g. GUI_v1_1 look whether a GUI_v1_2 or higher is present inside the set directory). When found, the AutomaticUpdate function copies this new version from the shared directory to the directory from which it is run. I now want GUI_v1_1 to automatically start GUI_v1_2 after it has been copied.

The process of copying the GUI from the shared directory to the one from which the 'old' GUI is ran is based on the comparison of the numbers present in the GUI titles by turning the titles into strings and then selecting and comparing the numbers in this string. The newest version available in the shared directory can be selected and copied this way. I now have the title of the GUI in string format, but to open it in the GUI, I need to have it in function format. Copying the GUI name into the GUI startup function manualy after it has been copied (i.e. GUI_v1_2) works and starts the second GUI. Taking the string directly after the GUI has been copied and applying str2func to that string does not.

If the GUI that has just been copied from the shared folder was named TestApp_v1_2 , This works: (ynupdate returns 1 or 0 depending on whether a file was copied from the shared directory).

function startupFcn(app)
    if haveInet
        [ynupdate, fname] = AutomaticUpdate2();
        if ynupdate == 1
            TestApp_v1_2
        end
    end
end

This does not:

function startupFcn(app)
    if haveInet
        [ynupdate, fname] = AutomaticUpdate2();
        if ynupdate == 1
            str2func(fname)
        end
    end
end

seeing as the newest file copied is named TestApp_v1_2, fname contains the string 'TestApp_v1_2', so I would expect this to work. I need this to work because the code has to be independent of the name of the version that has just been copied. It should always open the newest version that was just copied.

[Stephen23]

Your code has a major bug. The code that you wrote

str2func(fname)

calls str2func, which returns a function handle, exactly as its documentation states. However you then totally ignore this function handle (i.e. you do not allocate it to any variable, as its documentation clearly shows) and so you simply discard it without doing anything with it. And so, in contrast to your description, you did not actually call any function (Note that nowhere in the str2func documentation does it state that str2func will call a function).

The str2func documentation shows how to use it, including working examples:

https://www.mathworks.com/help/matlab/ref/str2func.html

You should also learn about function handles:

https://www.mathworks.com/help/matlab/function-handles.html

[Loek Meijers]

You're right. The problem was indeed that I did not understand what str2func did, and what a function handle is. I do now, thanks a lot!

Answer 1

[Rik]

While you could do it like this, I personally replace the contents of the file itself on update and ask the user to restart the function. For an example of this implementation, have a look here.

I'm not sure if it works (due to JIT/runtime compilation), but you may be able to use your strategy by using eval. I'm usually opposed to the use of eval, but I suspect this is one of the few times where it is a viable option. Of course you need to make sure that your updater function always returns a valid function name.

[Stephen23]

Why bother with eval?

Simply fix the major bug in the code shown in the question...

[Rik]

My main suggestion would be to replace the code itself in an update, instead of storing the metadata (version number) in the function name. I'm not claiming my implentation in the linked FEX submission is the most elegant solution, but I couldn't think of another/better method to apply an update, so if you do, I'dd be much obliged.

As far as I'm concerned, eval(fname) is not a much worse solution than guifun=str2func(fname);guifun();return. Both are fragile. The downside of my method is that it requires(?) a restart by the user.

[Stephen23]

I agree that the meta-data (the version number) would probably best not be included in the file/function name. As you say, replacing the text in its entirely is one option (or a simple copyfile?)

" eval(fname) is not a much worse solution than..."

Interesting point. According to its documentation str2func has a few prerequisites and restrictions for its creation, and presumably once it is created the function handle can be consistently handled by the JIT engine (esp. when used in a loop), whereas eval suffers the same slow evaluation each time. This would not stop a malicious function definition, but it means there are still distinct JIT-related advantages to using a function handle.

[Rik]

Isn't the JIT a moot point? An update is probably not going to happen so often that JIT optimization will have a large impact. I expect the timing difference caused by your internet connection is likely to be bigger than any JIT difference.

Would there be other advantages? Carefully reading the doc it doesn't look to me like there are any other differences in this specific case (unless there is a variable with the exact name that the updater returns, which there isn't). In the extremely unlikely event that there is an internal function with that name, there would be a difference.

Bottom line: there shouldn't really be a difference, but in edge cases str2fun should be a slightly better choice than eval.

[Guillaume]

In this case, indeed there's probably not much difference between eval or str2func. However, as a reviewer if I see eval in a code, there's all sorts of alarm bells going off that don't get triggered as much by an str2func. At least, I know that fname is not an expression that's going to create new variables or overwrite existing ones, or do more nefarious things.

Given the choice between eval and str2func, use the one that has the least potential to do the unexpected.

Answer 2

[Guillaume]

"This does not"

str2func(fname)

Yes, because str2func doesn't invoke the function, it just returns a handle to the function. You still have to call the function using the handle, so:

guifun = str2func(fname);  %get function handle.
guifun();    %call function handle.

However, in my opinion, you'd be better off embedding the version number in some other way (comment in the code?, get it from the version control system? Text in a separate file?) and using a fixed name for your GUI.