Multiple return values

[stylewarning]

We need a solution or a pattern for supporting multiple return values without consing. This may happen either with direct support for multiple values (more difficult), or compiling a couple versions of a function such that one returns multiple values and others return a tuple (possibly less difficult).

Multiple values are essential for efficient code.

[stylewarning]

My second proposal above would be something like this:

Suppose we have a function f of type * -> (Tuple :a :b). If a tuple is constructed at every tail position of f, then we compile two functions that are roughly:

(defun cl-f-mv (...)
  ;; implementation of f, but tail positions are
  ;; replaced with:
  (values p q))

(define cl-f (...)
  (multiple-value-call #'Tuple (cl-f-mv ...))

If the Coalton function f is called in any of the following scenarios:

(fst (f ...))
(snd (f ...))
(match (f ...)
  ((Tuple a b) ...))

then they are compiled to

(nth-value 0 (cl-f-mv ...))
(nth-value 1 (cl-f-mv ...))
(multiple-value-bind (a b) (cl-f-mv ...))

Otherwise, they are compiled to cl-f as normal.

[karlosz]

Additionally, the multiple values version for f can be called transitively through functions which themselves call only such functions or explicit Tuple constructors in tail-position.

The only bookkeeping required to track is if the return type of a function is a Tuple and all tail-positions are explicit constructors or calls to other functions with multiple-values versions.