Functions with more than one entry

Wouldn’t it be useful if a function (in BASIC) could have more than one entry, and hence more than one exit? For example:

sum, product = FNcalculate(3,4)
:
:
DEF FNcalculate(a,b)
=a+b, =a*b

Or does it already exist? If so, what is the exact syntax?

Should that not be more than one returned value ? Like this

*lua
Lua 5.4.4  Copyright (C) 1994-2022 Lua.org, PUC-Rio
RiscLua 544VFP-C
> f=\(x,y)=>x+y,x*y end; print (f(3,7))
10      21
>

I have often wondered why BASIC, C, Pascal, ….. only have functions returning a single value. It is not as if multi-returns or multi-assignments involved any great difficulties of implementation. Functions expect to find their arguments on the stack, and to exit with their return values on the stack. FORTH, Pop and Lua are the only languages with multi-returns that I can think of offhand. Because most procedures need to return errors as well as calculated values, it makes sense to have multi-returns. A frequent convention of Lua is that a function returns either a non-nil value if the calculation is successful, or nil followed by an error in case of failure. So

result, errmsg = f (...)
if not result then warn (errmsg) end -- if

result = assert (f (...))

Should that not be more than one returned value ?

Yes, that’s what I meant, apologise. (My English is sort of self-construct, not to mention my BASIC.)

I’ve written functions in Pascal with multiple return values. You just use an array, or an object, to return them. Javascript can also return multiple values, using this same method.

BASIC doesn’t have any type of data structure so you can’t return a struct as in C. Maybe it’s time to expand your horizons to Python which automatically turns multiple return values into a list tuple data type.

Just use a RETURN parameter. As others have intimated, “If I wanted to go there, I wouldn’t start here…”

Or does it already exist? If so, what is the exact syntax?

It is possible, but only due to the looseness of the parser. It shouldn’t be used in actual code.

PRINT FNthree("Count down...")
END

DEFFNthree(a$)
  a$ += "3..."

DEFFNtwo(a$)
  a$ += "2..."

DEFFNone(a$)
  a$ += "1..."

=a$

only have functions returning a single value

This is due to the heritage of functions being a mathematical construct. Hence, they are supposed to accept some form of input, perform a calculation, and return the result.
Plus, “that’s what Algol did” and we all know that languages are scions of their progenitors. ;)

Actually, it isn’t strictly true. While a function in BASIC only has one formal return value, both PROC and FN can have an input variable prefixed with RETURN in which case it is passed by reference rather than by value.

A% = 123

PROCbyval(A%)
PRINT A%

PROCbyref(A%)
PRINT A%

END

DEFPROCbyval(in%)
  in% = in% * 3
ENDPROC

DEFPROCbyref(RETURN in%)
  in% = in% * 3
ENDPROC

VisualBasic has a similar construct using ByVal and ByRef (IIRC, it’s been years…), however in both of these cases there is a risk of grotty things happening by allowing functions to directly mess with the input values in a global scope.

Edit: I was writing this when Stuart mentioned RETURN.

Functions expect to find their arguments on the stack, and to exit with their return values on the stack.

Depends upon the language implementation. Under RISC OS, APCS-based languages will place the first four input values into R0-R3, and expect the output in R0.
If I was writing a BASIC compiler, I would do it in a broadly similar manner. Pushing stuff onto the stack only to pop it right off again is “expensive” in terms of potentially unnecessary memory accesses. Remember, through most of the ’90s and ’00s, processor speeds were vastly faster than memory speeds. They still are but these days it is generally a smaller disparity than the likes of 450MHz/66MHz (my old Celeron box). So it would be seen as beneficial to try to reduce the number of memory accesses if possible.

A frequent convention of Lua is that a function returns either a non-nil value if the calculation is successful, or nil followed by an error in case of failure.

Hehe… a lot of DeskLib’s convention is to return NULL if something worked. If it’s non-NULL, then it’s probably a pointer to an error block.

