August 2005 - Haskell-Cafe

Re: Haskell poker server
by Kimberley Burchett 31 Aug '05

31 Aug '05

Hi Joel, I've been working on a library to parse binary data files (java bytecode in my case), and I ended up writing my own DataReader monad for the purpose of reading binary streams. It offers two main features: * It keeps track of how many bytes you've read. This is necessary for reading java bytecode, but probably unnecessary for the protocol you're using. * It supports hierarchical error messages (so you see "error while reading foo: unexpected end of input" instead of just "unexpected end of input"). If you're interested, you can check it out here: http://www.kimbly.com/code/JavaBytecode/ Kim

1 0

Monadic vs "pure" style (was: pros and cons of sta tic typing and side effects)
by Bayley, Alistair 30 Aug '05

30 Aug '05

> From: Martin Vlk [mailto:vlcak01@tiscali.cz] http://www-i2.informatik.rwth-aachen.de/Staff/Current/michaelw/sttt-ml-haske ll.pdf This quote from the paper resonated with me: "Also, if imperative elements of a given application were not taken into account during its design but turn out to be necessary later on, often major parts have to be redesigned or (at least) reimplemented, especially because types change significantly. A simple but recurring example is to add printing of status information to an otherwise purely functional algorithm. In the worst case this could result in having to rewrite the algorithm in a monadic style, but also to rewrite its callers (and transitively their callers as well), plus adjusting all type annotations on the way. Even when using opaque accessors to data structures, the required changes cannot necessarily be limited to a single module, but affect large parts of the system." The difficulty seems to be when you want to turn code that was initially "pure" into monadic code: it requires a fairly substantial rewrite. Once in a monadic style, I expect it is much easier to add various monadic/imperative enhancements. I've experienced this recently, where I've converted an algorithm from a purely functional version, using immutable arrays, to a monadic version using destructive arrays. I introduced errors with the conversion, and the unit test suite that I had for the pure version also had to be converted to a monadic style, in order to test the now-monadic code. So having to perform this conversion is clearly undesirable. I'm reminded of Wadler's "Monads for functional programming" (http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/marktoberdorf.pdf ) where he illustrates how easy it is to extend a program written in a mondadic style. So this begs the question: how much should we stick to a purely functional style? Should we advocate the adoption of a more monadic style from the outset, for programmers new to Haskell too? Alistair. ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

4 3

Haskell poker server
by Joel Reymont 30 Aug '05

30 Aug '05

Folks, I wrote a poker server in Erlang (link in signature) and I'm learning Haskell with an eye towards using it with Erlang. Erlang would take care of the overall control, etc. whereas Haskell would take care of the rest. I'm stuck with the basics I'm afraid and Haskell hackers don't seem to be active this weekend ;). I'm trying to write the poker server in Haskell to compare against my other implementations, specifically the Erlang one. The server talks a binary protocol. A packet notifying the player that a game has started looks like this: 0 1 5 7 +----+-----+-----+ | 24 | GID | Seq | +----+-----+-----+ I get a message from Erlang once data arrives over TCP and the message is a {tcp, Socket, Bin} tuple where Bin is binary data. I can easily extract what I need using Erlang binary pattern matching: read(<<24, GID:32, Seq:16>>) -> {24, GID, Seq}. My code shoots tuples like {24, GID, Seq} back and forth and all is fine. How would I do this in Haskell, though? Some folks have kindly supplied me with references to the various binary I/O packages and some server examples. I'm wondering, though, if someone would be kind enough to show how a packet like above could be sent and retrieved using Haskell sockets. I think this would serve as an excellent example to be posted at the Haskell Wiki. I also think that Haskell has a lot of interesting features that could well simplify my poker coding. I just need a little help to get started. Thanks, Joel -- http://wagerlabs.com/tech

5 5

RE: [Haskell-cafe] generics question, logical variables
by Ralf Lammel 30 Aug '05

30 Aug '05

