[Haskell-cafe] parallelism or concurrency ? if they are different

Henk-Jan van Tuyl hjgtuyl at chello.nl
Mon Feb 16 18:44:45 EST 2009

On Fri, 13 Feb 2009 11:09:35 +0100, Paolino <paolo.veronelli at gmail.com>  

> When I came to haskell, I arrived with a small and only evolutionary
> background in programming. First monad I met was MonadState StdGen m.
> Everything was in someway acceptable, I had no problem in
> explicitating the need for the generator.
> The lesson was referential transparency. To me referential tranparency
> is still obscure as a feature.
> Not using the monad , my functions pass around a generator, then they
> are repeatable, same generator , same computation.
> Years pass by, now evolutionary algorithms need to scale multicores.
> But multicore can be used with threads or par, the difference is that
> par is pure, because it respects referential transparency. But threads
> not.
> They are always unrespectful ? Or it's an implementation issue of
> preemptive choice?
> Can I have a baton to pass around like I had for random generator, so
> that the computation ends without IO (unsafe performed) , without
> breaking tranparency,
> something like (runIOThreads :: ThreadsIO a -> ThreadsBaton -> a) ?
>> From Real World Haskell my algorithm have to be parallelized as they
> don't do some kind of IO, they don't deal with the world, but where is
> it stated that it is possible  to write them with par (I couldn't) ?
> More , I'm not caring  that my computation is unrepeatable, for me
> it's fine that  the runtime system  gives me the cached results for
> same arguments computation. The fact that it doesn't ,and recompute
> the function giving out something fuzzily different from before, is
> enough to coerce me to spit out IO  values ?
> Finally, why and where the optimizer will substitute a value with its
> definition, so that it possibly get computed twice ?
> Thanks
> paolino

I am not an expert in this matter, but as nobody answered sofar (perhaps  
people were frightened off by a lack of structure in your text), I will  
try to give some pointers:

  - You can start a function with parameters in a thread like this
      threadId <- forkIO (foo 42)
    where foo has type Int -> IO ()

  - Communication between threads can be done with MVars, see:

  - You can find concurrency demos at:

  - Links to articles about parallelism:

  - To prevent recomputing, read:

Henk-Jan van Tuyl


More information about the Haskell-Cafe mailing list