- Haskell-Cafe - Haskell.org

RE: [Haskell-cafe] Re: Thread pool in GHC
by Simon Marlow 14 Sep '05

14 Sep '05

On 07 September 2005 16:04, Dinh Tien Tuan Anh wrote: > So is there a way to reuse thread ? > I think eventhough threads in GHC are extremely lighweight, it still > make a different if u keep launching and killing thread in so many > times. My advice would be to try without a thread pool first, and see if you have any performance problems. My guess is that you won't - threads are so lightweight that you might end up with *worse* performance if you use a thread pool. Cheers, Simon

1 0

some algorithm help with jhc
by John Meacham 14 Sep '05

14 Sep '05

I have started working on jhc more recently and have come across some places where I think my algorithms could be improved but was not sure exactly where to start so thought I would ask the list since perhaps someone here has some insight. After a long time of trying various methods of speeding up the fixpoint iteration of my points-to analysis (the current main bottleneck) I decided to step back and look at the basic problem again. It turns out I can express the problem as one of constraint satisfaction resulting in much smaller code (600 lines vs 2000) and 10fold speedups with my unoptimized first draft solver. It is much faster but still not as fast as I'd like. I don't know a lot about constraint problems, but my intuiton says this particular problem is of a type that should be particularly easy to solve but am uncertain where to start in my searching to find a fast algorithm. My constraints come in two types of rules. the rules are of the form (where a and b are variables to be solved for and x and y are values in my domain) * a >= f(b) where x >= y implies f(x) >= f(y) * enforce g(a) as a new set of rules where if x >= y then g(x) subsumes g(y) f and g are typed thusly. f :: domain -> domain g :: domain -> set of rules the following useful derived rules can be expressed by the above. a >= b a == b if z(a) then b >= c now, the reason my intuiton says there should be a fast solution is that there is no way for the variables to decrease. every added rule can only add to the least solution and not shrink any set. so, my basic question is, is this a known form of constraint satisfaction problem? does it admit a particulary fast solution as my intuition tells me? does it have a name I can search for on scholar.google.com? my current first draft implementation represents each rule as an IO action taking a difference set that propegates said difference set and then adds it to the current set for each var. The second problem I am facing is one of debugging. my code dealing with jhc core and all the optimizations that are performed on it has gone through a lot of evolution. over time, bugs have been introduced that are very hard to track down, the symptom would be suddenly having core that doesn't typecheck or has an unknown identifier or worse a segfault in the generated program. backtracking to find the error is quite tedious, mainly involving commenting out transformations until I find the offending one, then rederiving the correct code and comparing it to what I have written. I have decided to remedy the situation and start using QuickCheck to verify all my transformations are meaning and type preserving. however, the problem arrises in how to come up with a meaningful instance of Arbitrary for expressions in jhc core. It is not clear at all how to come up with code that generates random yet "interesting", well typed, convergent, terms in the extended lambda calculus with things like recursive definitons and primitives. even if I solved that, the problem of deciding whether two expressions (which might be functions) do the 'same thing' is undecidable, so how do I even test if the transformations are meaning preserving? Ideally, someone would have written a paper on this. I have seen several papers on generating suitable random graphs for testing graph algorithms, but have not come across one on creating typed lambda calculus terms. perhaps someone else has come across this same problem and has some insights? I am interested in ideas, brainstorming and pointers to papers or terms to search for as much as ready made solutions. In any case, I think they are interesting problems to begin with... hopefully someone out there thinks so too :) John -- John Meacham - ⑆repetae.net⑆john⑈

2 1

RE: [Haskell-cafe] Haskell poker server
by Simon Marlow 13 Sep '05

13 Sep '05

On 28 August 2005 20:00, Joel Reymont wrote: > 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}. I didn't see anyone mention this (apologies if I missed it), but the House project does parsing of network packets and has some useful combinators for parsing binary data: http://www.cse.ogi.edu/~hallgren/House/ Cheers, Simon

1 0

RE: [Haskell] mailing list headaches
by Simon Marlow 13 Sep '05

13 Sep '05

On 08 September 2005 17:53, Glynn Clements wrote: > Frederik Eaton wrote: > >> However, threading by "References", which RFC 2822 says >> SHOULD be possible, and which works on my other folders, doesn't work >> well on Haskell mailing lists. Presumably the issue is that there are >> a large number of Windows users with strange mail clients which don't >> insert "References" headers. > > It isn't so much that there are a large number of such users, but that > two of the core developers are among them (and are both employed by > Microsoft, so RFC-conformance probably isn't an option). Yes, this is partially our fault. When using Outlook through Exchange, the In-Reply-To header isn't generated at all. Outlook via SMTP works fine, though. I reported the bug several years ago, let's see if Office 12 fixes it :) Cheers, Simon

1 0

Language Workbenches - the Haskell solution?
by Yoel Jacobsen 13 Sep '05

13 Sep '05

It seems that Martin Fowler's article "Language Workbenches: The killer-App for Domain Specific Languages?" - http://www.martinfowler.com/articles/languageWorkbench.html - has generated some nice dynamic solution where a configuration file is written in the same language as the program. Notable examples are lisp - http://lispm.dyndns.org/news?ID=NEWS-2005-07-08-1 and python - http://billionairebusinessman.blogspot.com/2005/09/drop-that-schema-and-put… I'm trying to create an _elegant_ solution in Haskell. But I'm stuck. Since the native record-like access in Haskell syntax is using labelled fields in datatype decleration but the later are strictly compile-time. Therefore, if I compile my program and add a field in the configuration file (written in Haskell, using, for instance hs-plugins), I'll need to recompile the data declaration as well. Further, what is the type of the parser? Consider the following implementation: source = "#123456789012345678901234567890123456789012345678901234567890\n\ \SVCLFOWLER 10101MS0120050313.........................\n\ \SVCLHOHPE 10201DX0320050315........................\n\ \SVCLTWO x10301MRP220050329..............................\n\ \USGE10301TWO x50214..7050329..............................." data Configuration = Config String [(String, Int, Int)] config = [ Config "SVCL" [("CustomerName", 4, 18), ("CustomerID", 19, 23), ("CallTypeCode", 24, 27), ("DateOfCallString", 28, 35)], Config "USGE" [("CustomerID", 4, 8), ("CustomerName", 9, 22), ("Cycle", 30, 30), ("ReadDAte", 31, 36)]] -- parse takes the configuration, a line from the source string and generate a record parse :: Configuration -> String -> Record What is the type of Record? Anyway, any elegant solution or a hint towards one are most welcome. Thanks, Yoel

3 4

Template Haskell and Types
by Gracjan Polak 13 Sep '05

13 Sep '05

