Weekly edition Kernel Security Distributions Contact Us Search Archives Calendar Subscribe Write for LWN LWN.net FAQ Sponsors

# No thanks.

## No thanks.

Posted Nov 9, 2012 15:49 UTC (Fri) by HelloWorld (subscriber, #56129)
In reply to: No thanks. by renox
Parent article: Haley: We're doing an ARM64 OpenJDK port!

Your analysis of Joel's article seems quite shallow,
Feel free to write a rebuttal. Until then, I'll consider my points valid.
Also why do you consider returning a tuple different from returning multiple values?
I consider them different because they are different (duh). Let's say you have a function that duplicates its argument. In Haskell using a tuple, that's
`dup x = (x,x)`
`mad a b c = a*b+c`
How can you combine these to write a function that returns x*x+x? In a language like Haskell you can't easily do it with for example composition, you have to do something like
`foo x = mad x x x`
otoh, PostScript actually allows you to return multiple values, and there it's trivial:
```/mad { mul add } def
/foo { dup dup mad } def
```
(dup is a builtin in PostScript)

No thanks.

Posted Nov 9, 2012 16:14 UTC (Fri) by apoelstra (subscriber, #75205) [Link]

You know you're on LWN when a language war leads to a comment extolling PostScript over Haskell...

No thanks.

Posted Nov 9, 2012 21:33 UTC (Fri) by HelloWorld (subscriber, #56129) [Link]

It was the most well-known language I could think of that actually supports returning multiple values. Lua supposedly allows it too, but it's limited. Simple things work
```function dup(x) return x, x end
function add(x,y) return x, y end
```
but more somplex examples, such as
```function dup(x) return x, x end
```
don't. I'm not sure it can work in a non-stack-based language.

No thanks.

Posted Nov 10, 2012 0:22 UTC (Sat) by hummassa (subscriber, #307) [Link]

works perfectly in perl:

sub dup { \$_[0], @_ }

No thanks.

Posted Nov 10, 2012 14:09 UTC (Sat) by HelloWorld (subscriber, #56129) [Link]

This works because your version of dup returns excess arguments unmodified. Most perl functions don't do that, so it's not quite the same thing.

No thanks.

Posted Nov 11, 2012 0:44 UTC (Sun) by hummassa (subscriber, #307) [Link]

It does that because I modelled it after the postcript/forth example. In perl, is actually quite easy to adopt this style of programming:

sub mad { my(\$a, \$b, \$c, @rest) = @_; \$a*\$b+\$c, @rest }

So you can use @_ as the forth/postcript stack...

No thanks.

Posted Nov 9, 2012 17:50 UTC (Fri) by mathstuf (subscriber, #69389) [Link]

Intimidating, but:

compose :: (Num t) => t -> t
compose = uncurry (uncurry ((uncurry .) . (const . mad))) . dup . dup

Basically, the `const' adds a fourth (ignored) parameter to `mad' and then we uncurry that function to get it to take a tuple of tuples and then `dup . dup' the input to make `((x, x), (x, x))'. Granted, this looks nasty, but is also something that lamdabot might have been able to generate when asking for how to rewrite the obvious implementation in a point-free way.