December 2005 - Haskell-Cafe

Re: [Haskell-cafe] Proper way to write this
by Donn Cave 26 Dec '05

26 Dec '05

Quoth Pupeno <pupeno(a)pupeno.com>: | On Monday 26 December 2005 02:41, Donn Cave wrote: |> I don't think it will be too much worse. I would not try to |> combine the struct updates, in the "both" case -- it doesn't buy |> you anything, and pulls you into duplication you don't want. | What about this | | runDaytimeServer :: DaytimeServer -> IO DaytimeServer | runDaytimeServer dts = do | dts' <- runStreamDaytimeServer dts | dts' <- runDgramDaytimeServer dts' | return dts' | | ? | | I moved the structure update of dts into run_DaytimeServer. Right, that's what I was thinking. Donn Cave, donn(a)drizzle.com

1 0

Proper way to write this
by Pupeno 26 Dec '05

26 Dec '05

I have this piece of code: stopDaytimeServer dts = case dts of DaytimeServer {streamPort = Just _, dgramPort = Just _} -> do killServer (ss dts) killServer (ds dts) DaytimeServer {streamPort = Just _, dgramPort = Nothing} -> do killServer (ss dts) DaytimeServer {streamPort = Nothing, dgramPort = Just _} -> do killServer (ds dts) and I don't like it. I don't like the code repeting. It'd look good with Lips' "when": (define stop-daytime-serve dts (when (stream dts) (kill-server (ss dts))) (when (dgram dts) (kill-server (ds dts)))) Is there a better way to write that on Haskell ? Thanks. -- Pupeno <pupeno(a)pupeno.com> (http://pupeno.com) PS: I have a worse case: -- | Having a 'DaytimeServer', run it according to its specifications. runDaytimeServer :: DaytimeServer -> IO DaytimeServer runDaytimeServer dts = case dts of DaytimeServer {streamPort = Just _, dgramPort = Just _} -> do ss <- runDgramDaytimeServer dts ds <- runStreamDaytimeServer dts return dts{ss = ss, ds = ds} DaytimeServer {streamPort = Just _, dgramPort = Nothing} -> do ss <- runStreamDaytimeServer dts return dts{ss = ss} DaytimeServer {streamPort = Nothing, dgramPort = Just _} -> do ds <- runDgramDaytimeServer dts return dts{ds = ds}

2 1

StringMap
by Christian Maeder 25 Dec '05

25 Dec '05

Hi, could I ask you for efficient StringMap implementations, i.e. based on tries or hash keys? It's mainly for the sake of interest. In the (not too distant) future I'd like to see a library module Data.MapString along the lines of Data.Map and Data.IntMap. So it would be nice (but no requirement) if your implementation could be easily compared to (or exchanged with) the "Data.Map String" instance. (I also still lack a comparison and correctness test infrastructure.) Cheers and Merry Xmas Christian

3 2

kinds question
by David Roundy 25 Dec '05

25 Dec '05

Hello all, I have a question about how to create the right kind to declare lists to be a class. I have a class Foo class Foo f where foo :: f a -> Foo and I want to define that a list of Foos is also a Foo, but can't see how to do it. I imagine something like instance Foo f => Foo [f] where foo xs = map foo xs but of course [f] isn't a valid type. I can define newtype LL f a = LL [f a] instance Foo f => Foo (LL f) where foo (LL xs) = LL (map foo xs) but then I haven't defined anything regarding an actual list. When I try type LL f a = [f a] instance Foo f => Foo (LL f) where foo xs = map foo xs I am informed that LL should have two arguments. Any suggestions? Am I overlooking something obvious? -- David Roundy http://www.darcs.net

2 3

Re: [Haskell-cafe] Haskell vs OCaml
by Donn Cave 24 Dec '05

24 Dec '05

Quoth Tomasz Zielonka <tomasz.zielonka(a)gmail.com>: ... | There are many differences (Haskell on the left): Might also mention foreign (C) function interface (FFI.) ocaml's is I would say average, but ghc's is outstanding, really a different level of support altogether. With regard to the syntax - aside from esthetic questions or awkward notations, there are some practical problems with Objective CAML's common syntax, having to do with optional block delimiters and ";" as a statement concatenator. Sometimes you need to add what seems like gratuitous delimiters to compensate for the kind of unintuitive interpretation. There's a revised syntax that eliminates this problem among other things, but little apparent interest from the community (which figures - they wouldn't be using Objective CAML if this was a high priority for them.) ocaml is nice work, though - very portable compiler that produces native code, and that has helped promote FP in general even if the language isn't all that rigorously functional (mutable strings!?) It seems like it might do very well if it were adopted by basically a new community that would insist on the revised syntax and would make serious use of the OO side of the language, which is kind of interesting. Donn Cave, donn(a)drizzle.com

1 0

zigzag data structure
by Brian McQueen 23 Dec '05

23 Dec '05

I'm curious what this user community would come up with in order to implement the curious zigzag data structure. If you haven't heard anything about it, its a simple but peculiar idea, by the guy who dreamed up the Xanadu project: http://xanadu.com/zigzag/. Conceptually it is "cells" with some sort of value, where each cell has any number of connections to any other cell, but the connections are conceptually labeled/grouped as though they were dimensions. So a cell with the value "Brian McQueen" would have a link to "dorky guy" in the Description dimension, and a link to "519 S. Frances" in the Street Address dimension. Obviously most people would have links in those same dimensions passing through their own name's cell. My cell might have a pointer to "Hector" in the Hero dimension while a conceited man might have a link right back to itself in that same Hero direction. So the structure is very flexible. There are interesting examples on the web site of a Day Planner type of an app where each day has a time line and each time has appointments and the appointments have attendees and they all have personal contact information ... But its all logically linked. I imagine it would be something like this in C-like code: struct cell { value; ptr_to_links }; struct link { { dimension; ptr_to_destination; ptr_to_link; }; struct dimension { name; id; } ; As I write this I realise that I don't remember much, if any, discussion in this group about data structures. I may be starting with a non-functional way of thinking. BTW I'm mostly still at the reading Haskell and fiddling with ghci phase. Brian McQueen

4 5

RE: [Haskell-cafe] Haskell Speed
by Simon Marlow 23 Dec '05

23 Dec '05

On 23 December 2005 19:15, Daniel Carrera wrote: > Hi all, > > I'm taking a look at the "Computer Language Shootout Benchmarks". > > http://shootout.alioth.debian.org/ > > It looks like Haskell doesn't do very well. It seems to be near the > bottom of the pile in most tests. Is this due to the inherent design > of Haskell or is it merely the fact that GHC is young and hasn't had > as much time to optimize as other compilers? GHC? young? We celebrated GHC's 10th birthday a couple of years ago :-) Also, I would like to draw your attention to the fact that GHC wipes the floor with nearly everyone in the concurrency benchmark: http://shootout.alioth.debian.org/benchmark.php?test=message&lang=all Seriously, it's very difficult to draw any meaningful conclusions from these benchmarks. Cheers, Simon

3 2

RE: [Haskell-cafe] Haskell Speed
by Simon Marlow 23 Dec '05

23 Dec '05

On 23 December 2005 20:07, Jeremy Shaw wrote: > Another possible factor is known deficiencies in current IO library > used by most haskell compilers. It is my understanding that the > current IO library was not implemented with speed and efficiency as a > top priority. If someone took the time to optimize/rewrite the current > library code, it might be possible to greatly increase the overall > speed of IO intensive haskell programs with out any changes to the > compilers or language. Not really - the IO library is pretty reasonable, but representing strings as [Char] is holding us back in many of these "benchmarks" significantly. Using the new packed string library will help, though. Cheers, Simon

1 0

Continuations
by Joel Reymont 23 Dec '05

23 Dec '05

Folks, My current setup involves threads that block on a MVar/TMVar until they read an event from it and then proceed. I would like to convert these threads into continuations whereby a continuation is saved when an event is requested and I can call that continuation when an even arrives. I had done this in Lisp before like this: (defun/cc receive (game) (let/cc k ;; save continuation (setf (continuation game) k) ;; TODO: start a timer here )) (defun/cc ask-for-blind (game amount context) (let ((posted nil) (seat nil) (active (car context)) (small-blind-p (= (small-blind$ game) amount))) (while (and (not posted) (car active)) (setf seat (pop active)) ;; skip people who are waiting ;; for the big blind if small blind ;; is being posted. (unless (and (waiting-for-bb-p seat) small-blind-p) (setf (state seat) 'sitting-out) (setf (current game) seat) (send (player seat) 'blind amount) (let* ((cmd (receive game)) <------- note the call to receive here (action (first cmd)) (bet (second cmd)) (inplay$ (inplay$ (player seat)))) ... How would this translate into Haskell and the Cont monad? Alternatively, I would appreciate an example that requests, say, two Ints by saving a continuation each time and returns the sum. Thanks, Joel -- http://wagerlabs.com/

2 4

Optimization help needed
by Joel Reymont 23 Dec '05

23 Dec '05

Folks, These functions together can be taking 15-20% of my processing time. I'm trying to optimize the hell out of them. Would it be less expensive to convert each of them into a foreign function? Is there a way to optimize them further within Haskell? appU_wstr is particularly expensive and deals with reversing the words in a unicode string received little-endian. Thanks, Joel P.S appP_wstr :: Ptr Word8 -> Int -> String -> IO Int appP_wstr ptr ix [] = pickle short ptr ix 0 appP_wstr ptr ix a = do ix1 <- foldM (\ix' c -> pickle endianW16 ptr ix' $ word c) ix a pickle short ptr ix1 0 where word c = fromIntegral $ ord c appU_wstr :: Ptr Word8 -> Int -> IO (String, Int) appU_wstr ptr ix = do (a, ix1) <- unpickle endianW16 ptr ix appU_wstr' ix1 a [] where appU_wstr' ix 0 acc = return $!! (reverse acc, ix) appU_wstr' ix x acc = do (a, ix1) <- unpickle endianW16 ptr ix appU_wstr' ix1 a ((chr $ fromIntegral x):acc) {-# SPECIALIZE swap16 :: Word16 -> Word16 #-} {-# SPECIALIZE swap16 :: Int16 -> Int16 #-} swap16 :: Bits a => a -> a #ifdef BIG_ENDIAN swap16 v = (v `shiftR` 8) .|. (v `shiftL` 8) #else swap16 v = v #endif {-# SPECIALIZE swap32 :: Word32 -> Word32 #-} {-# SPECIALIZE swap32 :: Int32 -> Int32 #-} swap32 :: Bits a => a -> a #ifdef BIG_ENDIAN swap32 v = ( v `shiftR` 24) .|. ((v .&. 0x000000FF) `shiftL` 24) .|. ((v .&. 0x0000FF00) `shiftL` 8) .|. ((v .&. 0x00FF0000) `shiftR` 8) #else swap32 v = v #endif {-# SPECIALIZE swap64 :: Word64 -> Word64 #-} {-# SPECIALIZE swap64 :: Int64 -> Int64 #-} swap64 :: Bits a => a -> a #ifdef BIG_ENDIAN swap64 v = ( v `shiftR` 56) .|. ((v .&. 0x00000000000000FF) `shiftL` 56) .|. ((v .&. 0x00FF000000000000) `shiftR` 40) .|. ((v .&. 0x000000000000FF00) `shiftL` 40) .|. ((v .&. 0x0000FF0000000000) `shiftR` 24) .|. ((v .&. 0x0000000000FF0000) `shiftL` 24) .|. ((v .&. 0x000000FF00000000) `shiftR` 8) .|. ((v .&. 0x00000000FF000000) `shiftL` 8) #else swap64 v = v #endif -- http://wagerlabs.com/

2 2