Hi, Probably very simple question about template haskell: How do I make a type for an argument to splice? Example: data MyData = MyData1 | MyData2 mysplice mytype = [| litE $ stringL $ show mytype |] main = do putStrLn $(mysplice MyData) The above is not accepted, error: Compiling Main ( thtest.hs, thtest.o ) thtest.hs:51:34: Not in scope: data constructor `MyData' So how do I provide type as an argument? Besides: documentation that I found for th is very dated. Could somebody point me to something more up to date about th? Thanks! -- Gracjan

4 4

RE: [Haskell-cafe] Language Workbenches - the Haskell solution?
by Ralf Lammel 13 Sep '05

13 Sep '05

Hi Yoel, This looks like fun. Just some general comments: - One should try to *also* provide a simple solution. Here I would pick a solution that doesn't need a lot of explanation (of Haskell and the solution) and a lot of defense to score with it. - As a second step, one should identify a sweet spot upfront. The sweet spot could indeed be to get some extra static typing; some extra DSL checks; some increased declarativeness. (Or all of it.) To this end, I would study the DSL problem at hand, and not so much yet think of Haskell encoding. You can only score with Haskell, if there is something to be scored with in the problem at hand. - Now one can explore the identified sweet spot by trying to put strong Haskell features such as hs-plugins or Data.Generics or Data.Dynamic or phantoms or all of them or something else to work. - I haven't looked at the discussion, but a sophisticated Java solution could also try to score with dynamic class loading, reflection, perhaps even with compile-time reflection a la OpenJava. One would need to be prepared to cope with that ;-) - XML wasn't mentioned in your message. I wonder whether they discuss it in the actual thread. (Yes, you might be saying XML is not the same language as you are programming in, but it so easy to process XML in many languages, and one uses XSD for the DSL syntax). In fact, in Haskell I would strongly consider using HaXML or similar technology for non-trivial configuration problems. XML makes configuration also more portable. In reality, I don't see much value in using the programming language syntax for representing the configuration information. This makes it only harder to process those configurations with other tools. Ralf > -----Original Message----- > From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe- > bounces(a)haskell.org] On Behalf Of Yoel Jacobsen > Sent: Thursday, September 08, 2005 11:41 AM > To: haskell-cafe(a)haskell.org > Subject: [Haskell-cafe] Language Workbenches - the Haskell solution? > > I'm trying to create an _elegant_ solution in Haskell. > ... > Further, what is the type of the parser?

3 3

Where to start about writing web/HTTP apps ?
by gary ng 12 Sep '05

12 Sep '05

Hi, I just start learning haskell and have to say that it is stunning in how precise it can be(coming from a background of C then python/perl/js). I want to write apps for WEB and have briefly read WASH. However, that seems to be a CGI based solution. What I want is a native HTTP server(written in haskell), like Twisted/Cherrypy in Python. Are there any boilerplate(I know I should scrap the boilerplate but I need to have something to get start) for reference ? In addition, during my learning process, I keep on using my old experience as reference such as writing simple programs that needs functions like ltrim/rtrim/substr etc. that is in almost any language I have used. But it seems that haskell doesn't have it. I know that a haskell expert can write them in no time with things like dropWhile and reverse, it is a bit frustrating for new comers from a imperative background. Oh, while I am still here, I am reading "The Evolution of a Haskell Programmer" http://www.willamette.edu/~fruehr/haskell/evolution.html and learning the various way to tackle the same problem. Obviously, there are lots of things I don't know what it is about and I would tackle them as time go by. But I have problem even with the seems to be simple one like this : fac n = foldr (\x g n -> g (x*n)) id [1..n] 1 I can understand a foldl or foldr version but have problem with this, especially the "id" and the trailing "1" and the function being folded takes 3 parameters instead of 2(as in standard foldr/foldl solution). Would appreciate if someone can knock on my head and tell me what is going on in it. thanks for help in advance. regards, gary ______________________________________________________ Click here to donate to the Hurricane Katrina relief effort. http://store.yahoo.com/redcross-donate3/

7 10

Fwd: [Haskell-cafe] ghc for sunos
by Brian McQueen 12 Sep '05

12 Sep '05

---------- Forwarded message ---------- From: Brian McQueen <mcqueenorama(a)gmail.com> Date: Sep 9, 2005 9:14 AM Subject: Re: [Haskell-cafe] ghc for sunos To: Donald Bruce Stewart <dons(a)cse.unsw.edu.au> I installed it and its choking while looking for libreadline. I'm not an admin on these machines, so my options are limited. It seems to be a bit of an odd error msg though in that the search path looks wrong: ld.so.1: /users/bqueen/lib/ghc-6.2.2/ghc-6.2.2: fatal: libreadline.so.4: open failed: No such file or directory Why would the ghc dir be in there twice? Brian McQueen On 9/8/05, Donald Bruce Stewart <dons(a)cse.unsw.edu.au> wrote: > mcqueenorama: > > Is there a ghc for SunOS? I don't see on in the list. How hard would > > it be to make one? I'm surrounded by Sun boxes here. > > GHC runs on sparc/solaris and i386/solaris. Is that what you're looking > for? Have a look at the earlier 6.x releases for binaries for this OS. > > -- Don >

3 3

RE: [Haskell-cafe] Language Workbenches - the Haskell solution?
by Ralf Lammel 12 Sep '05

12 Sep '05

Yoann, Thanks for your comments. Yoann wrote: I don't think XML is a good idea for files that are managed/edited by humans. I think the users prefer simpler files with a custom syntax, and the user is the king. I don't mind, but when you say "user" do you mean "application configuration admin" or "plain application user". The former may know/like/dislike PL syntax, the latter may not like *anything* but very simple and foolproof formats or GUI-based configuration. There is no reason to believe that the latter wants to feel like programming in Haskell, Java, ... at least not in the universe I live in or that I observe. Yoann wrote: Of course the job of the programmer is easier when the file is coded in XML, ... This is unrelated to what I said. Perhaps my wording wasn't clear enough. I was trying to refer to the software life cycle and tool support as a whole. Doing software re-engineering for configurations that are formulated in a Turing-complete language is no fun. This is quite similar to the known issues with macros, when used for configuration; you may want to read about software asbestos here: http://homepages.cwi.nl/~ralf/am/ Yoann wrote: I am a programmer and personally I don't want to code my Haskell code in XML I didn't propose *that*. Anyway, picking up the new subject that you introduced accidentally, let me reply: you are not alone: most programmers don't like to code their PL code in XML. (As an aside, XML is used even for coding these days, just in case you don't know: check out some widely used AOP language extensions for Java. I am not saying whether I like this or not.) Yoann wrote: so I presume it is the same for the user with configuration files. So you presume that a user of application XYZ prefers to configure his/her application in the syntax of the underlying implementation language, supposing there is just one? That's a very interesting presumption. Have you any data to substantiate your presumption, or is that a prediction for the future? Yoann wrote: if your programming langage is lisp in which case parsing the configuration file is just a call to read. Sure! Sounds a bit like comparing apples and oranges. I can also parse my configuration file to "Data.Tree String" in Haskell, or something similarly weakly typed. Then parsing is just a call to read, too. (Lisp really doesn't score here.) So what's the point? I guess we won't be happy with that Haskell solution, or at least we would like to see whether we can score with Haskell in some way. Ralf

1 0

Monad, more than one of them ?
by gary ng 11 Sep '05

11 Sep '05

I am reading "Monads for functional programming" from http://homepages.inf.ed.ac.uk/wadler/topics/monads.html, which is IMO the best explanation of monad I have seen so far. What I would like to know is, what if I need more than one of them at the same time. Using the example given in the paper, it is quite comment that one would need exception handling, state management and output all at the same time. In an imperative language, one can do all three at the same time in the normal flow like wrapping a try/catch block, make some state changes to a global variable and make some io calls. How would one do it in a monadic way ? As my understanding of Monad is that it is something like a "wrapper/container" where the side-effect is kept. One way of doing it is of course expand it to include all three side effects. But this is unmanageable and it is no different than the non-monadic version mentioned in the paper. Another way I can see is to "wrap" one monad with another and so on. But this can also get complicated as what if I have 10 type of monads that can be permutated in various way. ______________________________________________________ Click here to donate to the Hurricane Katrina relief effort. http://store.yahoo.com/redcross-donate3/

3 2

RE: [Haskell] Monadification as a refactoring [was: Mixing monadicand non-monadic functions]
by Ralf Lammel 11 Sep '05

11 Sep '05

Frederik, [I am trying to drag this voluminous thread to cafe.] Jeremy Gibbons mentioned Martin Erwig and Deling Ren's paper on monadification. Very useful, indeed -- also with regard to the question you seem to ponder about; also see here for an early take on monadification, if you like http://homepages.cwi.nl/~ralf/sfp99/ and more recently, an interesting use case for it: http://homepages.cwi.nl/~ralf/foal03/ I disagree with you: Monadification transformations are certainly reversible. I *do* realize that you were not talking about plain reversibility but rather "a refactorization should have an inverse which commutes with simple edits". Let's talk about plain reversibility first. So you go from a non-monadic program to a monadic program. What monad do you choose initially? You use the identity monad, at least conceptually. (Making the monadic parametric, if intended, can be seen as an extra generalization step. To use such a generalized program, you would still need to commit to a specific monad eventually at a higher level of the program. So for simplicity it makes sense to start from a monadified program that uses the identity monad. A single monadification refactoring is not enough anyhow, if you care about monad-related program edits in a broader scope. You would also need extra refactorings and refinements for extending and reducing the monad through symbolic monad transformations and a few others, I presume.) Inlining the identity monad operations plus some bits of beta reduction get you back to the original program. (There are some subtle technical issues. For instance, getting rid of a monad, even if it is not used through actions, may still be difficult due to strictness/bottom lifting issues. See such details in Martin's paper.) How do go beyond plain reversibility for monadification? Your examples of refactorings were not fair. They did not admit that undoing refactorings *after program edits* is a problem for *many* established refactorings. Monadification is not really special in so far. (It is perhaps special in so far that it is generally a rather involved refactoring, compared to extract/inline method.) You mention (i) "extract function" followed by (ii) "edit function" followed by (iii) "inline function". (iii) is the inverse refactoring for (i). Now try this (iii), (ii') edit inlined code, (i). How do you know what to extract in the last step? How do you know where to extract (if you changed only n out of m inlining locations)? AND SO ON. These are all not insurmountable problems but they are quite similar to the "challenges" you run into once you want to inverse monadification. *As long as we keep the notion of "edits" vague, as you did, it shouldn't be surprising that reversibility after edits is not clear either.* Obviously, some edits can be handled by de-monadification. As long as the edits do not start to commit to monadic style by means of engaging into a specific non-identity monad *and* using monadic actions, then it is safe to exclude monadic style again. (Making this precise and really *safe* is difficult enough.) But even once you start to use commit/engage, after monadification, there are ways to eliminate it again on the basis of special treatments per monad. (Think of refactorings that extract or inline monadic style for specific monads; for instance state passing through extra argument and result components.) Also, you may reduce the amount of monadic style. HaRe efforts are addressing some concepts like this, I guess. Ralf > -----Original Message----- > From: haskell-bounces(a)haskell.org [mailto:haskell-bounces@haskell.org] On > Behalf Of Frederik Eaton > Sent: Saturday, September 10, 2005 4:25 PM > To: Claus Reinke > Cc: haskell(a)haskell.org > Subject: Re: [Haskell] Monadification as a refactoring [was: Mixing > monadicand non-monadic functions] > > On Sat, Sep 10, 2005 at 12:55:15AM +0100, Claus Reinke wrote: > > life is funny, isn't it? so many people so eagerly > > lazily, in my case > > > discussing conversion between non-monadic and monadic code, > > I'm trying to discuss a new syntax, not code transformations. I agree > that the two are related. I'm interested in the latter, but I don't > understand it very well. I think of refactoring as an operation that > takes source code to source code, i.e. unlike most operations done on > source code, refactoring produces output which is meant to be edited > by humans. Is this correct? But if it is, doesn't it mean that one > would like refactorizations to have some ill-defined "reversibility" > property: > > a refactorization should have an inverse which commutes with simple > edits > > For instance, if I (a) rename a variable, and then (b) introduce a new > reference to the renamed variable somewhere, I can later decide to > change the name back, reverting (a), without losing the work I did in > the meantime in (b). I can do this by applying another rename > operation, which will also affect the new reference. > > Or, if I (a) take a bit of code and remove it to a separate function, > and then (b) modify the body of that function, I can later decide to > inline the function back into the one place which calls it, thus > reverting (a), without losing the modification done in (b). > > Yet, I don't see how the "monadification" operations you propose could > have this property. They are certainly code transformations! But they > seem irreversible - once I (a) apply your transformations and (b) edit > the output, I can't revert (a) without losing the work done in (b). > Changes to the code become tightly coupled, design becomes less > tractable. > > > yet when we asked for your opinions and suggestions on this very > > topic only a short while ago, we got a total of 4 (four) replies - > > all quite useful, mind you, so we were grateful, but still one > > wonders.. we might have assumed that not many people cared after > > all: > > > > http://www.haskell.org//pipermail/haskell/2005-March/015557.html > > It might have been more useful to ask for survey replies to be sent to > the list. Often the various opinions of a large number of people can > be compressed to a few representative positions. But if respondents > can't see what opinions have been expressed so far, then this > time-saving compression becomes impossible. That is just my opinion. > > > shall I assume that all participants in this discussion have joined > > the Haskell parade since then, and have proceeded rapidly to the > > problems of monadic lifting?-) in which case I'd invite you to have > > a look at that survey and the papers mentioned. > > I should do that, yes! > > It's just that I was a bit late, having misplaced my trumpet. > > > > > I thought the easy answer would be to inject non-monadic values into > the > > > > monad (assuming one already rejiggered things to do automatic > lifting). > > > > I'd phrase it slightly differently: what (I think) one wants are > implicit coercions > > between monadic and non-monadic types of expressions, where the > coercions > > lift non-monadic values into the monad in question, while embedding > monadic > > computations in the current monad to get a non-monadic result if only > that is > > needed (although one might think of the latter as partially lifting the > operation > > that needs the non-monadic result). > > > > only I wouldn't want those implicit coercions to be introduced unless > > programmers explicitly ask for that (one usually only converts code from > > non-monadic to monadic once, and while the details of that step might > > be tiresome and in need of tool-support, the step itself should be > explicit > > - see my comment on (2) below). > > > > > Note that in (a), "pure" values are never used where monads are asked > > > for, only the other way around. > > > > that is probably where some would beg to differ - if you lift > operations, > > why not lift values as well? > > Oh, one should do both, I was just giving a case where value-lifting > didn't happen, as a counterexample to Aaron's viewpoint. > > > > I think that supporting syntax (a) for semantics (b) should be a > > > feature because: (1) it is (usually) obvious what (a) means; (2) it > > > eliminates the single-use variable 'v' - single-use variables like > > > this occur a lot in monadic Haskell code, and I think they make it > > > harder to read and write; (3) it would support the math-like syntax > > > that I presented in my original message. > > > > (1) "(usually) obvious" is tech-speak for "(perhaps) possible to > > figure out, though probably not uniquely determined"?-) > > > > when mathematicians abuse notation in the "obvious" way, > > there is usually an assumed context in which the intended > > abuses are clearly defined (if not, there is another context > > in which the "obvious" things will go unexpectedly awry). > > > > (2) the nice thing about Haskell is that it *distinguishes* between > > monadic and non-monadic computations, and between evaluation > > and execution of monadic computations. if you want everything > > mixed into one soup, ML might be your language of choice > > (http://portal.acm.org/citation.cfm?id=178047 , if I recall > correctly? > > see the paper discussed in > > http://lambda-the-ultimate.org/node/view/552 > > for one application that demonstrates the power/danger of such > > implicit monads). > > > > (3) using math-like syntax for lifted expressions is common practice > > in some families of Haskell-DSELs, eg. Conal Elliot's Fran. As John > > pointed out, the predefined class-hierarchy is not really helpful > > for such endeavours, but if one isn't picky, one may ignore classes > > not used.. the "trick" is to lift even constants, so when you get > > to applications, all components are already lifted, and lifting most > > arithmetic works out fine (Boolean operations are another matter). > > > > note, however, that the resulting language, while looking > > mathematically pure and permitting concise expression of complex > > circumstances, may not have the reasoning properties you expect.. > > At this point I think we have to look at more examples. I'm not > convinced that my position is right, but I'm not convinced that that > it is wrong either. I just think it's promising, based on my > experience. If I were a better person, and had more free time, I would > work on producing examples and working things out myself, and perhaps > write a paper or something. > > Of course, experienced people are disagreeing with me, so maybe I > should just accept their good judgment! In any case, I'm afraid I > don't have much more to contribute, beyond the idea itself. > > > > It might be hard to modify the type checker to get it to work, but I > > > think it is possible, and I see no reason not to be as general as > > > possible. > > > > here I'd agree, although in contrast to you, I'd be talking about a > > complex refactoring under programmer control, not about an implicitly > > invoked collection of coercions. I played with that idea after Martin > > Erwig visited our refactoring project in March, and got to a prototype > > type-coercion inference system for a very simple functional language, > > because I found the situation with various existing and, as Erwig/Ren > > pointed out, apparently unrelated monadification algorithms confusing. > > > > apart from the various styles of monadification, which we'd like > > to permit, and have the programmer select, e.g., by type annotations, > > there is the slight problem that there are an unbounded number of > > different monadifications (more if one wants to keep annotations to > > a minimum), so one needs a sensible bound (one that does not > > exclude any of the alternatives one might want). one also might > > want to be able to choose between the alternatives (or tune the > > system so that taking the first choice works out ok most of the > > time). oh, and it shouldn't be too inefficient, and it is really a pain > > to re-implement a type-system just to add a few coercion rules to > > it (which is why I haven't extended my mini fpl to Haskell yet..). > > Well, I've said a little about why I don't like irreversible > refactoring. I've been reading "Notes on the Synthesis of Form" by > Christopher Alexander, I think this has helped me understand the > process of design in more abstract terms, if you want a reference. > > I think the source code of a program should be as close to its initial > specification as possible. The goal should be to make it as easy to > read and modify as it was to write. However, if the design is spread > out over write/test/debug cycles, as is often the case in interpreted > languages such as perl; or refactor cycles, as you seem to be > proposing; then a lot of the decisions and rationales which determine > that design will not be visible in the final version of the code - > rather, they will be stored in the succession of modifications which > have been applied to create this final version. But these > modifications are, as it were, difficult to go back and modify. The > more a program is produced through a process of accretion or > evolution, the more tightly coupled various aspects of its design will > be, and the more difficult it will be to change any one of them. > > Even if most of the design decisions are good ones, eventually the > number of unfixable bad decisions will grow until continued > development of a particular component becomes untenable. This might > happen at a function level or a module level or a program level - but > in any case I think the development style in question should be > avoided where possible, and made avoidable where feasible. > > Frederik > _______________________________________________ > Haskell mailing list > Haskell(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell

1 0

How to debug GHC
by Monique Louise de Barros Monteiro 10 Sep '05

10 Sep '05

Hi, all, I'm developing a back end for GHC and I have the following problem: my program is throwing an "empty list exception" due to head [] and I need to compile GHC with -prof -auto-all in order to see the stack trace when running it with +RTS -xc -RTS. I changed the makefile but the option +RTS -xc -RTS was not recognized as an available RTS option Does anyone have any idea about how I can do that ? Thanks in advance, __________________________________________________ Monique Louise Monteiro Mestranda em Ciencia da Computacao Centro de Informatica - CIn - UFPE

14 21

[Announce] CabalFind 0.1
by Dimitry Golubovsky 10 Sep '05

10 Sep '05

Some time ago, I expressed an idea that certain search engines may be used to collect information about existing .cabal packages whose developers made them indexable by those engines. Finally, I have written an experimental library, CabalFind. The library provides a generalized interface to search engines, and also sample implementations for Google and Yahoo* I haven't set it up as a separate project, say, on SourceForge because I am not sure whether it is feasible to do so. Instead, I am suggesting that the developers of Haskell Library Infrastructure decide whether this library may serve as a basis for library infrastructure maintenance utilities. The library may be downloaded at darcs get http://www.golubovsky.org/repos/cabalfind/ or http://www.golubovsky.org/repos/cabalfind/cabalfind.tar.gz The .cabal file for the package is tailored for GHC 6.2.2. For use with 6.4, changes may be necessary, as the XML Toolbox for 6.4 no longer includes the HTTP module, so HTTP.cabal needs to be included in build-depends. More information provided at http://haskell.org/hawiki/CabalFind Any feedback is appreciated. Dimitry Golubovsky Middletown, CT ------ * Only these two search engines are found to be able to search by URI suffix (.cabal in our case); without this feature package search becomes very inefficient.

1 0

ghc for sunos
by Brian McQueen 09 Sep '05

09 Sep '05

Is there a ghc for SunOS? I don't see on in the list. How hard would it be to make one? I'm surrounded by Sun boxes here.

3 2

Re: [Haskell] Mixing monadic and non-monadic functions
by Ben Lippmeier 08 Sep '05

08 Sep '05

> Do you disagree with that > assertion? Or are you just saying that the syntax change as I propose > it is called "effect analysis"? Sorry, I thought you were talking about the usability of IO and State monads in particular, not more general ones. When I was talking about effect analysis it was along the same lines as how (fun1 :: a -> IO b) and (fun2 :: a -{IO}> b) are basically equivalent - though IMHO fun2 can be easier to use because it's type is a bit more orthognal to a "pure" function (fun3 :: a -> b). Ben.

1 0

Practical introduction to monads
by Paul Moore 07 Sep '05

07 Sep '05

I've started learning Haskell, and I'm going through all the tutorial material I can find - there's a lot of good stuff available. One thing I haven't found a really good discussion of, is practical examples of building monads. There's plenty of discussion of the IO monad, and the state monad, and a lot of good theory on monads, but although I've seen tantalising statements about how powerful the ability to define your own monads can be, but no really concrete examples - something along the lines of - here is problem X - this might be our first cut at coding it - we can abstract out this stuff, as a monad - see how the code looks now, how much cleaner it is (I've seen this type of model developing a state monad, but I'm looking for a more application-specific approach). Also, a lot of (non-IO) monad code I've seen seems to revolve around higher order features like monad combinators, which, while certainly powerful, still make my head explode. On the other hand, monadic IO feels entirely comprehensible, revolving round do-notation, and looking reassuringly sequential and imperative :-) Surely there are other uses of monads which can feel familiar to non-functional programmers? Otherwise, I'm still left with the (inaccurate, and unhelpful) impression that "IO is a badly integrated exception"... I don't know if the above makes sense. I've struggled with this for a while now, and haven't managed to express my confusion any more clearly - for which I apologise. I'd appreciate any pointers or explanations. FWIW, I've read (among other papers) "Why Functional Programming Matters", "A Gentle Introduction to Haskell", Hal Daume's "Yet Another Haskell Tutorial", Simon Peyton Jones' "Tackling the Awkward Squad", and "Haskell: The Craft of Functional Programming". I don't claim to have digested all of this - indeed, there are probably many areas I've only skimmed - so pointers to areas in these documents I might have missed would be appreciated. On the other hand, pointers to papers I've missed altogether would also be gratefully received. Thanks in advance for any help, Paul. -- There is a theory which states that if ever anybody discovers exactly what the Universe is for and why it is here, it will instantly disappear and be replaced by something even more bizarre and inexplicable. There is another theory which states that this has already happened. -- Douglas Adams

11 20

Re: [Haskell-cafe] Concurrency question
by Dmitry V'yal 07 Sep '05

07 Sep '05

Donald Bruce Stewart wrote: > Can I ask if just using a `seq` works as well? That was enough (now I > recall) for the watchdog code I posted earlier. > > -- Don In my case this doesn't work >timeout :: DeepSeq a => Int -> IO a -> IO (Maybe a) >timeout n t = do res <- par_io timer thr --timer > return res > where thr = do res <- t > return $! Just res > timer = do threadDelay $ n * 1000 > return Nothing It's probably because "resolve" function has type > resolve :: CNF -> (Bool, [(Int,Int)]) So it should be sequenced deeper.

1 0

Concurrency question
by Dmitry Vyal 06 Sep '05

06 Sep '05

Hi, everyone! I have a function, which sometimes takes a long time to compute or even may loop forever. So I want to limit it in time somehow. I tried to run it in another thread in order to kill it after its time lapsed. But it seems to lock out other threads so they can't terminate it. I wonder is there some clever way of dealing with such situation (running a computation in background for specific time) ? Thanks a lot.

6 7

haskell-mode in windows
by Abigail 06 Sep '05

06 Sep '05

Hello, It's not about Haskell directly but I would like to know how can I customize emacs in haskell-mode when i'm using emacs for windows. Please, I'm trying to do it but it doesn't do anything. Thanks. :D Abigail. __________________________________________________ Correo Yahoo! Espacio para todos tus mensajes, antivirus y antispam ¡gratis! Regístrate ya - http://correo.espanol.yahoo.com/

2 1

[beta] cabal-get: install haskell packages automatically
by Isaac Jones 05 Sep '05

05 Sep '05

Beta testers wanted! Lemmih (mostly) has been working on a tool which will download and install Haskell packages and their dependencies. This tool should work for any cabal-compatible package. We're looking for beta testers to try out "cabal-get" (for downloading and installing) and "cabal-put" (for uploading to the central repository). We're also looking for more developers to work on this. The home, for now is here: http://hackage.haskell.org/ModHackage/Hackage.hs?action=home and to get cabal-get, grab the bootstrapper: darcs get http://hackage.haskell.org/darcs/cabal-get-bootstrap And execute the Install.lhs file. You may have to modify it slightly if you don't like the defaults. After you install cabal-get, you should be able to install cabal-put by saying: cabal-get update && cabal-get install cabal-put Darcs repositories for all the tools are here: http://hackage.haskell.org/darcs/ Questions or problems? Email me or Lemmih. peace, isaac

2 2

A better, fair, and terminating backtracking monad [Was: Concurrency question]
by oleg＠pobox.com 05 Sep '05

05 Sep '05

Dmitry Vyal wrote: > Currently I'm playing with theorem-proving using resolution. So I need > some technique to break a computation, if takes too long. When it comes to resolution proofs, perhaps a better approach is to use a better monad that natively offers termination guarantees. For example, http://pobox.com/~oleg/ftp/Computation/monads.html#fair-bt-stream First of all, the monad can let succeed the computations that surely diverge in List and similar monads. As the code at the end of that file shows, the monad avoids depth-first traps, and can even handle left-recursion at the monadic level. Furthermore, the monad has the inherent `timing' metric: Incomplete eliminations. Each elimination is bounded in time. One can specify the upper bound on the number of eliminations and thus force the termination if no solution was found thus far. It is possible to modify the run function of the monad to return the continuation once the counter has expired. So, one can run the monad for a bit more, if desired. In contrast to iterative deepening, running the continuation does _not_ repeat any of the previous work. We have used the FBackTrack monad to implement a Datalog-like system (with top-down. resolution-based search however), and we could successfully solve the problem of finding the transitive closure in a _cyclic_ graph (the poster problem for post-Prolog systems like XSB). No tabling was needed. A scheme version of the monad was used in a leanTAP theorem prover (for the full first-order predicate logic): http://cvs.sourceforge.net/viewcvs.py/kanren/kanren/mini/leanTAP.scm http://cvs.sourceforge.net/viewcvs.py/kanren/kanren/mini/book-si.scm The original leanTAP prover was meant to be used with iterative deepening. Our implementation removes the limiting counter from the leanTAP (which throttles instantiations of a universally quantified formula); the monad has enough strength to find the solution anyway (Pelletier problems 43 and 38).

