[Haskell-cafe] Mutable arrays

Jeff φ jeff1.61803 at gmail.com
Wed Feb 6 01:14:22 EST 2008

On Feb 5, 2008 4:58 PM, Chaddaï Fouché <chaddai.fouche at gmail.com> wrote:

> 2008/2/5, Jeff φ <jeff1.61803 at gmail.com>:
> > This is interesting.  I've been programming in Concurrent Clean for a
> while.
> >  Instead of monads, Clean supports unique types for mutable arrays and
> IO.
> > In Clean, I can write code that iterates through a mutable array by
> > converting it to a lazy list.  This is convenient because I can use all
> the
> > nice list processing functions that are available.
> >
> You could absolutely write something like that in Haskell, but as some
> have pointed out, this is probably _not a Good Idea_, even though it
> works in your particular case, the array could be modified between the
> time you get the lazy list and the time you actually read it... And
> there's no way to insure it's not happening in Haskell, and I strongly
> doubt there is in Concurrent Clean, could you confirm ?
 Concurrent Clean can handle this in a safe way.  Here's a code snippet for
normalize_2D_ary from ArrayTest.icl:

uToList_2D :: *(a u:(b c)) -> (.[c],*(a u:(b c))) | Array a (b c) & Array b
map_in_place_2d_arr :: (a -> a) *(b *(c a)) -> *(b *(c a)) | Array b (c a) &
Array c a
normalize_2D_ary :: *(a *(b c)) -> *(a *(b c)) | Array a (b c) & Array b c &
/ c & Ord c
normalize_2D_ary ary =
    let (lst,ary2) = uToList_2D ary
        max_elem = foldl1 max lst
    in  map_in_place_2d_arr (\ x -> x / max_elem) ary2
uToList_2D takes a unique array, ary, and returns a tuple containing a list
of the array elements and a "new" array, ary2.  uToList_2D does not modify
ary, but Clean's type system forces any function that accesses a unique
array to thread the array through and return a "new" array.  Under the hood
the "new" array actually uses the same memory storage as the original
array.  So, it is effecient.  Threading the array serializes access
insuring the array won't be modified until the list is complete.  The type
system will generate an error if I wrote code that breaks referential

Array and IO Monads can be implemented in Clean on top of the uniqueness
type system.  The do-notation could be added to the language.
However, the comments I've read so far lead me to believe the code I've
shown cannot be implemented in Haskell using a lazy list without resorting
to unsafe functions.  I'm beginning to suspect the uniqueness type system of
Clean is more general and flexible than Haskell's monads.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20080206/ac8fdb76/attachment.htm

More information about the Haskell-Cafe mailing list