about Return value of Module[]

Question

questions are in the below code.

Although I'm pretty sure of the answer, I still feel a little uncomfortable, because I feel that the format of the body of Module[] is a bit "dead", seems that the Return statement had to be put at last line.

Is the value of Module[] is always equal to the last line which is not followed by semicolon;?

Is there a concept of "Return value of a function" including Module[] in Mathematica? and whenever you use the function in any expression, the function is always equal to the return value of the function?

i don't know how to ask, seems no questions here but a little uncomfortable for me(i'm not sure whether you can get the points of my uncomfortablement). Is there existing some reference about this?

f[x_,y_,z_]:=Module[{a,b,c},a+b;b+c;...;x+y+z]
(* is equal to the following c-function? *)
Head[x+y+z] f(Head[x] x ,Head[y] y, Head[z] z)
{ 
  Head[a] a; Head[b] b; Head[c] c;
  a+b; b+c; ....;
  return x+y+z;
}
(------------------------------------------)
f[x_,y_,z_]:=Module[{a,b,c},a+b;b+c;...;x+y+z;] (in my test return Null)
(* is equal to the following c-function? *)
void f(Head[x] x ,Head[y] y, Head[z] z)
{ 
  Head[a] a; Head[b] b; Head[c] c;
  a+b; b+c; ....;
  return ;
}

Answer 1

Effectively, Module[{body}, expr] "returns" the value of expr after evaluating according to the rules described in the documentation of Module. And the value of a;b;c is the value of c after evaluation (see CompoundExpression). So yes, the "return" value of Module is simply the value of the expression after the last ; (or Null if the expression ends with a ;).

I put "return" in quotes because I don't think you should think about expressions/functions "returning" something in Mathematica. Rather, expressions evaluate to something. What they evaluate to is controlled by the rules assigned to the various symbols. Almost everything works this way, even control flow constructs such as If and Switch follow this logic:

So, if you want to have the equivalent of something like

int foo(int a, bool b)
{
  int res = 2;
  if (b)
    return res*a*a;
  else
    return res+a+a;
}

(i.e. with the return not necessarily on the last line), you could do

foo[a_, b_]:=
  Module[
    {res = 2},
    If[b,
      res*a*a,
      res+a+a
    ]
  ]

This works because the value of If[a,b,c] will be b if a is True, and c if a is False. If you don't need any local variables, it gets even simpler:

foo[a_, b_]:=
  If[b,
    2*a*a,
    2+a+a
  ]

(i.e. there is in general no need for Module around every function body)

Answer 2

with the help of enthusiastic replyers and your links，my uncomforablement is gone.

about this uncomforablement,

First should know the function CompoundExpression[]. Main references are https://reference.wolfram.com/language/ref/CompoundExpression.html and https://mathematica.stackexchange.com/a/18617/89613

Secondly personally i realize that In fact, compound-expressions, which seem to be “dead” and inflexible, but considering that in fact, in general, “return value” is generally in the last position of a function, and the syntax design will not actually cause much inconvenience. That is, a less complex C function, I believe can always be translated into Mathematica statements in the form of compound-expressions with flow control statements such as If[]

Finally in Mathematica, it is probably better to adopt the idea of evaluating expr than the idea of ”return value“