2 1

Newbie question
by André Vargas Abs da Cruz 02 Sep '05

02 Sep '05

Hi everyone, I think this is a totally newbie question as i am a complete novice to Haskell. I am trying to write down a few programs using GHC in order to get used with the language. I am having some problems with a piece of code (that is supposed to return a list of lines from a text file) which I transcribe below: module Test where import IO readDataFromFile filename = do bracket (openFile filename ReadMode) hClose (\h -> do contents <- hGetContents h return (lines contents)) The question is: if i try to run this, it returns me nothing (just an empty list). Why does this happen ? When i remove the "return" and put a "print" instead, it prints everything as i expected. Thanks in advance André

12 18

RE: [Haskell-cafe] Monadic vs "pure" style (was: pros and cons of sta tic typing and side effects)
by Bayley, Alistair 01 Sep '05

01 Sep '05

> From: Duncan Coutts [mailto:duncan.coutts@worcester.oxford.ac.uk] > > This is often a misconception, that just because you find you need to > 'do' something in the middle of your algorithm, that you need > to convert it wholly to monadic style. Yes. However, Wadler makes a convincing (at least to me) case that the monadic style is easier to extend. The code changes for the monadic style appear to be more localised. Something else I noticed about my non-monadic code was the way I was threading state through functions. I was tempted to introduce a State monad to make this easier to manage, but then I decided to try mutable arrays instead, so that experiment was not attempted. So it might well have been better in monadic style anyway, even with immutable arrays. I'm conscious that for most (?) monads, monadic code can be invoked from non-monadic code. I'm only aware of the IO monad as a one-way trap. So changing code from pure to monadic doesn't necessarily involve program-wide changes, unless the monad you're introducing happens to be IO. In my array example, I introduced STArrays, but the main interface remained pure (non-monadic), which was my goal. I was also wondering what the disadvantages of monadic style are? Are there compiler optimisations which are not possible with monadic code? 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. *****************************************************************