This isn’t always true – File_Open for example returns zero if there was a problem or otherwise a file handle, but certainly a lot of the lower level SWI calls are defined like:

extern os_error *Wimp_SetColour(int colour);

it makes sense to have multi-returns

I can see this being abused somewhat, leading to potentially messy code and/or muddling up what is returned what. Was it pigs,fly or fly,pigs?

In more grown up languages than BASIC, this situation is handled using structures. These can be either passed on entry (with the contents updated by the function and a simple go/fail response) or the structure can be built by the function and passed as the exit value.
The former option is preferable, as the latter would tend to put the structure on the stack which means it only has limited visibility/lifespan. Unless declared static within the function, of course, but then you need to take care not to have stale data lingering.

BASIC doesn’t have any type of data structure so you can’t return a struct as in C.

True, but you can fake it by building the structure manually and passing the address to the data block. A bit of mindscrew that will be extremely familiar to anybody who’s ever written a Wimp program in BASIC. It’s doable, but it’s about as pretty as the result of a late night curry and one beer too many.

which automatically turns multiple return values into a list data type.

Ugh. I don’t like languages that “try to be clever”. Like PHP’s lack of typing for variables. Can lead to some interesting oddities when a variable is a number and PHP decides to interpret it as a string/number when you wanted a number/string.

For example:

$val = "1";        // it's a string
$val += 1;         // now it's an int
$val = $val * 1.2; // now it's a float

This can bite you in the arse if you’re trying to compare for equality and PHP figures that they’re not the same type so aren’t equal. The string “1” is not the same as the number 1, for instance.
Thankfully there’s a casting behaviour broadly the same a C so a given type can be forced.

If I wanted to go there, I wouldn’t start here.

+1.
Using an array or an object is wasteful of storage, and slow if used inside a loop. It is a kludge. The returned values should be on the stack, with no packing or unpacking required. Of course, if your language does have multi-assignments, then it also needs a nil value for coping with assignments where the number of variables on the LHS does not equal the number of expressions on the RHS. The two features go hand in hand. But having a nil value is useful anyway for lots of other reasons.

Ugh. I don’t like languages that “try to be clever".

+1.
Coercions can be bad news. On the other hand type systems can be too strict. Types in Pascal have to be constants, whereas one often needs variable types, that are unknown at some points of the program. Haskell deals with this by using the Hindley-Milner type system as a compromise. Type systems in which types can be parametrized by values are generally not computable.

Pushing stuff onto the stack only to pop it right off again is “expensive” in terms of potentially unnecessary memory accesses.

That’s Peephole Optimiser 101 though.

On the other hand type systems can be too strict.

Algol 68 had the helpful “Cannot coerce object of mode void to mode void”…

Ugh. I don’t like languages that “try to be clever”.

There’s nothing clever about returning a list tuple from a Python function, it does what is says on the tin. If you want clever then look at Perl’s handling of mixed scalar and array parameters to a function, that’s a waking nightmare of unintentionality.

BASIC doesn’t have any type of data structure so you can’t return a struct as in C. Maybe it’s time to expand your horizons to Python which automatically turns multiple return values into a list data type.

Ahem,

Python 3.7.3 (default, Jan 22 2021, 20:04:44) 
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def fn(): return 1, 2
... 
>>> type(fn())
<class 'tuple'>
>>> 

There’s a lot of snooty attitudes here. ;-)

To return multiple values you use RETURN. That is the way it is done in BASIC. It is quite fit for purpose, it is robust and there are no tricks.

>f=\(x,y)=>x+y,x*y end;print (f(3,7))
10      21

is:

DEFPROCf(x,y,RETURN s,RETURN p):s=x+y:p=x*y:ENDPROC
PROCf(3,7,s,p):PRINT s,p
10      21

and you also have variables with the sum and product.

