In what language(s) is the return value set by assigning to the function’s name?

Question

In this Stack Overflow question the original code made the mistake of using the function name as a variable, and assigned the return value to it. A commenter mentioned that he once used a language where this was the way you returned the value from functions. The comment reads "I know I once used a language where the return value of a function needed to be assigned to the name of the function. It's so ancient and obsolete I can't even remember which language it was."

That sounds familiar to me as well, but I also can't remember what language it was.

Does anyone have better memory than us and can tell us which language it is?

Answer 1

Pascal does this, I don't know of others. Don't know if the practice move forward with other Wirth languages.

Answer 2

The languages in the Visual Basic family do exactly this. This includes VBScript, VBA, Visual Basic and earlier. I believe these inherit the "feature" from QBASIC. For example

Public Function AddTwo(something as Integer)
    AddTwo = something + 2
End Function

Answer 3

Fortran, for sure:

      PROGRAM TRIANG 
      WRITE(UNIT=*,FMT=*)'Enter lengths of three sides:' 
      READ(UNIT=*,FMT=*) SIDEA, SIDEB, SIDEC 
      WRITE(UNIT=*,FMT=*)'Area is ', AREA3(SIDEA,SIDEB,SIDEC) 
      END 

      FUNCTION AREA3(A, B, C) 
*Computes the area of a triangle from lengths of sides 
      S = (A + B + C)/2.0 
      AREA3 = SQRT(S * (S-A) * (S-B) * (S-C)) 
      END

(from Clive G. Page's Professional Programmer's Guide to Fortran77).

It's also defined that way in the Fortran ANSI X 3.9 1966 Fortran 66 standard.

Answer 4

The earliest such languages I can find are FORTRAN II and ALGOL 58, both published in the same year 1958; though the original FORTRAN (1956) can arguably also be included.

For FORTRAN, the first page of the manual chapter covering functions contains this example (p. 27):

FUNCTION AVRG (ALIST, N)
DIMENSION ALIST (500)
SUM = ALIST (1)
DO 10 I=2, N
SUM = SUM + ALIST (I)
AVRG = SUM / FLOATF (N)
RETURN
END (2, 2, 2, 2, 2)

FORTRAN II also includes another function syntax (p. 10), the single-line function definition, inherited from its prececessor:

FIRSTF(X) = A*X + B

It’s not hard to see how the former syntax is a natural extension of the latter, in turn coming from mathematical usage.

ALGOL 58, similarly to FORTRAN, defines both single-line ‘functions’:

A function declaration declares a given expression to be a function of certain of its variables. Thereby, the declaration gives (for certain simple functions) the computing rule for assigning values to the function (cf. functions) whenever this function appears in an expression.

Form: Δ ~ I_n (I, I, ~, I) := E where the I are identifiers and E is an expression which, among its constituents, may contain simple variables named by identifiers appearing in the parentheses.

and ‘procedures’, equivalent to a today’s definition of function (in imperative/procedural programming languages, at least). The return value is indicated as follows (p. 19):

For each single output procedure I(P_i) listed in the heading, a value must be assigned within the procedure by an assignment statement “I := E” where I is the identifier naming that procedure.

These syntaxes were later taken up by some dialects of BASIC (in the form of DEF FN and later FUNCTION) and ALGOL’s descendant Pascal: in Borland’s Pascal compilers, assigning to the function name was the only supported syntax before the introduction of the Result variable in Delphi 1.0.

It is probably Pascal that the mentioned commenter remembered; some universities still teach programming in it, and usually stick to the original, standard variety, instead of modern extended dialects like Object Pascal. (This isn’t really part of the question, but I’d assume the StackOverflow asker’s misunderstanding came from that as well.)

Answer 5

TL;DR:

I'd say, most likely it is Pascal you remember, as it was rather popular in the early 80s, used in University courses all thru the 80s way into the 90s and still had some fellowship there after, most notably Delphi.

---

Some History

The basic idea is that the function name is not only already reserved, so no need to come up with anything different, and using it is a clear statement that this is the result. It also simplifies compiler design, as a dedicated data item can be allocated within the calling convention.

There are essentially two lines of heritage, FORTRAN and ALGOL.

For both some of their descendants kept it, like

• some BASIC variants from FORTRAN and
• Pascal and Modula from ALGOL.

