Native MATLAB function for sequential evaluation of functions? [duplicate] - matlab

Question

This question already has answers here:
How to execute multiple statements in a MATLAB anonymous function?
(5 answers)
Closed 5 years ago.
So I was trying to polish my input validation in MATLAB functions and in the process I ended up creating the following function that really makes my code cleaner. I put it here in full in case someone finds it useful:
function [] = callFunctions(varargin)
%callFunctions Calls a sequence of functions on their respective arguments.
% The inputs are expected as funcHdl1, {input1}, funcHdl2, {input2}, ...
% Then callFunctions calls sequentially func1(input1); func2(input2); ...
%% === INPUT VALIDATION ===
% Check that the callFunctions has at least one argument
message = 'The number of arguments must be positive.';
assert(nargin > 0, message);
% Check that the callFunctions has an even number of arguments
message = 'The number of arguments must be even.';
assert(mod(nargin,2)==0,message);
% Name the handles
numHandles = nargin/2;
handleNames = cell(1,numHandles);
inputNames = cell(1,numHandles);
for k=1:numHandles
handleNames{k} = 'handle';
handleNames{k} = cat(2, handleNames{k}, int2str(k));
inputNames{k} = 'input';
inputNames{k} = cat(2, inputNames{k}, int2str(k));
end
% Function to check that the inputs are function handles
isValidFunctionHdl = #(x) validateattributes(x, {'function_handle'}, {});
% Create an input parser
p = inputParser;
% Add all arguments to check if they are handles. Don't check the inputs.
for k=1:numHandles
p.addOptional(handleNames{k}, 0, isValidFunctionHdl);
p.addOptional(inputNames{k}, 0);
end
% Parse the input
p.parse(varargin{:});
%% === PROGRAM ===
% Evaluate all the functions on their inputs
for k=1:numHandles
feval(varargin{2*k-1},varargin{2*k}{:});
end
end
Now the last part called %% === PROGRAM === is the important part. It just evaluates the functions func1, func2, func3, ... on their respective inputs input1, input2, input3, ..., all of which are given as inputs to callFunctions. It is called as:
callFunctions(funcHdl1, {input1}, funcHdl2, {input2}, ...)
My question is simple: is there a native MATLAB function that does what callFunctions does? I use this during input validation (in combination with assert and validateattributes). So Ì intend to use callFunctions in nearly every function I write. I'd like to use the least custom functions possible for this.
Ben
EDIT: I didn't want to go into this to keep the post short. But yes there is a context where this seems necessary for me. This is when I do input validation with the input parser. I often need to check multiple conditions, like this (completely made up example):
% Made up function to illustrate context
function [] = myFunction(input)
% Create an input parser
p = inputParser;
% Create functions to validate input. Must be a 2d logical array with at least one false value
isValidArray = #(x) validateattributes(x, {'logical'}, {'2d'});
hasAtLeastOneFalse = #(x) assert(length(find(x)) < length(x), 'Must be at least one false.');
isValidInput = #(x) callFunctions( isValidArray, {x}, hasAtLeastOneFalse, {x} );
% Add the required input
p.addRequired('input', isValidInput);
% Parse the input
p.parse(input);
end
This makes my code much cleaner because it allows me to combine multiple validateattributes and assert statements in the call to addRequired.

Answer 1

There is nothing like this that I know of that already exists ... and I am not sure why there would be.
Basically you are trading this:
func1(input1);
func2(input2);
For this:
callFunctions(#func1, {input1}, #func2, {input2})
All I see this doing is a bunch of input checking that callFunctions was used correctly. Assuming each individual function is written well and has it own asserts etc ... I don't get the need for this at all. Besides making it harder to read.
You could either skip it entirely or just have a simple for loop for a list of FCN handles & inputs. Each function would handle its own errors and you wouldn't be adding a bunch of code around something that seems pretty straight forward.
EDIT:
To your example usage: Why not do something like this? To me this is much "cleaner" than your example which seems to be your goal.
function [] = myFunction(input)
% Create an input parser
p = inputParser;
% Must be a 2d logical array with at least one false value
addRequired(p, 'input', #(x) validateattributes(x, {'logical'}, {'2d'}));
p.parse(input);
assert(length(find(input)) < length(input), 'Must be at least one false.')
disp('Running rest of code with good inputs!')
Which handles all your cases for bad inputs:
>> myFunction(ones(2,2,2))
Error using myFunction (line 6)
The value of 'input' is invalid. Expected input to be
one of these types:
logical
Instead its type was double.
>> myFunction(true(2,2,2))
Error using myFunction (line 6)
The value of 'input' is invalid. Expected input to be two-dimensional.
>> myFunction(true(1,2))
Error using myFunction (line 7)
Must be at least one false.
>> myFunction([true false])
Running rest of code with good inputs!