- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Composing functions with runST
by Yitzchak Gale 02 Jan '07

02 Jan '07

Hi Thomas, You wrote: > How do I "import" Control.Monad.ST so I can experiment with it from > ghci and just do > runST > like you had. Instead of qualifying it in some way. In GHCi, use the :module command (:m) for built-in modules, and :load and :add for source files. In Hugs, use :load and :also for both. You need to run Hugs with the -98 flag to use Control.Monad.ST. > how do I do runST as fully qualified? Like this: Prelude> Control.Monad.ST.runST (do {r <- Data.STRef.newSTRef 2007; Data.STRef.readSTRef r}) 2007 Have fun with monads! Regards, Yitz

1 0

porting ghc
by Brian McQueen 01 Jan '07

01 Jan '07

I was trying to get a ghc going in my shell account the other day and found that the data at http://haskell.org/ghc/docs/6.6/html/building/sec-porting-ghc.html didn't apply at all. The system is a netbsd alpha which turns up as alpha-unknown-netbsd through configure. I didn't find any configure.in to modify, but there is a config.guess. Is that what I'm supposed to modify? I was using the source distribution of ghc 6.6. So how do I get off to s start on the netbsd system at my ISP? Here is the uname data for my system with the hostname x'd out: NetBSD xxx 2.1.0_STABLE NetBSD 2.1.0_STABLE (sdf) #0: Mon Nov 13 08:11:09 UTC 2006 root@ol:/var/src/netbsd/src/sys/arch/alpha/compile/sdf alpha Brian McQueen

2 2

Strange type behavior in GHCi 6.4.2
by Grady Lemoine 01 Jan '07

01 Jan '07