8 12

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

29 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

Weak hashtable memoization code?
by David Roundy 28 Aug '05

28 Aug '05

Hi all, Does anyone have a nice bit of example code to implement memoization using weak pointers and hash tables? It would be nice to have a pre-packaged module that I could just use, which has already been tested. The contents of Data.WeakPtr seem a bit lower-level than I'd rather work with. -- David Roundy http://www.darcs.net

2 1

Comtrol.Monad.when
by Juan Carlos Arevalo Baeza 27 Aug '05

27 Aug '05

Any reason why "Control.Monad.when :: Monad <Control.Monad.html#t%3AMonad> m => Bool <Data.Bool.html#t%3ABool> -> m () -> m ()" doesn't have type "Monad <Control.Monad.html#t%3AMonad> m => Bool <Data.Bool.html#t%3ABool> -> m a -> m ()" instead? Just seems a bit of a waste to have the restriction without need. I find myself needing to add the extra spurious "return ()" at the end more often than not. I made an alternate "when_" for my own use, but... JCAB

1 0

RE: [Haskell-cafe] How to use STArray?
by Bayley, Alistair 26 Aug '05

26 Aug '05

> From: Udo Stenzel [mailto:u.stenzel@web.de] > > You messed the argument order to readArray up. Yes, that won't help :-) > Even with that repaired, > you'll need a type signature somewhere to help ghc resolve the > overloading of newArray and readArray, which is surprisingly > tricky due > to the "s" that must not escape. This works: > > compute :: Int -> Int > compute n = runST ( do > arr <- newArray (-1, 1) n :: ST s (STArray s Int Int) > readArray arr 1 > ) Thanks. This is what I needed. The thing that worked best for me was to wrap newArray (and newArrayList) with functions that I could give signatures to. I was hoping to keep the program as signature-free as possible, to avoid committing heavily to particular implementations. e.g. makeArray :: Int -> Int -> a -> ST s (STArray s Int a) makeArray lower upper val = newArray (-lower, upper) val makeListArray :: Int -> Int -> [a] -> ST s (STArray s Int a) makeListArray len lst = newListArray (1, len) lst 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. *****************************************************************

