July 2010 - Haskell-Cafe

ANN: HaRe-0.6, now on Hackage
by Chris BROWN 10 Jul '10

10 Jul '10

Dear Haskellers, As part of our project on Refactoring Functional Programs http://www.cs.kent.ac.uk/projects/refactor-fp/ we are pleased to announce the availability of HaRe 0.6 on Hackage. http://hackage.haskell.org/package/HaRe-0.6 Please see the README.txt for build/use instructions and known issues, and let us know about any problems, bugs, suggestions or additional platforms you can confirm as working. Happy Refactoring! The HaRe Team (Chris Brown, Huiqing Li, Simon Thompson) Background: Refactoring is the process of changing the structure of programs without changing their functionality, i.e., refactorings are meaning-preserving program transformations that implement design changes. For more details about refactoring, about our project and for background on HaRe, see our project pages. HaRe - the Haskell Refactorer: HaRe is our prototype tool supporting a collection of refactorings for Haskell 98 (see README.txt for known issues and limitations). It is implemented as a separate refactoring engine (on top of Programatica's Haskell frontend and Strafunski's generic traversal strategy library), with small scripting frontends that call this engine from either Vim or Emacs.

4 5

Transformers versus monadLib versus...
by Gregory Crosswhite 10 Jul '10

10 Jul '10

Hey everyone, What is the current state regarding transformers versus monadLib versus mmtl versus ... etc.? Transformers seems to be the "blessed" replacement for mtl, so when is it worthwhile to use the other libraries instead? It hadn't even occurred to me to look closely at packages other than transformers for this purpose until I read a message earlier today from someone who said that he uses monadLib whenever he needs to use monad transformers, and it has now made me curious about them. Cheers, Greg

2 1

Memoization in Haskell?
by Angel de Vicente 10 Jul '10

10 Jul '10

Hi, I'm going through the first chapters of the Real World Haskell book, so I'm still a complete newbie, but today I was hoping I could solve the following function in Haskell, for large numbers (n > 108) f(n) = max(n,f(n/2)+f(n/3)+f(n/4)) I've seen examples of memoization in Haskell to solve fibonacci numbers, which involved computing (lazily) all the fibonacci numbers up to the required n. But in this case, for a given n, we only need to compute very few intermediate results. How could one go about solving this efficiently with Haskell? Thanks in advance, Ángel de Vicente -- http://www.iac.es/galeria/angelv/ High Performance Computing Support PostDoc Instituto de Astrofísica de Canarias --------------------------------------------------------------------------------------------- ADVERTENCIA: Sobre la privacidad y cumplimiento de la Ley de Protección de Datos, acceda a http://www.iac.es/disclaimer.php WARNING: For more information on privacy and fulfilment of the Law concerning the Protection of Data, consult http://www.iac.es/disclaimer.php?lang=en

8 15

Fix plugins package.
by Andy Stewart 10 Jul '10

10 Jul '10

Hi all, I want to use *plugins* package (http://hackage.haskell.org/package/plugins-1.4.1) Unfortunately, it looks broken. Anybody can fix it? Thanks, -- Andy

3 9

bug in ghci ?
by Pasqualino "Titto" Assini 10 Jul '10

10 Jul '10

Hi, I just noticed that in ghci: data Test = Test String instance Show Test show $ Test "Hello" Will result in infinite recursion. Is this a known bug? Thanks, titto

9 18

Transformers versus monadLib versus...
by Gregory Crosswhite 09 Jul '10

09 Jul '10

Hey everyone, What is the current state of opinion regarding transformers versus monadLib versus mmtl versus ... etc.? Transformers seems to be the "blessed" replacement for mtl, so when is it worthwhile to use the other libraries instead? (It hadn't even occurred to me to look closely at packages other than transformers for this purpose until I read a message earlier today from someone who said that he uses monadLib whenever he needs to use monad transformers, and it has now made me curious about them.) Cheers, Greg

9 25

Code Example and Haskell Patterns
by Ali Razavi 09 Jul '10

09 Jul '10

Hi, Hackage is a sizable repository of Haskell code; makes me wonder if there is a way to use it more effectively for pedagogical purposes. For example, I really would like to study State monad, monad transformers, applicative, arrows etc. in action--i.e., in the context of a real application rather than small toy examples commonly found in tutorials. If there isn't such a source, can someone point me to an application whose implementation you would consider being a paragon for said concepts? Best, Ali

5 5

FIX Protocol in Haskell (was Re: [Haskell-cafe] Talking to Java from Haskell?)
by Daniel Cook 09 Jul '10

09 Jul '10

> 1) How stable/defined is FIX? Not very. There are several protocol versions, various vendors have their own custom message types, there are service packs released fairly regularly updating the protocol for new message types, etc. > 2) How large of a subset of FIX do you use? I will be using a relatively small subset of the available FIX messages, and my subset will change a lot at the beginning but then stabilize. > work overall. If FIX has only one canonical implementation, changes > frequently, or you'll only use a small portion of it, then b) would > likely be simplest. FIX has one canonical open source implementation (actually 2, but they're the same program ported to C++ and Java). Another option is to use Haskell's FFI to wrap the C++ implementation. QuickFIX is designed exactly the way you *wouldn't* design it to make interop with Haskell easy. The API is based on callbacks to a class which one extends. The C++ uses lots of templates, and the .h files are full of macros. On the plus side, the program has a .idl, and is already SWIG-wrapped for C#, Python, and Ruby. Do you (or anyone) have experience wrapping highly stateful C++ programs with Haskell FFI? Are there examples around? (Xmonad comes to mind, but I don't know if X11's API is C or C++ ..) I think I'm going to have to recreate the various message types in Haskell's type system anyway. Given that, maybe I should simply use Haskell to implement a small, clean, extensible subset of this protocol (what I need). I can then test it heavily against the QuickFIX implementation. Opinions? -- Dan On Fri, Jul 9, 2010 at 2:31 PM, John Lato <jwlato(a)gmail.com> wrote: >> From: Daniel Cook <danielkcook(a)gmail.com> >> >> Hi, >> >> Someone has written a large Java library (QuickFIX/J) which speaks a >> gnarled, ugly protocol (FIX). There don't appear to be any FIX >> protocol libraries in Hackage. I need my Haskell program to talk to a >> 3rd-party system that only speaks FIX. >> >> Should I: >> >> a) Reimplement the protocol directly Haskell? (This appears to be non-trivial) >> >> b) Wrap the Java library with some code to use a lightweight message >> queue (zeromq) to send messages to my Haskell program? (This would >> require essentially re-implementing an abstracted subset of the the >> protocol into 0MQ messages) > > I think you need to answer these two questions to make a decision: > > 1) How stable/defined is FIX? > 2) How large of a subset of FIX do you use? > > If FIX is relatively stable or has multiple (non-C) implementations in > current use, and you'd be using a large-enough subset, then I expect > implementing a Haskell implementation would be the smallest amount of > work overall. If FIX has only one canonical implementation, changes > frequently, or you'll only use a small portion of it, then b) would > likely be simplest. > > Another option would be to expose hooks to your Haskell program > through the FFI and have it called by Java. > > John >

