- Haskell-Cafe - Haskell.org

Re: [Haskell] pros and cons of static typing and side effects ?
by Martin Vlk 01 Sep '05

01 Sep '05

Hi folks, have you read this paper: http://www-i2.informatik.rwth-aachen.de/Staff/Current/michaelw/sttt-ml-hask… It contains descriptions of lots of real-world problems and how easily they are solved with Haskell (and ML, because the paper compares the two languages). Among other things it touches on the static typing pros and cons in a way that anyone who ever did serious programming will understand. vlcak

3 3

embedding prolog in haskell.
by Keean Schupke 01 Sep '05

01 Sep '05

Does anyone know if the source code for the embedded prolog (by Silvija Seres & Michael Spivey) is available for download from anywhere? I have read the paper and found some of the types are wrong, some critical definitions are missing, and the definition of unify is missing. Regards, Keean.

3 5

Haskell thread preemption
by Dmitry Vyal 31 Aug '05

31 Aug '05

Hello, all. I'm experimenting with concurrent haskell using GHC 6.4. I wrote these fuctions as described in "Tackling the Awkward Squad": par_io :: IO a -> IO a -> IO a par_io t1 t2 = do c <- newEmptyMVar :: IO (MVar a) id1 <- forkIO $ wrapper c t1 id2 <- forkIO $ wrapper c t2 res <- takeMVar c killThread id1 killThread id2 return res where wrapper :: MVar a -> IO a -> IO () wrapper mvar io = do res <- io putMVar mvar res timeout :: Int -> IO a -> IO (Maybe a) timeout n t = do res <- par_io thr timer return res where thr = do res <- t return $ Just res timer = do threadDelay n return Nothing Now, then I try something like timeout 1000000 (print $ cycle "test") it behaves correctly: repeatingly prints "test" for one second and then returns Nothing. But then I try this: timeout 1000000 (print $ 2^2^2^2^2^2) it hangs for about eight seconds. Currently I'm playing with theorem-proving using resolution. So I need some technique to break a computation, if takes too long. It seems that using "timeout" there does nothing. I waited for several minutes for invalid theorem and timeout didn't expire. "Control.Concurrent" page of "Haskell Hierarchical Libraries" says, that a thread may be pre-empted whenever it allocates some memory, and that tight loops which do no allocation tend to lock out other threads. But resolution function, i wrote, hogs a *lot* of memory and (print $ 2^2^2^2^2^2) does either. So i'm curious about this behavior of timeout. So what is the correct way of running such computations in parallel? Maybe I'm missing something?

1 0

RE: [Haskell-cafe] Haskell poker server
by Bayley, Alistair 31 Aug '05

31 Aug '05

> From: Cale Gibbard [mailto:cgibbard@gmail.com] > > Well, here's an attempt at a start on a similar mechanism for Haskell: > > ---------- (start Packet.hs) > module Packet where > > import Data.Bits > import Data.Word > > class Packet a where > readPacket :: [Word8] -> (a, [Word8]) ... There's a request on LtU for a similar ability (somewhat wider in scope, perhaps): http://lambda-the-ultimate.org/node/view/938 There must be a "gap in the market" :-) 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. *****************************************************************

7 8

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 31 Aug '05

31 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 31 Aug '05

31 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 30 Aug '05

30 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 30 Aug '05

30 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