Others dropped it, like the ALGOL follow up

• BCPL, which introduced the return() syntax,

which is quite common today as C took it from BCPL.

Language ideas are like genes jumping between hosts. For example Ada, in many ways an ALGOL/Pascal grandchild, also turned to using a return element.

Granddaddy FORTRAN has, over the years, varied the way it returns function results.

• Originally the result of a function was assigned to the identifier of the function
• with FORTRAN 90 the explicit definition of a return name in the function head was introduced.

While this is essentially just syntactical sugar, it features a change in style. The reasoning applied was that with recursion constructions like Foo = Foo(x-1) would look strange. But I guess that is up to interpretation.

Interestingly here as well is that FORTRAN II of 1958 did introduce a RETURN statement in its strive to add procedural programming, but it's usage was simply to return execution to a caller, the return value had to be set separate.

Answer 6

Fortran has used this syntax, from the earliest version which had functions at all right up to Fortran 2008 and beyond.

However Fortran 2008 has an (even more confusing?) option where you can declare a different variable name that is used to return a function value! For example

function xyz(argument) result(answer)
...
answer = 42
...
end function xyz

instead of the old style

...
xyz = 42
...

Answer 7

Algol 60 for one.

Here's the relevant words from the Revised Report on the Algorithmic Language Algol 60.

5.4.4. Values of function designators.

For a procedure declaration to define the value of a function designator there must, within the procedure declaration body, occur one or more explicit assignment statements with the procedure identifier in a left part; at least one of these must be executed, and the type associated with the procedure identifier must be declared through the appearance of a type declarator as the very first symbol of the procedure declaration. The last value so assigned is used to continue the evaluation of the expression in which the function designator occurs.

Any occurrence of the procedure identifier within the body of the procedure other than in a left part in an assignment statement denotes activation of the procedure.

The last sentence is significant -- it shows that the name of the type procedure (function) is not treated 'just like' a variable within the procedure (function) body; rather, it is only assignment that is special-cased.

In Algol 60, a call to a function that takes no arguments is not followed by empty parentheses: thus n := read rather than n := read().

The last sentence is also famous as being the sentence that got recursive procedures into the language. But that's not germane to this answer.

Answer 8

BASIC is another language with functions where some dialects used assignment to the function name to provide the return value. The earliest dialects were similar to Fortran single-line functions:

DEF FND(x) = x*x

But later dialects allowed more complex variants, similar to Fortran multi-line functions:

DEF FNPeekWord& (A&)
  FNPeekWord& = PEEK(A&) + 256& * PEEK(A& + 1)
END DEF

Answer 9

MATLAB / Octave also does this.

It is from 1984; so not as old as some of the others.

It was probably imitating Fortran, since it was orginally concieved as a high-level tool. On top of the Fortran libraries like Linpack and Eispack.

Answer 10

I believe that SNOBOL4 did this. http://berstis.com/greenbook.pdf

The following is an example of the definition and use of a function to compute factorials of numbers:

   DEFINE('FACT(N)') :(SKIPFCN)
 * Set value to 1
 FACT      FACT = 1
 * Return 1 if N<2
 * Return N*((N-1)!) with recursive call
   FACT = GT(N,1) FACT(N - 1) * N :(RETURN)
 SKIPFCN
   OUTPUT = '5 factorial is ' FACT(5)

http://berstis.com/s4ref/prim3e.htm

Answer 11

Verilog (1995/2001) also returns by assignment to implicit variable. SystemVerilog added the "return" statement but the classic assignment is still available.

Answer 12

Pascal is one that I personally used that does it. Common Lisp kinda-sorta-but-not-really does it, in that return values are almost always implicit (ie. every statement has a value, and the last value in a block is the block's return value), so you very rarely see an explicit return statement, but when you need to return a value and can't use the implicit way, the way to do it is by using the RETURN-FROM^[*] statement, like so: (return-from function-name value).

^[*]There's also a RETURN statement, but it's a shorthand for (return-from nil value), and will not have the effect of making VALUE the value of the function in which it was executed. It's a great pitfall for newbies coming from C and its descendants.

Answer 13

Haskell (from 1990) does this as well:

doubleMe x = x + x  

defines a function doubleMe of one parameter x and assigns the function body x+x to it, see the great Learn You A Haskell For Great Good