1 0

Other transactional arrays?
by Emil Melnicov 09 Jul '10

09 Jul '10

Currently, Haskell have transactional arrays in "Control.Concurrent.STM.TArray" implemented as "Array i (TVar e)" which is array of transactional variables. But what if I need to place an array into TVar itself? This is something like "TVar (IOArray i e)", but with ability to read/write array elements inside an STM transaction, and then commit changes with "atomically". I've tried to make up this arrays in the following way: > {-# LANGUAGE MagicHash #-} > {-# LANGUAGE UnboxedTuples #-} > {-# OPTIONS_GHC -fno-cse #-} > module Data.Vector.STM > ( TVector > , newTVector > , newTVectorIO > , readTVector > , readTVectorIO > , writeTVector > ) where > import GHC.Conc > import GHC.Prim > import GHC.Types (Int(..), IO(..)) > data MutableArray a = MutableArray (MutableArray# RealWorld a) > data TVector a = TVector (TVar# RealWorld (MutableArray a)) > stm = STM > {-# NOINLINE stm #-} > newTVector :: Int -> a -> STM (TVector a) > newTVector (I# i#) x = stm $ \s1# -> > case newArray# i# x s1# of { (# s2#, a# #) -> > case newTVar# (MutableArray a#) s2# of { (# s3#, t# #) -> > (# s3#, (TVector t#) #) }} > newTVectorIO :: Int -> a -> IO (TVector a) > newTVectorIO (I# i#) x = IO $ \s1# -> > case newArray# i# x s1# of { (# s2#, a# #) -> > case newTVar# (MutableArray a#) s2# of { (# s3#, t# #) -> > (# s3#, (TVector t#) #) }} > readTVector :: TVector a -> Int -> STM a > readTVector (TVector t#) (I# i#) = stm $ \s1# -> > case readTVar# t# s1# of { (# s2#, (MutableArray a#) #) -> > case readArray# a# i# s2# of { (# s3#, a #) -> > (# s3#, a #) }} > readTVectorIO :: TVector a -> Int -> IO a > readTVectorIO (TVector t#) (I# i#) = IO $ \s1# -> > case readTVarIO# t# s1# of { (# s2#, (MutableArray a#) #) -> > case readArray# a# i# s2# of { (# s3#, a #) -> > (# s3#, a #) }} > writeTVector :: TVector a -> Int -> a -> STM () > writeTVector (TVector t#) (I# i#) x = stm $ \s1# -> > case readTVar# t# s1# of { (# s2#, (MutableArray a#) #) -> > case writeArray# a# i# x s2# of { s3# -> > case writeTVar# t# (MutableArray a#) s3# of { s4# -> > (# s4#, () #) }}} It seems like it works, but I'm in doubt about it's correctness. Unfortunately, I don't know much about STM mechanics, so I'm asking Cafe users (you :-) for help.

2 2

Re: [Haskell-cafe] Talking to Java from Haskell?
by John Lato 09 Jul '10

09 Jul '10

> From: Daniel Cook <danielkcook(a)gmail.com> > > Hi, > > Someone has written a large Java library (QuickFIX/J) which speaks a > gnarled, ugly protocol (FIX). There don't appear to be any FIX > protocol libraries in Hackage. I need my Haskell program to talk to a > 3rd-party system that only speaks FIX. > > Should I: > > a) Reimplement the protocol directly Haskell? (This appears to be non-trivial) > > b) Wrap the Java library with some code to use a lightweight message > queue (zeromq) to send messages to my Haskell program? (This would > require essentially re-implementing an abstracted subset of the the > protocol into 0MQ messages) I think you need to answer these two questions to make a decision: 1) How stable/defined is FIX? 2) How large of a subset of FIX do you use? If FIX is relatively stable or has multiple (non-C) implementations in current use, and you'd be using a large-enough subset, then I expect implementing a Haskell implementation would be the smallest amount of work overall. If FIX has only one canonical implementation, changes frequently, or you'll only use a small portion of it, then b) would likely be simplest. Another option would be to expose hooks to your Haskell program through the FFI and have it called by Java. John

1 0