That is the way it is done in BASIC. It is quite fit for purpose, it is robust and there are no tricks.

OK, I agree, but I am definitely snooty. I suppose in theory one could avoid FN and assignment altogether and only have PROC, once you introduce a new primitive PROCassign(RETURN x, y). It would look horrid though. Why INPUT X and not X = INPUT, but K$ = GET$ and not GET K$? Lets face it, the syntax of BASIC is a horrid mess, and a burden on beginner and compiler-writer alike.

Having types lends meaning to programs, and helps to avoid most errors. The trouble is that for lots of algorithms you don’t actually need to know what the type is, only how to distinguish different types. That in Pascal you need a different function to sort numbers from one to sort strings is clearly a nonsense. C’s use of pointers fits well for this situation. But the downside is that C predicates a particular memory model: consecutive chunks of memory labelled by the smallest address. Other languages try to avoid this assumption, using the idea that objects in memory have descriptors whose details are left to a specialized memory manager, not itself part of the language. A high level language (like the user) has no business mandating a particular memory model or fiddling with addresses; but then C is a low-level language.

a different function to sort numbers from one to sort strings is clearly a nonsense

Why? Numbers are regular. Numbers have predictable qualities such as 2 being a larger amount than 1. Sure, humans manage to mess this up (is 1.01 > 1? what is -1?), but these are mainly issues of interpretation…or perhaps more specifically limits of interpretation. That &FFFFFFFF is -1 is the nonsense here, but we accept it as a compromise.

Strings, on the other hand, are a sequence of values that we give meaning to. And in many cases without coherent agreement to the meaning. Is your website declared as ISO 8859/1? Don’t write in Welsh because officially everybody is supposed to interpret that as a synonym for Windows CP-1252, which has subtle differences in the free-for-all middle bit.

Even with Unicode, there are different types, with UTF-8 being the popular one (it works well with C), but since it is a string of bytes without an obvious marker, it’s easy to mess it up. From time to time my Amazon orders come with a gibberish address, as Amazon clearly uses UTF-8 and the vendor’s system printed this out as if it were something like the aforementioned CP-1252.

Let me ask you – would you put Å before B or after Z? What would you do if it was expressed as ÃŶ? How would you sort non-Latin names? In Japanese, for example, the vowels are あ a, い i, う u, え e, and お o (and this isn’t even counting the thousands of Kanji and their multiple readings).

A lot more complicated than numbers!

There’s a lot of snooty attitudes here. ;-)

Too many years spent hacking sanity into other people’s ***tty code.

Not mine, I hasten to add, my code is perfect. (well, you did mention snooty attitudes ☺)

BASIC doesn’t have any type of data structure so you can’t return a struct as in C.

It is hardly relevant now, but with BASIC and Basalt you could create structures much like C and pass them by reference. With some trickery you can do that in BASIC alone.

However, I have never found a need to use those structures in anger. For instance, you can do this to fill an icon block, with no indirection in sight:

P%=block%
[OPT 2
& xmin%
& ymin%
& xmax%
& ymax%
& flags%
= LEFT$(text$,11)
= 0
]

Here’s a shortform version with values. ;-)

P%=block%:[OPT 2:&100:&100:&200:&200:&&0700035:="Text":=0:]

[none of this is tested, but you get the idea!)

Edit: Does this count as a trick? It is in the language and documented.

a different function to sort numbers from one to sort strings is clearly a nonsense

In BASIC you use Martin Avison’s *Sort, of course, but that is ASCII for strings, Rick. ;-(

would you put Å before B or after Z? What would you do if it was expressed as ÃŶ?

I have never done it before, but I just tried a combintion of OS_HeapSort and Territory_Collate, which does the trick. It is pretty simple in BASIC, but does require an assembler wrapper round Collate, AFAICT.

Of course, this does rely on a working territory for the language you want to sort in. ;-)