Frederik, Thanks for the challenge. I didn't get some of the bits about your application scenario though. (What did you mean by the type Pred? Why a list in the result of solve? How did you model typed logical variables? With GADTs, phantoms? ... Perhaps send more code, if you want to discuss this topic more.) So I hope that the attached make sense to you. I do believe so. I have coded a function that converts a term "t Maybe a" to a term "t Id a", where I assume that: - "t" is the Haskell type that may involve Maybe/Id "spots". - Maybe/Id spots for variables are wrapped in a dedicated datatype Spot, - "a" is the type of the term with regard to some custom type system. - The custom type system is model as a class Term. Here is the conversion function: force :: ( Data (t Maybe a) , Data (t Id a) , Term t Maybe a , Term t Id a ) => t Maybe a -> t Id a force = fromJust . tree2data . data2tree This example assumes that all Maybe spots are actually Just values. Clearly, you can do some error handling in case this cannot be assumed. You could also make the Maybe-to-Id conversion part of the traversal that resolves "holes". This is not the challenge, the challenge was indeed to traverse over a term and to "get the types right" when replacing subterms of type Maybe x by subterms of type Id x. The actual type conversion relies on going through the universal Tree datatype. We use "Tree Constr" as the type of an intermediate value. (We could also use "Tree String" but this would be more inefficient. BTW, we take here dependency on the invariant that constructors in Constr are polymorphic. So SYB's reflection is nicely generic; compare this with Java.) When encountering spots during trealization, they are converted from Maybies to Ids. Then, a subsequent de-trealization can do its work without any ado. The deep trealization solves the problem of exposing these type changes to the type of gfoldl. (Amazingly, one might say that the type of gfoldl is just not general enough!) I guess I should admit that: - We temporally defeat strong typing. - We make the assumption that all occurrences of Spot are to be converted. - That is, we don't quite track the type parameter for Maybe vs. Id. - This is a bit inefficient because of going through Tree Constr. So I am willing to summarize that this is potentially a sort of a (cool) hack. Code attached. Ralf P.S.: The extension you propose seems to be a major one. Perhaps you could look into the TH code for SYB3 (ICFP 2005) to see whether this can be automated. This sort of discussion calls for kind polymorphism once again. > -----Original Message----- > From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe- > bounces(a)haskell.org] On Behalf Of Frederik Eaton > Sent: Sunday, August 28, 2005 9:36 PM > To: haskell-cafe(a)haskell.org > Subject: [Haskell-cafe] generics question, logical variables > > Hi all, > > I'm trying to write something like a generic fmap, or a generic > natural transformation. The application is this. I have a typed > logical variable library which produces arbitrary terms with values of > type "Var a", which are references to a value of type "Maybe a", and I > want to write a "solve" function which replaces these values with > instantiated versions of type "Id a" where > > newtype Id a = Id a > > . Furthermore I want this to be reflected in the type of the generic > term: > > solve :: Pred (t Var) -> [t Id] > > so if I have a type like > > data Entry k = Entry (k String) (k Int) > > then I can write some constraint equation with values of type "Entry > Var", and get back values of type "Entry Id" - in other words, objects > where the unknowns are statically guaranteed to have been filled in. > > I looked at the generics library. I may be mistaken, but it seems that > it doesn't have what I need to do this. The problem isn't the mapping, > it's creating a new type which is parameterized by another type. The > only options for creating new types are variations on > > fromConstr :: Data a => Constr -> a > > but what is needed is something like > > fromConstr1 :: Data1 a => Constr1 -> a b > > With something like that it should be possible to define: > > gmapT1 :: (forall b . Data1 b => b l -> b m) -> a l -> a m > > Does this make sense? Here I would be treating all instances of Data > as possibly degenerate instances of Data1 (which just might not depend > on the type variable). > > If it seems like a good idea, I would be interested in helping out > with the implementation. > > Frederik > > -- > http://ofb.net/~frederik/ > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1

How to use STArray?
by Bayley, Alistair 29 Aug '05

29 Aug '05