Hello, I've been playing around with Dan Piponi's work on automatic differentiation (from http://sigfpe.blogspot.com/2005/07/automatic-differentiation.html and http://sigfpe.blogspot.com/2006/09/practical-synthetic-differential.html) and I'm getting some odd behavior with the inferred types of functions in GHCi 6.4.2. My test case is as follows: > data Dual a = D a a deriving (Show,Eq) > instance Num a => Num (Dual a) where > fromInteger i = D (fromInteger i) 0 > (D a a')+(D b b') = D (a+b) (a'+b') > (D a a')-(D b b') = D (a-b) (a'-b') > (D a a')*(D b b') = D (a*b) (a*b'+a'*b) > evalDeriv f x = (v, v') > where D v v' = f (D x 1) > f x = x^3 > f' = snd . (evalDeriv f) When I load this in GHCi, I get: *Main> :t f f :: (Num a) => a -> a *Main> :t snd . (evalDeriv f) snd . (evalDeriv f) :: (Num a, Num (Dual a)) => a -> a *Main> :t f' f' :: Integer -> Integer Why is the type of f' Integer -> Integer, especially when the type of the expression it's defined as is more general? Is this something I'm not understanding about Haskell, or is it more to do with GHC 6.4.2 specifically? Any help appreciated, --Grady Lemoine

9 26

Second Call for Papers: TFP 2007, New York, USA
by TFP 2007 31 Dec '06

31 Dec '06

CALL FOR PAPERS Trends in Functional Programming 2007 New York, USA April 2-4, 2007 http://cs.shu.edu/tfp2007/ The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming languages, focusing on providing a broad view of current and future trends in Functional Programming. It aspires to be a lively environment for presenting the latest research results through acceptance by extended abstracts. A formal post-symposium refereeing process then selects the best articles presented at the symposium for publication in a high-profile volume. TFP 2007 is co-hosted by Seton Hall University and The City College of New York (CCNY) and will be held in New York, USA, April 2-4, 2007 at the CCNY campus. SCOPE OF THE SYMPOSIUM The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles leading-edge, previously unpublished research work Position Articles on what new trends should or should not be Project Articles descriptions of recently started new projects Evaluation Articles what lessons can be drawn from a finished project Overview Articles summarizing work with respect to a trendy subject Articles must be original and not submitted for simultaneous publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or more experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Articles on the following subject areas are particularly welcomed: o Dependently Typed Functional Programming o Validation and Verification of Functional Programs o Debugging for Functional Languages o Functional Programming and Security o Functional Programming and Mobility o Functional Programming to Animate/Prototype/Implement Systems from Formal or Semi-Formal Specifications o Functional Languages for Telecommunications Applications o Functional Languages for Embedded Systems o Functional Programming Applied to Global Computing o Functional GRIDs o Functional Programming Ideas in Imperative or Object-Oriented Settings (and the converse) o Interoperability with Imperative Programming Languages o Novel Memory Management Techniques o Parallel/Concurrent Functional Languages o Program Transformation Techniques o Empirical Performance Studies o Abstract/Virtual Machines and Compilers for Functional Languages o New Implementation Strategies o any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2007 program chair, Marco T. Morazan, at tfp2007(a)shu.edu. SUBMISSION AND DRAFT PROCEEDINGS Acceptance of articles for presentation at the symposium is based on the review of extended abstracts (6 to 10 pages in length) by the program committee. Accepted abstracts are to be completed to full papers before the symposium for publication in the draft proceedings and on-line. Further details can be found at the TFP 2007 website. POST-SYMPOSIUM REFEREEING AND PUBLICATION In addition to the draft symposium proceedings, we intend to continue the TFP tradition of publishing a high-quality subset of contributions in the Intellect series on Trends in Functional Programming. IMPORTANT DATES Abstract Submission: February 1, 2007 Notification of Acceptance: February 20, 2007 Registration Deadline: March 2, 2007 Camera Ready Full Paper Due: March 9, 2007 TFP Symposium: April 2-4, 2007 PROGRAMME COMMITTEE John Clements California Polytechnic State University, USA Marko van Eekelen Radboud Universiteit Nijmegen, The Netherlands Benjamin Goldberg New York University, USA Kevin Hammond University of St. Andrews, UK Patricia Johann Rutgers University, USA Hans-Wolfgang Loidl Ludwig-Maximilians Universität München, Germany Rita Loogen Philipps-Universität Marburg, Germany Greg Michaelson Heriot-Watt University, UK Marco T. Morazán (Chair) Seton Hall University, USA Henrik Nilsson University of Nottingham, UK Chris Okasaki United States Military Academy at West Point, USA Rex Page University of Oklahoma, USA Ricardo Pena Universidad Complutense de Madrid, Spain Benjamin C. Pierce University of Pennsylvania, USA John Reppy University of Chicago, USA Ulrik P. Schultz University of Southern Denmark, Denmark Clara Segura Universidad Complutense de Madrid, Spain Jocelyn Sérot Université Blaise Pascal, France Zhong Shao Yale University, USA Olin Shivers Georgia Institute of Technology, USA Phil Trinder Heriot-Watt University, UK David Walker Princeton University, USA ORGANIZATION Symposium Chair: Henrik Nilsson, University of Nottingham, UK Programme Chair: Marco T. Morazan, Seton Hall University, USA Treasurer: Greg Michaelson, Heriot-Watt University, UK Local Arrangements: Marco T. Morazan, Seton Hall University, USA ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0

Re: [Haskell-cafe] Literate Haskell source files. How do I turn them into something I can read?
by Kirsten Chevalier 31 Dec '06

31 Dec '06

[redirecting to the mailing list] On 12/31/06, Michael T. Richter <ttmrichter(a)gmail.com> wrote: > On Sat, 2006-30-12 at 23:48 -0800, Kirsten Chevalier wrote: > > I'm probably not the right person to explain why David Roundy chose to > > write his code the way he did, since I've never even met him. However, > > since as of 12/8/2006 there were 115 contributors to darcs, perhaps > > reading the source code isn't as difficult as you seem to think it is. > > What's the secret then? pdflatex vomits. unlit generates a few dozen > pages of whitespace per five-line block of code. I'm at a loss to take > this "literate" format and turn it into something which I can read. > The secret lies in adjusting your perspective. The literate format is readable by humans as is. If there are specific things about it that you find difficult, you can post about them here with *specific* examples you find perplexing. But one reason why you may feel like people aren't being helpful is that your question isn't specific enough. > > > I fail to see how making code which can't be read makes it more... > > > readable. > > > "Can't" is an awfully strong word, isn't it? > > Nope. The source files as they are are gibberish. Again, that's an awfully strong statement. Clearly, there exist any number of people who can read them without finding them gibberish. Perhaps it might be better to listen to what they are telling you than to make contradictory declarations. > There's some kind of > markup (of a type I can't identify) mixed up with Haskell source. Given > that I can't identify the markup and I'm a little hazy on Haskell at > this point (part of the point of this exercise was to learn to read > Haskell as it's used in real projects), the net effect is executable > line noise. You know, like a perl program written circa 3.0. > Right, if you're trying to learn to read Haskell as it's used in real projects, reading the .lhs files as they are is the way to go. Again, if you find specific things hard to comprehend, ask here, or on the IRC channel. A general "all Haskell looks like line noise!" complaint is hard for us to answer. > > I can only explain how I did it myself, which was through practice. > > OK. How do you read the literate source code? Which tools do you use > to separate the code from the commentary? Which tools actually work to > turn .lhs files into something human-readable? (pdflatex failed on the > GHC code as well.) > My eyes. And brain. I'm sorry that I can't be more helpful, but that's what most other people I've watched reading Haskell code use, too. Cheers, Kirsten -- Kirsten Chevalier* chevalier(a)alum.wellesley.edu *Often in error, never in doubt "Memo to myself: Do the dumb things I gotta do. Touch the puppet head." -- They Might Be Giants

1 0

Mo' comprehensions
by Diego Navarro 31 Dec '06

31 Dec '06

I was solving some programming puzzles today[1], and found myself pining for Map comprehensions. Maybe there should be a Comprehensible class that's automatically mapped to comprehension syntax. It's rather odd to have them only for lists. That would be both more general and more elegant than just bringing back monad comprehensions. Is there any obvious reason why this wouldn't work? [1] www.projecteuler.net <-- fun stuff! -- -- Diego Navarro

4 3

HaXML - creating a simple document
by Terrence Brannon 31 Dec '06

31 Dec '06

Hello, I don't know why my simple example will not render a simple HTML document. For the moment, I simply want to render this: <html> </html> or whatever, the simplest document is. When I run my source code, it simply hangs (as the transcript below shows) {- SOURCE CODE -} import Text.XML.HaXml.Html.Generate import Text.XML.HaXml.Combinators import Text.XML.HaXml.Wrappers main = processXmlWith go go = html [] {- EXECUTION TRANSCRIPT  ghci mk.hs ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. [1 of 1] Compiling Main ( mk.hs, interpreted ) Ok, modules loaded: Main. *Main> main Loading package haskell98 ... linking ... done. Loading package HaXml-1.17 ... linking ... done. -}

3 3

Re: [Haskell-cafe] Literate Haskell source files. How do I
by Eric Kow 30 Dec '06

30 Dec '06

Hi, > On 30/12/06, Michael T. Richter <ttmrichter(a)gmail.com> wrote: > > Are there any tools which I can use to render .lhs files readable? I'm fine with having them converted into documented source (i.e. source code embedded in documentation) or as pure Haskell source (but without the huge whitespace gaps) -- but I can't figure out how to get either. The darcs code is a bit different in that the LaTeX "comments" are actually the user's manual (for the most part). The code is normally hidden when you compile the pdf. To see the code, you can apply the attached darcs patch. (You could also do it by hand; it's just a couple of changes). When you run make manual/darcs.ps, you will have a ps file that is simultaneously the darcs manual, and various bits of darcs code interspersed and highlighted in blue. (This is > 300 pages of literate darcs, mind you. Maybe just browsing it in a text editor is simpler) -- Eric Kow http://www.loria.fr/~kow PGP Key ID: 08AC04F9 Merci de corriger mon français.

