Re: GIT version: values

[Hans Aberg <haberg-1@telia.com>]

On 26 Jan 2011, at 21:51, Andy Wingo wrote:

>> It seems it is not only 'values' writing, but the new behavior  
>> seems to
>> be to strip trailing values quietly:
>>  (define a (values 2 3 4))
>>  (call-with-values (lambda () a) (lambda x x))
>> in Guile 1.9.14.68-a7d8a computes to
>>  $1 = (2)
>>
>> By contrast, in guile-1.8.8, it computes to
>>  (2 3 4)
>
> Indeed.  This and a (hopefully small) number of other differences are
> noted in the NEWS.
...
> There is no tuple with multiple-valued returns: they are returned on  
> the
> stack.

Right. I was implementing infix notation tuples syntax f(x_1, ...,  
x_k) using Bison on top of Guile, relying on the old behavior of  
'values'. It is possible to extend Scheme values as to infix tuples  
usage:

Think of Scheme (f x_1 ... x_k) as equivalent to f(x_1 ... x_k), and  
add the reduction of tuples singletons (x) = x. Then (f (values  
x_1 ... x_k)) is the same as f((x_1 ... x_k)) = f(x_1 ... x_k), that  
is (f x_1 ... x_k). However, if more than one of the x_i in is a non- 
singleton, it is an iterated tuple which cannot be reduced on its  
topmost level.

In addition, I extended so that if f = (f_1, ..., f_n), then f(x) is  
defined to (f_1(x), ..., f_n(x)). For values, ((values f_1 ... f_n)  
x_1 ... x_k) computes to (values (f_1 x_1 ... x_k) ... (f_n x_1 ...  
x_k)). With this syntax, one can write (atan ((values sin cos) x)).

Also, functions that return no value might just as well return  
(values) instead of an internal unspecified value. They will then work  
as in C/C++.

> Both of these behaviors are allowed by R5RS and R6RS.

This is correct.

> The compiler's
>    behavior is more correct, however. If you wish to preserve a  
> potentially
>    multiply-valued return, you will need to set up a multiple-value
>    continuation, using `call-with-values'.

But this is false. It prevents implementing tuples in Scheme, at least  
using 'values'.

The topic is discussed here:
https://groups.google.com/group/comp.lang.scheme/browse_thread/thread/b72d987aa6626cd2/e2f7cfa55fb51d55?hl=en

It mentions the above:
 > [E]very procedure takes exactly one argument and returns exactly one
 > result.  The argument and the result will always be a sequence. [...]
 > An expression in tail-recursive position returns a one-element
 > sequence.  Continuations accept sequences containing an arbitrary
 > number of elements as results.