bug-guile
[Top][All Lists]

## Re: GIT version: values

 From: Hans Aberg Subject: Re: GIT version: values Date: Thu, 27 Jan 2011 00:34:57 +0100

```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:

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.

```