3 2

RE: [Haskell-cafe] How to use STArray?
by Bayley, Alistair 26 Aug '05

26 Aug '05

> From: Ketil Malde [mailto:ketil+haskell@ii.uib.no] > > Greg Buchholz <haskell(a)sleepingsquirrel.org> writes: > > > Diff arrays have an immutable interface, but rely on > internal updates in > > place to provide fast functional update operator //. > > While a cool concept, ISTR that somebody benchmarked these some time > ago, and found the performance to be fairly poor in practice. Has > that changed lately, or am I just misremembering? DiffArray certainly improved the execution time of my program (the execution time was dominated by array updates, so no surprise there). I should have said that I'm also concerned with space usage; I'd like to allocate the arrays at the beginning and expect that to be all of the memory required, so that's another reason to be interested in mutable arrays. 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. *****************************************************************

1 0

RE: [Haskell-cafe] How lazy can "peek" be?
by Bayley, Alistair 25 Aug '05

25 Aug '05

> From: Juan Carlos Arevalo Baeza > > If I don't want to pay for that cost, then I have > to convert the code as in: > > func p = > b <- peekByteOff p 4 > case b of > B1 -> doSomething > B2 -> do { a <- peekByteOff p 0; doSomethingElse a } > B3 -> do { a <- peekByteOff p 0; doAnotherThing a } > > Repetition, repetition, repetition. This does get tedious. Would this work? > func p = do > let get_a = peekByteOff p 0 > b <- peekByteOff p 4 > case b of > B1 -> doSomething > B2 -> do a <- get_a; doSomethingElse a > B3 -> do a <- get_a; doAnotherThing a Or, with marginally less duplication: > B2 -> get_a >>= doSomethingElse > B3 -> get_a >>= doAnotherThing 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. *****************************************************************

