- Haskell-Cafe - Haskell.org

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

Something that kind of resembles OO
by Michael Mossey 09 Jul '10

09 Jul '10

I notice in algebraic data defined with named fields, you can use the same name inside different constructors and then apply it to any data of that type. data Vehicle = Car { ident :: String, wheel :: Circle } | Plane { ident :: String, stick :: Line } f :: [Vehicle] -> [String] f = map ident This is a little like fields in a base class. I also see that a wrong use of accessor functions will compile but give a runtime error: test = wheel (Plane "foo" (Line 1)) Will give a runtime error.

2 1

does () match with a??
by Hector Guilarte 09 Jul '10

09 Jul '10

Hey everyone, I'm making a Game Monad for an assignment (yes, homework) . Here's a little explanation of what I need to do (I can't use anything from Control.Monad.*, I need to do everything myself): I need to define my newtype Game and make it's Monad instance I need to make the function : runGame :: Game a -- A particular game -> Int -- Initial amount of lives -> Maybe (a , Int ) -- Result and remaining lives. I need to make the instance for this class: class Monad m = > GameMonad m where extraLife :: m () getLives :: m Int checkPoint :: m a -> m a die :: m a now what I've done (I was inspired by the State Monad) I defined my Game type as follows: > newtype Game r = Game { execGame :: Int -> Maybe (r,Int) } My Monad instance like this: > instance Monad Game where > return a = Game $ \r -> Just (a,r) > m >>= k = Game $ \r -> let x = execGame m r > in case x of > Just (a, r') -> execGame (k a) r' > Nothing -> Nothing and my GameMonad instance: > instance GameMonad Game where > extraLife = Game $ \l -> Just ((),l+1) > getLives = Game $ \l -> Just (l,l) > die = do > n <- getLives > Game $ \_ -> Just ((),n-1) -- Here's the problem so, what's bothering me? Look at the type signature of die in the GameMonad class, it's supposed to return something of type (m a), but I don't know what to return in that case, and whatever I try to return it doesn't work, because when I try to compile it says that it couldn't match expected type 'a' against infered type 'whatever' ('whatever' being anything, from (), to string, or a number). shouldn't 'a' match with anything I put there? Note that I can't change the signatures because they were giving to me that way and I already checked with teacher if they were right. (I fixed it returning Maybe (Maybe a, Int) instead, but I can't change the signature of the function runGame) Thanks you, Hector Guilarte

3 4

Re: [Haskell-cafe] Multidimensional Matrices in Haskell
by John Lato 09 Jul '10

09 Jul '10

Hello, There are a lot of options. The "array" package, which is included with GHC, provides both mutable and immutable arrays of arbitrary dimensions. A quick scan of hackage shows ArrayRef, ix-shapable, and judy as alternatives, among others. Immutable arrays can be pure, but all mutable array interfaces will require a monad of some type. I usually think ST-based mutability is easiest to work with. John > From: Mihai Maruseac <mihai.maruseac(a)gmail.com> > > Hi, > > A friend of mine wanted to do some Cellular Automata experiments in > Haskell and was asking me what packages/libraries are there for > multidimensional matrices. I'm interested in both immutable and > mutable ones but I don't want them to be trapped inside a monad of any > kind. > > Any hints? > > -- > MM >

3 2

use of modules to save typing
by Michael Mossey 08 Jul '10

08 Jul '10

I'm fairly beginnerish to Haskell, and come from OO. I have a complaint about Haskell, but I think I found a good solution. Any suggestions welcome. I have RSI and like to minimize typing. The use of classes as name spaces helps to do that. Also I can use some Emacs abbreviation magic easily with OO and not so easily with Haskell. I'll explain in a second. In Haskell, when defining data for complex programs I like to use named fields to allow for changing data definitions without having to change all code. But named fields are top-level functions (I think). They must be chosen not to clash. My habit has been to prefix them with the name of the constructor. So in a program for playing back musical documents that needs to track some state, we have: data PlayState = PlayState { playState_cursor :: Int , playState_verts :: [Loc] , playState_len :: Int , playState_doc :: MusDoc } Note all these "playState_" prefixes. Lots of typing, which is not good. In OO, you could type x.cursor() In Haskell you have to type playState_cursor x which also, I feel, is harder to read. Now suppose I want to use PlayState with a State monad. -- Increment the cursor. incrCursor :: State PlayState () incrCursor = cur <- gets playState_cursor len <- gets playState_len let newCur = min (cur+1) (len-1) p <- get put $ p {playState_cursor = newCur} Okay, I'm sorry, that is just a lot of typing for what it is doing. Not good for people with RSI, and not all that readable. I could define a function to make modifying the state a little easier. playState_update_cursor :: Int -> PlayState -> PlayState playState_update_cursor i p = p {playState_cur=i} Then incrCursor would look like: incrCursor :: State PlayState () incrCursor = cur <- gets playState_cursor len <- gets playState_len let newCur = min (cur+1) (len-1) modify (playState_update_cursor newCur) Notice how often the characters "playState_" get typed. This would be a great situation for Emacs abbreviations. When you define an abbreviation in Emacs, such as defining "xps" to expand to "PlayState", emacs will watch for the characters xps. It will then replace "xps" with "PlayState" when you type a non-alphanumeric character following "xps". So if I type "xps." the moment I hit "." it changes to "PlayState." But I would have a hard time using this feature with "playState_" because it is always followed by an alphanumeric character. So my idea, now, is to put the definition of PlayState in its own module and import it qualified as PlayState. ---------------- module PlayState -------------- data PlayState = PlayState { cursor :: Int , verts :: [Loc] , len :: [Int] , doc :: MusDoc } update_cursor i p = p {cursor = i} ----------------------------------------------- I got rid of the "playState_" prefixes because I am not worried about using generic field names like "doc". They won't clash if I always import this qualified. And that reduces the necessary typing in the definition. Now my monad looks like testMonad = do cursor <- gets PlayState.cursor len <- gets PlayState.len let newCur = min (cur+1) (len-1) modify $ PlayState.update_cursor newCur Now I can define an abbreviation for PlayState. This is a big help. Also, I find this more readable. To me PlayState.cursor is more readable than playState_cursor For one thing, syntax highlighting helps in the former case. For another, the latter case requires that you recognize a naming convention, but the former case says clearly: "cursor is within the namespace PlayState, so this combination must be describing a cursor related to PlayState."

6 7