Why does Octave/Matlab use function handles

Question

What benefit does it get from treating functions specially? For example,

function n = f(x)
   2*x
endfunction

f(2) //outputs 4
f = @f
f(2) //outputs 4

If handles can be called the same way as functions, then what benefit do we get from functions being treated specially. By specially I mean that variables referring to functions can't be passed as arguments:

function n = m(f,x)
   f(x)
end

m(f,2) // generates error since f is called without arguments

Why aren't functions procedures (which are always pointed to by variables) like in other functional languages?

EDIT: It seems like my question has been completely misunderstood, so I will rephrase it. Compare the following python code

def f(x):
    return 2*x
def m(f,x):
    return f(x)
m(f,3)

to the octave code

function n = f(x)
   2*x
end
function n = m(f,x)
    f(x)
end
m(@f,2) % note that we need the @

So my question then is, what exactly is a function "object" in octave? In python, it is simply a value (functions are primitive objects which can be assigned to variables). What benefit does octave/matlab get from treating functions differently from primitive objects like all other functional languages do?

What would the following variables point to (what does the internal structure look like?)

x = 2
function n = f(x)
   2*x
end
g = @f

In python, you could simply assign g=f (without needing an indirection with @). Why does octave not also work this way? What do they get from treating functions specially (and not like a primitive value)?

Answer 1

Variables referring to functions can be passed as arguments in matlab. Create a file called func.m with the following code

function [ sqr ] = func( x )
    sqr = x.^2;
end

Create a file called 'test.m' like this

function [ output ] = test( f, x )
    output = f(x);
end

Now, try the following

f=@func;
output = test(f, 3);

Answer 2

There's no "why is it different". It's a design decision. That's just how matlab/octave works. Which is very similar to how, say, c works.

I do not have intricate knowledge of the inner workings of either, but presumably a function simply becomes a symbol which can be accessed at runtime and used to call the instructions specified in its definition (which could be either interpreted or precompiled instructions). A "function handle" on the other hand, is more comparable to a function pointer, which, just like c, can either be used to redirect to the function it's pointing to, or passed as an argument.

This allows matlab/octave to do stuff like define a function completely in its own file, and not require that file to be run / imported for the function to be loaded into memory. It just needs to be accessible (ie in the path), and when matlab/octave starts a new session, it will create the appropriate table of available functions / symbols that can be used in the session. Whereas with python, when you define a function in a file, you need to 'run' / import that file for the function definition to be loaded into memory, as a series of interpreted instructions in the REPL session itself. It's just a different way of doing things, and one isn't necessarily better than the other. They're just different design / implementation decisions. Both work very well.

As for whether matlab/octave is good for functional programming / designed with functional programming in mind, I would say that it would not be my language of choice for functional programming; you can do some interesting functional programming with it, but it was not the kind of programming that it was designed for; it was primarily designed with scientific programming in mind, and it excels at that.