2 1

How lazy can "peek" be?
by Juan Carlos Arevalo Baeza 25 Aug '05

25 Aug '05

Hi! One of the nice things of laziness is that it allows us to express things concisely. For instance: func a b = let ta = transmogrify a in case b of B1 -> doSomething B2 -> doSomethingElse ta B3 -> doAnotherThing ta It is clear why having this let-expression is a good thing. We can "transmogrify a" only once, and then use the "transmogrified a" only when (if) needed. In this case, one branch of the case expression doesn't need it, in which case we've effectively paid nothing for it, no matter how complex and time/resource-consuming "transmogrify" is. So far, so good. Now, I need to interoperate with external code using FFI. I have a function that gets called from outside, and gets its parameters as a pointer to a structure, so: func p = do a <- peekByteOff p 0 b <- peekByteOff p 4 case b of B1 -> doSomething B2 -> doSomethingElse a B3 -> doAnotherThing a Now I see myself with a little dilemma. This code looks a lot like the first version, where instead of "transmogrifying", we just read the value from the structure through the use of the pointer. Reading the value from memory can't be very time consuming, but it has to cost something. If I don't want to pay for that cost, then I have to convert the code as in: func p = b <- peekByteOff p 4 case b of B1 -> doSomething B2 -> do { a <- peekByteOff p 0; doSomethingElse a } B3 -> do { a <- peekByteOff p 0; doAnotherThing a } Repetition, repetition, repetition. This does get tedious. Especially when the case expression has many branches, and there are many variables in the structure that might or might not be needed. So you see my dilemma. It's _very_ tempting to do something like: func p = do let a = unsafePerformIO $ peekByteOff p 0 b <- peekByteOff p 4 case b of B1 -> doSomething B2 -> doSomethingElse a B3 -> doAnotherThing a I mean... the contents of "p" are never going to be modified, so this "feels" right on some level. But we're effectively breaking the pureness of the language. I mean... this function could be called twice with the same _pointer_ but different data stores in the structure, which can (and maybe will) cause problems depending on how evaluation proceeds. Is there a way to handle this nicely? I recently read about the Clean language. It seems like it allows (and relies) in an extension to the type system, that allows the program to specify uniqueness of values, so that two pointers values might be represented using the same bits, but they'd still be considered distinct values. But no such thing in Haskell. Maybe a good thing... trying to understand the whole explanation of uniqueness in Clean made my head spin. But still... Is it known what GHC, for instance, will do to this code when optimizing? Might it just do the right thing? Probably the C optimizer would take care of it. It feels to me that's my only hope. But it'd be great if the "haskell" part of the compiler could take care of it natively. This is something that I've been thinking about. I mean... the IO monad does seem to impose too much sometimes. Any IO action always is assumed to modify the "external world" (affect the execution of the actions that come after it), whether it does or not: do peekByteOff p 0 -- totally useless, but it needs to be performed anyway before "returning" return () do a <- peekByteOff p 0 b <- peekByteOff p 4 -- could be done before "a" Somehow, it feels like it'd be a good thing to be able to limit the scope of IO actions. Going too far would complicate it enormously: do a <- readFile "file" b <- peekByteOff p 4 -- could be done in any order, really, but how would you express it... maybe "domains of influence", like "filesystem" and "memory"... not very clear. do a <- peekByteOff p1 0 pokeByteOff p2 0 1234 -- could be done in any order, as long as p1 and p2 don't alias each other (yuck!) So I wouldn't want to go that far... yet :). A global thing might be an improvement. I'm aware it wouldn't be a monad anymore, but could it be something else? I hope this is all pointless :-). JCAB