Hello all, I have a pure function which uses immutable arrays from Data.Array, but it spends about 95% of its time doing array updates. The arrays are used in a single-threaded manner (no need for the old values after an array update), and the arrays are not returned; just one of the elements. So I want to convert it to use STArray, to see if there's a performance gain, but it's not clear how I should tie everything together. I'm believe I don't want to use runSTArray, because I'm not interested in getting an array back from the pure function - just one of the elements. Here's an contrived example: module Main where import Data.Array.ST import Control.Monad.ST main = print (compute 5) compute :: Int -> Int compute n = runST ( do arr <- newArray (-1, 1) n readArray 1 arr ) to which GHC responds: No instance for (MArray a Int (ST s)) arising from use of `readArray' at test.hs:11:4-12 Probable fix: add (MArray a Int (ST s)) to the expected type of an expression or add an instance declaration for (MArray a Int (ST s)) In the result of a 'do' expression: readArray 1 arr In the first argument of `runST', namely `(do arr <- newArray (- 1, 1) n readArray 1 arr)' In the definition of `compute': compute n = runST (do arr <- newArray (- 1, 1) n readArray 1 arr) Alistair ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

10 12

Floating point madness
by Mark Goldman 29 Aug '05

29 Aug '05

I have looked around the net, and in some reference books and I cannot find a function to convert a Float to a Double directly. Can there truly be no such animal in the Prelude/standard libs? -mdg

2 1

haskell and fuse
by David Roundy 29 Aug '05

29 Aug '05

Hi all, I worked for a bit while I was on vacation on a haskell interface to libfuse, which I thought some of you might find interesting. It is VERY much a halted-work-in-progress, as I didn't get very far, and don't have time to continue work on it. You can get what there is with darcs get http://abridgegame.org/repos/fuse_example or browse at http://abridgegame.org/cgi-bin/darcs.cgi/fuse_example It's basically an attempt at combining a nice DarcsIO-style filesystem interface on the haskell side (called FuseIO) with an interface to libfuse (which is a library for creating filesystems from user space on linux). The main file is (quite confusingly) called hello.hs, and you can see that it basically just imports one function from FuseIO and one from Fuse. It tries to do the equivalent of `mount --bind dir1 dir2`, execpt that there's no support for writing to files, or in general modifying the mounted filesystem. I had been thinking (although I now have no time for this) about the possibility of implementing a caching distributed network filesystem which had git as its backend. Of course, I'd start with just a local filesystem with git as the backend, which would be a bit stupid, although it'd have the (very minor) advantage that identical files would be effectively hard-linked as far as space use goes. The FuseIO module itself might be rather interesting for other projects (e.g. darcs), or even (one could imagine) as an alternative to the haskell standard IO libraries for filesystem access, since it'd allow you to write a function that is guaranteed by the typesystem to do nothing but read from a filesystem, and it'd also allow writing polymorphic filesystem access/modification code that could be applied outside the IO monad (e.g. to Slurpies). It would also allow one to use treat network objects (e.g. http or ftp) as filesystems. The Fuse side of things uses hsffig to generate an interface to libfuse, and then translates the libfuse interface into FuseIO commands, so implementing a new sort of filesystem (e.g. sshfs) would require modifying neither FuseIO nor Fuse, but instead just implementing a new FS and plugging it in. But the Fuse interface is very limited, as is the FuseIO interface (which doesn't support, for example, file permissions), so to make a real useful filesystem would require considerable extension of both modules. -- David Roundy http://www.darcs.net

2 1

Hugs - evaluation statistics
by Dusan Kolar 29 Aug '05

29 Aug '05

Hello, Even if I know number of reductions should not be used to anything important I'm quite confused with values I get. Is garbage collection somehow affecting the number of reductions? I have always thought not, but... ;-) Thx, Dusan

3 4

generics question, logical variables
by Frederik Eaton 29 Aug '05

29 Aug '05

Hi all, I'm trying to write something like a generic fmap, or a generic natural transformation. The application is this. I have a typed logical variable library which produces arbitrary terms with values of type "Var a", which are references to a value of type "Maybe a", and I want to write a "solve" function which replaces these values with instantiated versions of type "Id a" where newtype Id a = Id a . Furthermore I want this to be reflected in the type of the generic term: solve :: Pred (t Var) -> [t Id] so if I have a type like data Entry k = Entry (k String) (k Int) then I can write some constraint equation with values of type "Entry Var", and get back values of type "Entry Id" - in other words, objects where the unknowns are statically guaranteed to have been filled in. I looked at the generics library. I may be mistaken, but it seems that it doesn't have what I need to do this. The problem isn't the mapping, it's creating a new type which is parameterized by another type. The only options for creating new types are variations on fromConstr :: Data a => Constr -> a but what is needed is something like fromConstr1 :: Data1 a => Constr1 -> a b With something like that it should be possible to define: gmapT1 :: (forall b . Data1 b => b l -> b m) -> a l -> a m Does this make sense? Here I would be treating all instances of Data as possibly degenerate instances of Data1 (which just might not depend on the type variable). If it seems like a good idea, I would be interested in helping out with the implementation. Frederik -- http://ofb.net/~frederik/

1 0

Data.Graph or Data.Graph.Inductive?
by Kimberley Burchett 28 Aug '05

28 Aug '05

Is there a general agreement as to whether one should prefer Data.Graph or Data.Graph.Inductive? I've read both of the papers, and while I find the Inductive view very compelling, it seems like Erwig was more concerned with elegance than performance, while King&Launchbury seem to value performance more highly. Any guidance as to which package people actually use would be appreciated. Kim

1 0