Windows-native GHC (Yasm issue)

[Peter Tanski]

Hello Bulat,

On Nov 29, 2006, at 4:10 AM, Bulat Ziganshin wrote:
> Wednesday, November 29, 2006, 2:58:39 AM, Peter Tanski wrote:
>
>> optimisations would make that much difference in speed.  I should
>> thank you, in return, for your work on Arrays and the haskell.org
>> Array page.
>
> i'm interesting to know how you use (or pla to use) this lib?

Sorry for the lateness of my reply; I have been too busy to attend to  
email :(

The biggest parts for me are the monad independent references and  
dynamic arrays.  Changing between the ST and IO monad is a hassle,  
although being the picayune sort I tend to watch those  
transformations for time when working with arrays.  Dynamic arrays  
are very handy for data types that need to resize transparently;  
generally, things for which you would normally use lists instead of  
arrays, if they don't change size too often.  Most of my code  
involves evolutionary algorithms (i.e., scheduling), AI-type  
algorithms and some sorting (experimental); every time I use Haskell  
for sorting the time differential makes me cringe.  If you are  
interested I will get some example code for you.

I have kind of a love-hate relationship with Haskell: it is sublimely  
beautiful at the high level but grotesque inside.  Take Monads, for  
example.  They are great for interleaving data (i.e., accumulators).   
On the other hand, especially where the only state maintained is the  
order of execution, all those little bits of data maintaining  
explicit state is merely an artificial machine built on top of a real  
machine: an expensive abstraction, better maintained by reducing  
certain monads to real-world low-level, stateful machine types.   
(Maybe I'm wrrong; can you think of a case where the State, really  
State# s, in the IO monad is actually used as a sequential reference,  
i.e., for "unrolling" back to a previous computation in a list of  
computations?)  My curiosity over an optimiser-based solution is one  
reason I started exploring Cmm and NCG, working backwards to the Code  
Generator (CG) and eventually to STG.

Cheers,
Pete