1 0

Pattern match failure, then inconsistent function
by Adam Wyner 25 Aug '05

25 Aug '05

Hi, I am getting a "pattern match failure", and then subsequent functions which worked right work wrong. I am using Hugs and Trex. While most of the other functions work fine, the function "findCoordinatesUtil" generates an error, then misbehaves; it takes a record and searches a list of records to find other records in a specified relationship with the input function. In the first example, it works fine: LexicalSemantics03> findCoordinatesUtil (giveActionFromLabel "Action6" testLexActions03) testLexActions03 [(label="Action7", xcond=["prop1","prop7","prop5"], ycond=["prop3","pr op4","neg-prop6"]),(label="Action08", xcond=["prop1","prop7","prop5"], ycond=["prop3","neg-prop6","prop5"]),(label="Action09", xcond=["prop1 ","prop7","prop5"], ycond=["prop3","neg-prop6","neg-prop1"])] However, when I run the function on a larger list of records (here testList01), it generates an error message. LexicalSemantics03> findCoordinatesUtil (giveActionFromLabel "Action33 " testList01) testList01 Program error: pattern match failure: map_v780 (instEq_v20 instEq_v11 Eq_== "neg-prop2") map_v780 INTERNAL ERROR: Error in graph Moreover, when I subsequently run the function, I get a different (and wrong) result -- label-"Action08" is missing. LexicalSemantics03> findCoordinatesUtil (giveActionFromLabel "Action6" testLexActions03) testLexActions03 [(label="Action7", xcond=["prop1","prop7","prop5"], ycond=["prop3","pr op4","neg-prop6"]),(label="Action09", xcond=["prop1","prop7","prop5"], ycond=["prop3","neg-prop6","neg-prop1"])] When I reload the module, it correctly works again. LexicalSemantics03> :r LexicalSemantics03> findCoordinatesUtil (giveActionFromLabel "Action6" testLexActions03) testLexActions03 [(label="Action7", xcond=["prop1","prop7","prop5"], ycond=["prop3","pr op4","neg-prop6"]),(label="Action08", xcond=["prop1","prop7","prop5"], ycond=["prop3","neg-prop6","prop5"]),(label="Action09", xcond=["prop1 ","prop7","prop5"], ycond=["prop3","neg-prop6","neg-prop1"])] I don't understand the pattern match failure or how to correct it. What is this error message telling me? Thanks, Adam Wyner

3 2

Overlapping instances
by Frank 24 Aug '05

24 Aug '05

I would like to state that a class Sup is exhaustively broken down in two subclasses Sub1 and Sub2 (meaning, for every instance of Sub1 and every instance of Sub2, the methods in Sup apply). I try to code this as: instance Sub1 x => Sup x instance Sub2 x => Sup x And get the (expected) error message ExhaustiveClass.hs:22:0: Duplicate instance declarations: ExhaustiveClass.hs:22:0: instance (Sub1 x) => Sup x ExhaustiveClass.hs:25:0: instance (Sub2 x) => Sup x (I have allowed overlapping instances, undecidable instances) Is there another way of achieving this? Any help appreciated! Andrew ----------------- complete code I tried with: class Sub1 a where op1 :: a -> a class Sub2 a where op2 :: a -> a -> a class Sup a where op3 :: a -> Bool instance Sub1 Int where op1 = id instance Sub2 Float where op2 x y = y instance Sub1 x => Sup x where op3 _ = True instance Sub2 x => Sup x where op3 _ = False But get Andrew U. Frank Professor, Head of Department Geoinformation and Cartography E127 phone: +43 1 588 01 12710 TU Vienna secr. +43 1 588 01 12700 Gusshausstrasse 27-29 fax +43 1 588 01 12799 A-1040 Vienna Austria cellular phone +43 676 41925 72 http://www.geoinfo.tuwien.ac.at/persons/frank/frank.html skype:AndrewUFrank

2 1

RE: [Haskell-cafe] Re: Oracle + Haskell advice?
by Bayley, Alistair 23 Aug '05

23 Aug '05

> From: Brian Strand [mailto:bstrand@switchmanagement.com] > > > > > Reviewing at the bind variable code has highlighted a > glaring design flaw: > > you can only pass homogenous lists of bind values! > > I was wondering about that; I thought maybe you just passed > everything to OCI > as String and let Oracle sort it out, but that doesn't seem > very Haskell-ish. I've fixed this now, so it should be quite a bit more usable. The code's in the experimental branch, but it's all quite safe, except for the MS Sql Server stuff, which is work-in-progress. I've updated the Haddock docs, which should explain how to use everything. Please tell me of anything that's unclear, or omitted. Again, I'm happy to help with any problems or questions. 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. *****************************************************************