1 0

Seeking advice on a style question
by Steve Schafer 30 Dec '06

30 Dec '06

In my text/graphics formatting work, I find myself doing a lot of "pipeline" processing, where a data structure will undergo a number of step-by-step transformations from input to output. For example, I have a function that looks like this (the names have been changed to protect the innocent--and to focus on the structure): process :: a -> b -> c -> d -> e process x1 x2 x3 x4 = let y01 = f01 x1 x2 x3; y02 = f02 x1; y03 = f03 y02; y04 = f04 y03; y05 = f05 x1 y01 y04; y06 = f06 x2 y05; (y07,y08) = f07 y01 y06; y09 = f08 y07; (y10,y11) = f09 x2 x4 y09 y08; y12 = f10 y10; y13 = f11 y12; y14 = f12 x1 x2 x3 y01 y13; y15 = f13 y14; y16 = f14 y15 y11 in y16 As you can see, the process is somewhat imperative in overall appearance, with each intermediate function f01..f14 accepting some combination of the original input values and/or intermediate values and returning a new value (or, in some cases, a tuple of values). Obviously, not all of the steps need to be broken out this way. We can, for example, skip the second and third steps and directly write: y04 = f04 $ f03 $ f02 x1; Laying it out this way has a couple of advantages. It makes the steps in the process transparently clear, and if I discover at some point that I need to make a change (e.g., a new requirement causes f13 to need access to x2), it's perfectly obvious where to make the modifications. Nevertheless, it also looks like something that would be amenable to processing with a State monad, except for one thing: The "shape" of the state isn't constant throughout the process. At any given step, new information may be added to the state, and old information may be thrown away, if there is no further need for it. In principle, it could be managed with a bunch of nested StateT monads, but my attempts to do so seem to get so caught up in the bookkeeping that I lose the advantages mentioned above. Alternatively, I can wrap all of the state up into a single universal structure that holds everything I will ever need at every step, but doing so seems to me to fly in the face of strong typing; at the early stages of processing, the structure will have "holes" in it that don't contain useful values and shouldn't be accessed. So here's the question: Is there a reasonable way to express this kind of process (where I suppose that "reasonable" means "in keeping with Haskell-nature") that preserves the advantages mentioned above, but avoids having to explicitly pass all of the various bits of state around? The (unattainable?) ideal would be something that looks like this: process = f14 . f13 . ... . f01 or process = f01 >>= f02 >>= ... >>= f14 Steve Schafer Fenestra Technologies Corp. http://www.fenestra.com/

