[clean-list] Re: relationship between uniqueness types and single-threaded lambda calculus?

[TK]

>
> You don't need to register first (I've always found the website a bit
> confusing in this regard).


I stumbled upon the right page just before writing an e-mail trying to prove
myself worthy( having read CleanBook beforehand , scientific intent , ... )
for access to the system.


I am not sure there really is a
> semantic difference between using a "lookup" (using let* or #!) which
> does not return a new array or using a "uselect" which returns a pair of
> a new array and the item requested. You claim that the latter increases
> the degree of sequentialization, but I'm not sure that is correct. The
> point of let* x = e1 in e2 is that e1 _must_ be evaluated before e2 is
> evaluated.


He probably meant having to sequentially feed a read operation with an array
returned by another read operation.


One more thought: let* allows to define a number of variables at the
> same time, so that the two lookups for x and y could be done in either
> order; I'm not sure #! in Clean allows that


Looks like it does with # but not #!.


although I suppose you
> could probably do something like
>
>   #! (x,y) = (lookup a i, lookup b j)
>
> (not sure if that is valid Clean syntax, not tested - but I'd presume
> so).
>

//disallowed
( x , y ) = ( a , b )

//allowed
( x , y ) = temp
where
    temp = ( a , b )

//allowed
( x , y ) = let temp = ( a , b ) in temp
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mailman.science.ru.nl/pipermail/clean-list/attachments/20070531/2955d589/attachment.html