Sorry for the oversight - definitely not intentional. Please use the link on the right to make an enhancement request via technical support. I don’t think it is entirely compatible since in a regular function, the function has its return args listed in the program. And now return would depend on position. But would it obey nargout? And what if the results returned were different for different values of nargout? Clearly, I haven’t thought about this enough to evaluate if it’s even realistic.

In your example with anonymous function, you can get the same result now with

myfunc = @(x) (x==1)*2 +(x==2)*3

>>
myfunc = @(x) (x==1)*2 +(x==2)*3
myfunc =
    @(x)(x==1)*2+(x==2)*3
>> myfunc([1 3 2])
ans =
     2     0     3

–Loren

Suggestion: perhaps enable return to accept arguments:

myfunc = @(x) (if (x==1) return(2); else return(3); end);

This would seem to be entirely backward compatible with existing code and may be useful for Matlab functions in general (not just anonymous):

function [a,b] = myfunc(data)
% do some useful computation
return (result1,result2);
end

Thanks,
Yair

I second Loren’s suggestion on giving anonymous and nested functions a try. It took me a little while to get used to the new syntax for anonymous function, but just like any other MATLAB syntax, I am completely used to it now. I had VERY little programming experience when I started using MATLAB (I may have programmed a little in BASIC), so the learning curve was steep, but after that, MATLAB code was MATLAB code, including anonymous functions.

Another relevant example is the new Object Oriented Programming capability that was introduced in R2008a. It’s a completely new programming construct, which may seem extremely foreign to a traditional MATLAB user. I was one of those people. I had no experience in object oriented programming, so I was very confused. I think it took me about a year to get my head around it. Now, it feels very natural, and I love it. It changed how I code in MATLAB, and I can create more sophisticated applications with it.

I think we should not dismiss a particular feature just because it is a foreign concept or syntax. Although, I do agree that there should be added benefits for any new programming constructs. I hope that some of the discussions in this post, as well as the other posts by Loren, will convince you of the benefits of anonymous functions. I do recommend giving them a try.

p.s. BTW, I find Steve’s example with the anonymous function so much easier to understand, because I know how to interpret that syntax. This is how you would read it:

“Do the following for each element of the structure array ‘data’: compare field ‘test’ of the structure with string ‘inverse_real’. Store the results to an array ’select’.”

Yes, I’ll put some effort into this. Sounds like a fun way to spend the Thanksgiving weekend.

More thoughts from me…

* Another reason I like nested and anonymous functions. This particular discourse will concentrate on anonymous functions mostly, but nested and anonymous functions are so closely related that they points work for both.

Nested/anonymous functions allow for more natural APIs/interfaces. Here’s a quick example. If I want to work with a bunch of lines, ones for which I don’t know the slope and intercept, I have to write a function that takes 3 inputs (x,m,b). But if what I am doing with these lines is integrating, for example, I really need to have the function be a function of x alone, and not include slope/intercept.

No programming languages that I am familiar with allow you to separate parameters (slope/intercept) from unknowns (or variables). They are all just variables. But, if I have a line defined as a function of x, I can ask all kinds of questions about it without having to myself know slope and intercept. For that matter, I can substitute something that’s not strictly a line. Suppose I want to next see what happens with a quadratic. If I use the paradigm of having to write a function, I have to write it now to include, 3 terms, and I have to change my integrator to accept 3 optional arguments, etc.

More elegantly, I can supply a function handle that has only x as an input, and who cares what the underlying function is. That anonymous function carries with it all the information it needs, and the function I send it to doesn’t need to know anything other than it is a function of x. Gets all the parameter messiness out of the way.

* Finally, I recommend you “put some skin in the game” - i.e., read (or reread) posts from this blog under the category Function Handles, download the code or copy/paste it into an editor and try it. There are examples in the documentation. Copy/paste them into files, run them, go through them with a debugger, etc. I don’t think you can replicate my 3 weeks of learning by reading a doc alone. Take the plunge.

–Loren

I didn’t mean to imply that your code is distasteful, I just can’t understand what it is doing at a glance. Since I’m one of the more experienced MatLab users around here, if I can’t understand a coding technique, I certainly can’t expect my co-workers to understand it. If you think my code example is harder for a novice to follow, tell me why.

My comment regarding the function handle being hidden in plain sight was only in regards to the way the FRPs for these functions of functions are written.

A life-long dear friend of mine (he & I were best men at each other’s weddings) has worked for a career as a code developer. When I complain to him about code that I can’t understand, he bluntly counters that that is the reason why professional developers are needed.

But, that model doesn’t work for MatLab. We recognize that all the technical computing functionality we write in .m code could be provided by some custom application written in C or whatnot. But, the advantages writing it in MatLab outweigh the disadvantages of having amateurs writing the code. But, we still have to verify that the code does the correct thing & that requires that we be able to read & understand the code.

Like I said before, I would love to understand fully why you smart developers at The MathWorks think function handles & anonymous functions are attractive. You clearly see something that we don’t. And, this isn’t at all like the other type of technical computing decisions we make in the world of MatLab.

For example, I may choose to estimate transfer functions from recorded data using a CZT based routine rather than an FFT based routine. I understand how to solve the problem each way & make the decision based on subtle points.

In the case of anonymous functions, my co-workers & I just don’t get it. If as Loren says, a user has to play with it for 3 weeks to understand it, then why can’t you guys write up a nice training package that leads the user thru this so they can make the decision about using the technique from a position of knowledge? Instead, I’m forced to not even consider the technique only because I can’t imagine why this is attractive.

;-)

The style of putting the argument list for an anonymous function ahead of the function name rather than after it doesn’t make any sense to us. All normal functions in the world of MatLab have the input arguments after the function name.

Why is it reversed for anonymous functions?

A couple things. Reading between the lines, it appears that your use of this feature is from the command line, rather than writing a stand-alone function to process the data. i.e., you are using MatLab in what I call its supper, wizbang desktop calculator mode. Then, you wanted to inspect the data_subset in the workspace after you had done this command line processing. Am I guessing correct?

Next, from a first reading of the FRP for arrayfun, I can’t see from the Description how you are using legal syntax. Only after reading it several times & jumping over to the FRP for function_handle do I pick up on the subtle detail that your 1st argument in arrayfun is an in-line generation of a function handle. The fact that that 1st argument is a function handle is almost hidden in plain sight.

Like I said, this is all very confusing to us. Several of us out here discussed this a bit and we are all equally confused.

The clearest way to generate your index variable, select, is to do it inside some for loops. Isn’t this what you are after?

for ii = 1 : size(data, 1)
    for jj = 1 : size(data, 2)
        select(ii, jj) = strcmp(data(ii, jj).test, 'inverse_real';
    end
end
data)subset = data(select);

I suppose for my code, you need to know that data has 2 dimensions. But, usually I know the data well enough that this isn’t a problem.

I do stuff like this from the command line all the time. Or, I just open an editor window, type it out, highlight it & do a Evaluate Selection.