10 21

Idiomatic Haskell equivalent of "keyword arguments" to functions
by Paul Moore 30 Dec '06

30 Dec '06

I'm thinking around the design of a couple of things, and am hitting an issue which I know how I would solve in Python, but I'm not sure what a good idiomatic Haskell approach would be. The problem is that I am trying to write a function which takes a rather large number of arguments, many of which are optional (ie, have sensible defaults). The canonical example of this is creating a GUI window, which involves a lot of style options, most of which would typically be left to default. In Python, this type of interface is often handled either as a function with many keyword arguments, or as a mutable object which has attributes set, and then a method called to handle the function call. Neither of these approaches seems plausible in Haskell. I looked at wxHaskell for inspiration - its approach (button f [text := "Quit", on command := close f]) looks quite readable, but slightly unusual (to me) for Haskell. It also seems fairly complex to implement (ie, my head hurt when I tried to follow the types involved, but maybe that's just because it's getting late :-)) To make things concrete, the example I'm really thinking of is a "send an email" function, which would take a subject, a body, a list of recipients, optional lists of cc and bcc recipients, an optional mailserver (default localhost), an optional port (default 25), and possibly optional authentication details. I found a couple of Haskell modules implementing a SMTP client, but they both just used a list of positional parameters, which I'm not really happy with. At the very least, I'd like to wrap them in a nicer interface for my code. I'd appreciate any ideas about how to think of this sort of problem - I'm pretty sure that what I need to do is think differently about the issue, rather than just mechanically translating the code I'd write in Python. But I don't really know how. Any pointers would be very helpful! Thanks, Paul.

5 6