2 1

Category theory monad <----> Haskell monad
by Carl Marks 23 Aug '05

23 Aug '05

Is there any text/article which makes precise/rigorous/explicit the connection between the category theoretic definition of monad with the haskell implementation?

5 5

RE: [Haskell-cafe] Functional dependencies and type inference
by Simon Peyton-Jones 23 Aug '05

23 Aug '05

Thomas Strange and interesting example! If I had a pound for every time functional dependencies had messed up my brain, I'd be a rich man. Apart from anything else, your example is another case of the "critical example" http://www.haskell.org/pipermail/haskell-cafe/2005-August/010974.html as you mention. It's also jolly strange that GHC infers the (un-writable) type bar :: (forall r. (Dep Int r) => Int -> r) -> Bar -> Char but you can write neither that type nor bar :: (Int -> Bool) -> Bar -> Char so in fact GHC won't type the bogus type-cast. Nevertheless, those are artefacts of GHC's not-yet-right implementation of fundeps. I think the real problem here is that the "newtype-deriving" mechanism isn't conservative enough. Given class C a where { op :: ty } newtype T = MkT S the idea is that if S is an instance of a class C, then T can be, witnessed by the same functions. That amounts to saying that ty[S/a] is interchangeable with ty[T/a] and that isn't really true when fundeps get in on the act. I can't say I really understand it fully, but that's as far as I can take it today. Question: what restrictions on the newtype-deriving mechanism would make it sound? Simon | -----Original Message----- | From: Thomas Jäger [mailto:thjaeger@gmail.com] | Sent: 23 August 2005 02:02 | To: Simon Peyton-Jones | Cc: Einar Karttunen; haskell-cafe(a)haskell.org | Subject: Re: [Haskell-cafe] Functional dependencies and type inference | | Simon, | | I believe there may be some nasty interactions with generalized | newtype-deriving, since we can construct two Leibniz-equal types which | are mapped to different types using fundeps: | | class Foo a where | foo :: forall f. f Int -> f a | | instance Foo Int where | foo = id | | newtype Bar = Bar Int deriving Foo | | -- 'Equality' of Int and Bar | eq :: forall f. f Int -> f Bar | eq = foo | | class Dep a b | a -> b | | instance Dep Int Bool | instance Dep Bar Char | | newtype Baz a = Baz { runBaz :: forall r. Dep a r => a -> r } | | conv :: (forall f. f a -> f b) -> | (forall r. Dep a r => a -> r) -> (forall r. Dep b r => b -> r) | conv f g = runBaz $ f (Baz g) | | bar = conv eq | | Here, after type erasure, 'bar' is the identity function . Ghc infers | | bar :: (forall r. (Dep Int r) => Int -> r) -> Bar -> Char | | This is not valid as an explicit type signature, but presumably the | proposal implies that we could type bar as | | bar :: (Int -> Bool) -> Bar -> Char | | instead. Now | | \x -> bar' (const x) (Bar 0) :: Bool -> Char | | would become an unsafe coercion function from Bool to Char. | | | Thomas | | On 8/11/05, Simon Peyton-Jones <simonpj(a)microsoft.com> wrote: | > Einar | > | > Good question. This is a more subtle form of the same problem as I | > described in my last message. In fact, it's what Martin Sulzmann calls | > "the critical example". Here is a boiled down version, much simpler to | > understand. | > | > module Proxy where | > | > class Dep a b | a -> b | > instance Dep Char Bool | > | > foo :: forall a. a -> (forall b. Dep a b => a -> b) -> Int | > foo x f = error "urk" | > | > bar :: (Char -> Bool) -> Int | > bar g = foo 'c' g | > | > | > You would think this should be legal, since bar is just an instantation | > of foo, with a=Char and b=Bool. But GHC rejects it. Why?

1 0

RE: [Haskell-cafe] Functional dependencies and type inference
by Simon Peyton-Jones 23 Aug '05

23 Aug '05

Einar Good question. This is a more subtle form of the same problem as I described in my last message. In fact, it's what Martin Sulzmann calls "the critical example". Here is a boiled down version, much simpler to understand. module Proxy where class Dep a b | a -> b instance Dep Char Bool foo :: forall a. a -> (forall b. Dep a b => a -> b) -> Int foo x f = error "urk" bar :: (Char -> Bool) -> Int bar g = foo 'c' g You would think this should be legal, since bar is just an instantation of foo, with a=Char and b=Bool. But GHC rejects it. Why? GHC looks at the call to foo (in bar's RHS), and instantiates it with a=Char. That tells it that the second argument should have type (forall b. Dep Char b => Char -> b) But it doesn't! It has type (Char -> Bool). And to GHC these are not the same types. You may say that they *should* be the same types. The crispest way I know to explain why it arguably should be rejected is to try translating the program into System F (which is what GHC actually does). Then the RHS of bar looks like bar (g::Char->Bool) = foo {Char} 'c' (...???...) The {Char} is the type argument to foo. But what can we pass for (...???...)?. We must pass a polymorphic function, with type forall b. Dep Char b -> Char -> b But all we have is g::Char->Bool. And System F has no way to connect the two. Well, that's the problem anyway. I can think of three "solutions": - Reject such programs (GHC's current solution) - Abandon compilation via System F - Extend System F I'm working on the third of these, with Martin, Manuel, and Stephanie. Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | Einar Karttunen | Sent: 15 July 2005 13:48 | To: haskell-cafe(a)haskell.org | Subject: [Haskell-cafe] Functional dependencies and type inference | | Hello | | I am having problems with GHC infering functional dependencies related | types in a too conservative fashion. | | > class Imp2 a b | a -> b | > instance Imp2 (Foo a) (Wrap a) | > | > | > newtype Wrap a = Wrap { unWrap :: a } | > data Foo a = Foo | > data Proxy (cxt :: * -> *) | > | > foo :: Imp2 (ctx c) d => Proxy ctx -> (forall a b. (Imp2 (ctx a) b) => a -> b) -> c -> d | > foo p f x = f x | | The type of "foo (undefined :: Proxy Foo)" is inferred as | "forall c. (forall a b. (Imp2 (Foo a) b) => a -> b) -> c -> Wrap c" | which shows the outmost functional dependence is working fine. ctx | is carried to the inner Imp2. | | However "foo (undefined :: Proxy Foo) Wrap" will fail complaining that | | Couldn't match the rigid variable `b' against `Wrap a' | `b' is bound by the polymorphic type `forall a b. (Imp2 (ctx a) b) => a -> b' | at <interactive>:1:0-32 | Expected type: a -> b | Inferred type: a -> Wrap a | In the second argument of `foo', namely `Wrap' | | My guess is that GHC cannot see that the functional dependency | guarantees that there are no instances which make the inferred | type invalid. Any solutions to this problem? | | | - Einar Karttunen

4 3