Edit: This does not work. I was seeing an artefact. ;-( ;-(

Stick a NULL on the strings ;-)

Edit: This does not work. I was seeing an artefact. ;-( ;-(

Oh? Seems like a pretty interesting idea to “leverage” (fx: vomit emoji) OS facilities to save having to write a sort routine.

Let’s have a crack at this (updated to perform two types of sort)…

 10 ON ERROR PRINT REPORT$+" at "+STR$(ERL) : END
 20 
 30 DIM A$(10), M% 63, N% 127
 40 
 50 REM Let's pick some names
 60 A$(0) = "April"    : REM Normal
 70 A$(1) = "Emily"    : REM Normal
 80 A$(2) = "Æronwen"  : REM Welsh, 'ae' lig
 90 A$(3) = "Jessica"  : REM Normal
100 A$(4) = "Ásfríðr"  : REM Norse
110 A$(5) = "Clíodhna" : REM Irish
120 A$(6) = "Aubrey"   : REM Germanic
130 A$(7) = "Clemence" : REM French
140 A$(8) = "Clotilde" : REM Germanic
150 A$(9) = "Angela"   : REM Normal
160 
170 REM Since BASIC has no "address of" operator for
180 REM getting a pointer to a string (not to mention
190 REM it'll be in a BASIC format), we'll poke each
200 REM into memory, and set up a list of pointers.
210 FOR l% = 0 TO 9
220   REM Assume we can fit them into 16 bytes ;)
230   $(N%+(l% * 16)) = A$(l%) + CHR$(0)
240   M%!(l%<<2) = N% + (l% * 16)
250 NEXT
260 M%!(10 << 2) = 0 : REM End marker
270 
280 REM Show what we have
290 PRINT "Before sorting"
300 l% = 0
310 WHILE (M%!l% <> 0 )
320   PRINT RIGHT$("00000000"+STR$~(M%!l%), 8)+" : ";
330   SYS "OS_Write0", M%!l%
340   PRINT
350   l% += 4
360 ENDWHILE
370 
380 
390 REM Do a straight string sort
400 SYS "OS_HeapSort32", 10, M%, 4,,,,, 0
410 
420 REM Show what we have now
430 PRINT '"After basic string sort"
440 l% = 0
450 WHILE (M%!l% <> 0 )
460   PRINT RIGHT$("00000000"+STR$~(M%!l%), 8)+" : ";
470   SYS "OS_Write0", M%!l%
480   PRINT
490   l% += 4
500 ENDWHILE
510 
520 
530 REM Now we want some code to munge HeapSort to Territory_Collate
540 DIM code% 127
550 P% = code%
560 [ OPT 2
570   ; we can trash R0-R3
580   ; objects are in R0 and R1
590   ; we must return flag LT if R0<R1
600 
610   STR   R14, [R13, #-4]!  ; we'll be called from the SWI, so be paranoid
620 
630   MOV   R2, R1            ; string 2
640   MOV   R1, R0            ; string 1
650   MVN   R0, #0            ; -1 for current territory
660   MOV   R3, #%000         ; cardinals, ignore case, ignore accents
670   SWI   "Territory_Collate"
680 
690   ; Result is <0 if S1<S2
700   ;            0 if S1=S2
710   ;           >0 if S1>S2
720   ; So compare with zero to ensure LT or GE conditions are met
730   CMP   R0, #0
740 
750   ; Done
760   LDR   PC, [R13], #4
770 ]
780 
790 SYS "OS_HeapSort32", 10, M%, code%,,,,, 0
800 
810 REM Show what we have now
820 PRINT '"After territory-collate sorting"
830 l% = 0
840 WHILE (M%!l% <> 0 )
850   PRINT RIGHT$("00000000"+STR$~(M%!l%), 8)+" : ";
860   SYS "OS_Write0", M%!l%
870   PRINT
880   l% += 4
890 ENDWHILE
900 
910 END

Which does this:

*NameSortTest
Before sorting
0000985C : April
0000986C : Emily
0000987C : Æronwen
0000988C : Jessica
0000989C : Ásfríðr
000098AC : Clíodhna
000098BC : Aubrey
000098CC : Clemence
000098DC : Clotilde
000098EC : Angela

After basic string sort
000098EC : Angela
0000985C : April
000098BC : Aubrey
000098CC : Clemence
000098DC : Clotilde
000098AC : Clíodhna
0000986C : Emily
0000988C : Jessica
0000989C : Ásfríðr
0000987C : Æronwen

After territory-collate sorting
000098EC : Angela
0000985C : April
0000989C : Ásfríðr
000098BC : Aubrey
0000987C : Æronwen
000098CC : Clemence
000098AC : Clíodhna
000098DC : Clotilde
0000986C : Emily
0000988C : Jessica
*

Okay, it didn’t quite know what to do with Æronwen, but it was a bit of a cheat using the AE ligature. Otherwise, it appears to have sorted correctly, putting Ásfríðr between April and Aubrey, and Clíodhna between Clemence and Clotilde.

a different function to sort numbers from one to sort strings is clearly a nonsense

My fault for not explaining myself clearly. A sorting algorithm has nothing to do with the type x of the elements in the array to be sorted. It takes as an argument a comparison function : a function of two arguments, a and b of type x, which returns true if a is to come before b and false otherwise. Whether x is numbers of some kind or strings or whatever does not matter to the algorithm, only to the comparison function. Box-shuffling does not care about what is in the boxes. The notion that values can be containers, an intentionally vague word, for other values is not really expressible in BASIC, but it is an important idea nonetheless.

Not allowing ASCII NUL as a character in a string is a nasty limitation, asking for trouble. Now alphabetic ordering is another can of worms entirely.

Why not try C++
With template functions:

https://www.cplusplus.com/doc/oldtutorial/templates/

A sorting algorithm has nothing to do with the type x of the elements in the array to be sorted.

Ah, and there’s the distinction. There are two ways that one can sort something. The first is to have a generic sort which calls out to a comparison routine as you suggest, and as used above in my BASIC example. The other way is to have a ready-built function to perform a sort according to a predetermined type of value.
It’s a bit like “why does BASIC have CIRCLE when you can calculate the pixels and POINT plot them?”, the answer is because it makes things simpler. No crappy maths and complications, just call CIRCLE and it’s done.

Interestingly, standard C only offers qsort() which takes a base address, a count of objects, their size, and a pointer to a comparison routine. So you have to “do it yourself” in C.

Not allowing ASCII NUL as a character in a string is a nasty limitation

It has provided benefits, though. By reserving a specific character to mark the end of the string, it is possible to have strings of arbitrary length. Systems that use a single byte to hold the length (like BASIC) are limited with strings maxing out at 255 or 254 bytes (depending on whether or not the terminator is required – it shouldn’t be given an explicit length, but…).

The downside is that the length of a string cannot be determined without literally walking it and counting the bytes, but since the length is essentially arbitrary ¹, it is certainly preferable to the alternative.

As to why null, well, perhaps because in the VT world, all of the other characters have meaning. SOH, STX, ETX, EOT, ENQ, ACK, BEL… and that’s the first seven.

Otherwise, it appears to have sorted correctly,

Hmm. My code does exactly the same ¹, but it is not correct, I think.

You have:

660 MOV   R3, #%000  ; cardinals, ignore case, ignore accents

This is the default flags, taking acount of case and accents, so the sort should appear as the first HeapSort, with Æronwen at the end, I suggest. It looks as though R3=%11 is applied, whatever. That is the ‘artefact’.

A lttle bit more experimenting makes me unsure that Collate is working as specified, although I am sure that I have had a version that did. I am still on RO 5.25. More work needed.

¹ It is a a bit briefer and much more BASICy. ;-)