- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] library sort
by John Hughes 08 Mar '06

08 Mar '06

>Am Samstag, 4. März 2006 21:30 schrieb Neil Mitchell: > > >>>And a related question is: Which packages are searchable by Hoogle? >>> >>> >>The best answer to that is "some". I intentionally excluded OpenGL and >>other graphics ones because they have a large interface and yet are >>not used by most people using Haskell. [...] >> >> > >Well, this a bold assumption IMHO, and I'm not particularly happy with that, >as you can probably imagine. For my part, I would assume that Joe Programmer >is much more likely to use some multimedia packages than TH or Data.Graph.* >etc., but this is a bold assumption on *my* side... > >... > >>Well, this a bold assumption IMHO, and I'm not particularly >>happy with that, as you can probably imagine. >> >> > >I would also imagine that Joe Programmer is more likely to use >wxHaskell or Gtk2Hs than those - however because those are outside the >standard tree they don't make it in. I don't think much of TH made it >in either (not becuase of deliberate exclusions, but because of >technical limitations in the tool). > > > When I surveyed Haskell users, I asked respondents to name the most important tools and libraries they use. (Caveat: respondents saw the list of tools and libraries already named, and could include these just by selecting them, so tools mentioned early in the survey were more likely to be named by subsequent respondents). Here are a few relevant entries, where the percentage is the proportion of respondents who named the tool: 29% Parsec 19% wxHaskell 16% QuickCheck 16% haddock 12% Monadic Parser Combinators 11% Gtk2Hs 9% hs-plugins 8% HaXml 7% Data.* 7% Monad foundation classes 6% Arrows 6% HOpenGL The list includes all libraries named by more than 5% of respondents. Sure enough, wxHaskell and Gtk2Hs are more popular, but 6% naming HOpenGL as among the "most important" libraries is quite respectable. John

3 2

Web application frameworks (was: [Haskell] Re: Trying On Learn Haskell Web Server)
by Graham Klyne 08 Mar '06

08 Mar '06

[Switching to haskell-cafe] Niklas Broberg wrote: > Ehum, shameless plug. :) > Pretty much what I was fishing for... > On 3/6/06, Graham Klyne <GK(a)ninebynine.org> wrote: >> Cale Gibbard wrote: >>> Ah, neat, I knew about WASH, but somehow I'd missed the fact that >>> there was a server there :) >> Interesting... at a casual glance, this looks as if it could be coming close to >> being a "full stack web application framework" for Haskell, looking to occupy >> the same kind of territory as systems like Java/Servlets+JSP+the rest, >> Ruby/Rails or Python/Turbogears (the last a package I'm currently using). > > Have you looked at HSP [1]? This is exactly what the HSP project aims > for, although there is quite some ways to go yet. I've noticed it, but haven't yet taken a closer look. Currently, I'm pretty busy with non-Haskell activities, but I'd love to find a sufficiently mature tool to migrate some of my work to Haskell. >> I think see: >> The web server >> CGI process dispatching >> Web page templating >> Relational database access > > All of these are present in HSP. I noticed that WASH makes some mention of HSP. My main concern with a *SP approach, and a reason I haven't delved more deeply, is that they are, AFAICT, heavily dependent on code embedded in HTML, when I really want to separate the code and markup as much as possible. >> Additional features of a full-stack web application framework that may or may >> not be present are: >> >> - Support for longer-running web processes (implemented in haskell, of course) > > HSP has that. Ah, OK... I wasn't aware of that. >> - An easy way to map incoming URIs to specific functions (hmm.. or to monadic >> values, I think) > > I don't think I understand what you're after exactly, but I'm sure > it's interesting, care to explain a bit further? :-) I'll try and explain using Turbogears as example. Actually, I think that Turbogears would make a good model for building a Haskell Web application framework, since many of the key integration points are implemented using higher order functions. It makes heavy use of Python 2.4 "decorators", which are a (constrained) form of functional composition for class member functions. The web server/controller component of Turbogears is CherryPy. Roughly, a class maps to a web server "directory" in URI space, with a declared class (conventionally "root") corresponding to path / for a server. Member variables use used to create subdirectories. here's an example from soemthign I'm working on: [[ class Root(controllers.Root): panel = PanelRenderer() ### Note 1 webbrick = WebBrickAccess() itunes = ITunesAccess() @turbogears.expose(html="templates.welcome") ### Note 2 def index(self): return dict(now=time.ctime()) @turbogears.expose(html="templates.listpanels") ### Note 2 def panels(self): def selectPanelName((_,nam)): return nam[:-4] pattern = re.compile( r'^.+\.xml$' ) c = CollectFiles("../resources/paneldef/",pattern,recursive=False) return { 'baseuri' : turbogears.url("/")+"panel/", ### Note 3 'panels' : map(selectPanelName,c) } ]] Notes: 1. These assignments create sub-pages of the root page for http://.../panel/, http://.../webbrick/, http://.../itunes/. 2. This is the Python decorator syntax, that defines a class method as a composition of the decorator function (turbogears.expose) and the function definition that follows. The turbogears.expose decorator performs two functions here: (a) it causes the function to be exposed as a web page; e.g. http://.../index or http://.../panels, (b) it uses the output from the defined function as input to a templating system to format and return an HTML web page. 3. The templating system uses a Python "dictionary" type to accept values that are included in the constructed web page. You will note that this code is completely independent of the details of the templating syst actually used. Indeed, Turbogears can be used with more than one templating system, and (in principle), I think the decorator system would allow miore than one such system to be used within a single application - not that I advocate this ;). I think all of this could be converted quite easily to appropriate Haskell idioms. >> - Easy mapping from Haskell data structures to underlying SQL - what would be >> called an Object-Relational Mapper (ORM) in OO languages > > Some of our students are working on bringing the power of Ruby/Rails > to HSP, with emphasis on smooth database interfacing. Not sure exactly > what this entails though, I've never used Rails... :-) IMO, Rails suffers in this respect by being too-tightly integrated with its ORM system. It's fine if you want, as Bruce Tate says, to "babysit a relational database". By in my application, I actually want to "babysit" a collection of web-connected devices. Turbogears, by contrast, leaves the controller/model interface completely in the open: there is no presumtpion that the supplied ORM code will be used. This means I can simply call my own (web client library) code instead of the ORM code, and everything just works. With rails, on brief examination, I felt that IK wpould need to unpick the ORM interface and then implement my own "model" code behind that interface -- just the kind of complexification and dependency I'm trying to get away from. >> - Handling of interaction with a browser-side Javascript library for smoother >> AJAX support > > This is not currently present in HSP, but they are surely on the > conceptual todo-list. There is a design for a crude JavaScript > support, but we'd certainly need more. In turbogears, this mostly amounts to validation of form results coming back from Ajax-enabled forms, as far as I can tell. It's not a feature I've used yet. BTW, the Mochikit Ajax library (component of Turbogears) is an interesting example of functional idioms used in Javascript. >> - Options to run the whole thing behind Apache to leverage its security and web >> space management capabilities > > Lemmih has implemented a HSP/FastCGI binding for Apache. I also know > that work is being done on building a direct HSP/Apache binding. All > work in progress though. Yes, I was aware of a fastCGI for Haskell. Didn't Bjorn Bringert (also) implement one? I tend to think of CGI programs as run-to-completion-then-exit, even when a fastCGI interface allows a persistent wrapper program to speed startup. But I could easily be missing something here. >> I think that continuation-based web session state management, ala >> Smalltalk/Seaside, would be a very natural fit for a Haskell framework -- all >> handled by a "Web session monad", maybe. (Or maybe I just don't know what I'm >> talking about ;) > > This is by far the biggest drawback of HSP today. There is no > high-level support for continuations (other than explicitly defined > continuations at top level). This is something that I assume would not necessarily be (too) tightly integrated into the rest of the framework. This is only a very vague sketch, and I might be talking rubbish as I haven't studied this are in any depth, but I imagine using something a monad to maintain the state of a web session, with each incoming request corresponding to a bind operation, updating the session state and returning a value to the client. I'm not sure how closely this follows technically the idea of using continuations, but I think the end result is similar: cleaner and well-isolated management of session state and web transaction progress. >> How far are we from having such a framework for Haskell? > > Depends on how many people would be willing to invest time in it. > Right now we have students at Chalmers working on a project that aims > towards such a framework, but they can only do so much in the time > they have. We would surely welcome any help we could get. :-) Well, it's the sort of project I'd love to work on, but right now I also lack time. I've felt for a long time that Haskell would be a great language for building Web applications, and my work with Turbogears is showing me how it might actually all come together. Part of the problem is finding someone who is prepared to sponsor such work, as I've already taken a year or so working on my own projects, and not ready to take the financial hit again. > (ps. Going on vacation for 2 weeks in a few hours, so I'm not likely > to respond for a while... ;-)) Have fun! #g -- PS: I just spotted this in HWN: [[ * Haskell as a markup language. Oleg Kiselyov [4]writes on using Haskell to represent semi-structured documents and the rules of their processing. [5]SXML is embedded directly in Haskell, with an open and extensible set of `tags'. The benefit of this is of course in static type guarantees, such as prohibiting an H1 element to appear in the character content of other elements. 4. http://www.haskell.org/pipermail/haskell/2006-March/017656.html 5. http://ssax.sourceforge.net ]] I think this really should be in the toolkit, possibly at the heart of the templating system. I think this kind of capability is exactly why Haskell could be so good as a web application language. -- Graham Klyne For email: http://www.ninebynine.org/#Contact

2 2

Annoucing alternative to Text.Regex
by Chris Kuklewicz 08 Mar '06

08 Mar '06

This message is cross-posted to haskell-cafe(a)haskell.org and libraries(a)haskell.org Hi, Working on the shootout (specifically http://shootout.alioth.debian.org/gp4/benchmark.php?test=regexdna&lang=all ), it was impossible to use Text.Regex since it was too slow (it would reach the timeout limit, such as an hour, where TCL takes 3.21 seconds ). So we had to work around this by implementing our own regex engine. I have tooled up an all-parsec version that I think can be a nearly drop-in-alternative to Text.Regex. I will describe it a bit and then ask for advice. It takes the string form of the regular expression and uses Parsec to create a (data Pattern) tree structure. This recognizes all of "man re_format" including back references, missing only the [[:>]] or [[<:]] extension (word boundaries). It also accepts new modifiers '?' and '+' to be used like "a*?" and "a*+" for lazy and possessive matching. The Pattern form is amenable to simplification, and some easy simplification are performed. Then the Pattern is transformed in a Parsec parser that will match the input (from the beginning only) and return all the captured sub-expressions. It also supports (get|set|update)UserState functions. It should return the longest match when all the pattern elements are greedy, i.e. no lazy or possessive modifiers are used. With lazy or possessive modifiers the longest alternative is used, but this may not be the longest overall match. (Parsec keeps track of line and column position, but not the number of characters, which had to be added.) Note that the pattern "(.)Q\1" can be used to match strings like "aQa", and "(a|b\1)+" matches all of "ababba". The Text.Regex compatibility code embeds the generated Parsec parser into more complicated parsers and runs them to emulate the different functions in the Text.Regex interface. It is possible to extend all of this in several ways: 1) Turn the Pattern into simpler parsec, e.g. if the expression captures are not needed 2) When possible, turn the Pattern into a faster DFA parser instead of Parsec 3) Create parsers that with different semantics than "longest match", e.g. left-biased 4) Creates parsers that return all matches 5) Employ smart optimizations for special forms of Pattern 6) With an earlier version, I made a proof of principle String -> ExpQ transformer that created Parsec at compile time using Template Haskell. This could be updated. Not done: testing. (If you have clever things to throw at it, pass them along). Not done: benchmarking (though it should usually beat Text.Regex). And now I want to ask for advice. If there is interest I could post the code somewhere, but I don't own a stable place to put it at the moment. Is there a canonical place on the net to put small Haskell modules (28 kB uncompressed) ? Is there some darcs-repository I could insert it into ? Also, is there a library style guide somewhere with best practices?

2 2

RE: [Haskell] Re: Trying On Learn Haskell Web Server
by Bayley, Alistair 08 Mar '06

08 Mar '06

[Moving to café] > From: haskell-bounces(a)haskell.org > [mailto:haskell-bounces@haskell.org] On Behalf Of Mattias Bengtsson > > > > > I think that continuation-based web session state management, ala > > > Smalltalk/Seaside, would be a very natural fit for a > Haskell framework -- all > > > handled by a "Web session monad", maybe. (Or maybe I > just don't know what I'm > > > talking about ;) > > > > This is by far the biggest drawback of HSP today. There is no > > high-level support for continuations (other than explicitly defined > > continuations at top level). > > I would really like to know exactly what this means. Are there any > examples or papers on this? I have a lot of links... which I'll feel free to spam you and the list with :-) Here a list of continuation-based web-frameworks that I know about; there may be more: Cocoon (Java + Javascript) http://cocoon.apache.org/ Borges (Ruby) http://borges.rubyforge.org/ Wee (Ruby) http://www.ntecs.de/blog/Wee WASH (Haskell) http://www.informatik.uni-freiburg.de/~thiemann/haskell/WASH/ Seaside (Smalltalk) http://www.seaside.st/ PLT Scheme (Scheme) http://www.plt-scheme.org/ (can't find the actual library) Siscweb (Scheme) http://siscweb.sourceforge.net/ Uncommon Web (Common Lisp) http://common-lisp.net/project/ucw/ Rife (Java) http://rifers.org One of the first people (but not the only, I think) to recognise that continuations were a good way of modelling web interations was Christian Queinnec: http://www-spi.lip6.fr/~queinnec/PDF/www.pdf http://www-spi.lip6.fr/~queinnec/Papers/webcont.ps.gz Probably the best-known such framework is Seaside (ironic, as Smalltalk doesn't natively support continuations, AFAIK): http://www.seaside.st/ Phil Wadler is also doing something along these lines in Links, I believe: http://homepages.inf.ed.ac.uk/wadler/links/ Excellent summary of problems with REST and continuations (Dave Roberts): http://www.findinglisp.com/blog/2004/11/web-application-design-rest-of-stor… IBM article, mainly about Cocoon - a Java + Javascript framework: http://www-128.ibm.com/developerworks/java/library/j-contin.html More hype: http://phirate.exorsus.net/wiki/doku.php?id=web_development_in_2005 http://phirate.exorsus.net/wiki/doku.php?id=further_discussion_of_continuat… http://phirate.exorsus.net/wiki/doku.php?id=sessions_and_state Bill Clementson's postings (he's a Lisper): http://bc.tech.coop/blog/041229.html 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

ANN: pass.net is live in haskell!
by S. Alexander Jacobson 07 Mar '06

07 Mar '06

I just launched http://pass.net. Pass.net lets website use the user's email domains to authenticate. The default implementation is in Haskell and is now live. -Alex- PS I am at ETech right now and will be at SXSW next week. If you are here, please say hi. ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com

1 0

Can't uninstall GHC or prepare SOE installation on OS X
by Xavier Elizalde 07 Mar '06

07 Mar '06

I've installed the Glasgow Haskell Compiler 6.4.1 for OS X on my system. I have The Haskell School of Expression book and the instructions for setting up and running the SOE software seem to have a different configuration compared to GHC 6.4.1. Namely, it's meant to use X11 and locations for files are different. I presume the easiest thing to do is uninstall GHC 6.4.1 and install the binaries available on the SOE site. I've attempted to run the uninstall AppleScript for GHC, but I get a "Finder got an error: Can't get item "GHC-6.4.pkg" of folder "Receipts" of folder "Library" of startup disk. (-1728)" error. What should I do? If I'm going to uninstall it by hand, I don't know which files need to be removed. And I also wonder if it is actually preferable to somehow keep GHC and just configure it to work with the SOE by installing the GraphicsLib library and getting it to use X11. And I'm not clear about how I should do that. Or does the GHC already have GraphicsLIb as part of it? If so, shouldn't it launch an X11 Xterm terminal rather than the standard OS X Terminal? Xavier

1 0

PrefixMap: code review request
by David F.Place 07 Mar '06

07 Mar '06

Hi, I'm a newish Haskell hacker with way too much experience hacking Lisp. At first, I found my Haskell code looking very lisp-y. I think my code is becoming more idiomatic haskell. I would be very grateful to anyone who would take a glance at the code below and point out any un-idiomatic usages that jump out. It's a small module from a program which looks for palindromes in a list of words. Thanks very much. Cheers, David \begin{code} {-# OPTIONS -O2 -optc-O3 #-} module PrefixMap (PrefixMap,fromDistinctAscPairList,searchMap) where import Data.List import qualified Data.Map as Map import Test.HUnit \end{code} The PrefixMap datastructure implements a Prefix Tree which allows a key/value relationship. \begin{code} data PrefixMap k v = Node (Maybe v) (Map.Map k (PrefixMap k v)) deriving (Show) \end{code} A PrefixMap is built from an alphabet enumerating the possible constituents of keys and a list of pairs of keys and objects. A key is a string of elements of the alphabet. The list must be distinct and in ascending order. The constraint is not checked. \begin{code} fromDistinctAscPairList :: Ord k => [k]->[([k],v)]->PrefixMap k v fromDistinctAscPairList alphabet pairList = build alphabet Nothing (partList pairList alphabet) partList :: Ord k => [([k],v)]->[k]->[(k,[([k],v)])] partList pairs alphabet = reverse . fst $ foldl' f ([],pairs) alphabet where f (result,pairs) l = (result',rest) where (part,rest) = span ((==l) . head . fst) pairs result' = if null part then result else (l,part):result build :: Ord k => [k]->(Maybe v)->[(k,[([k],v)])]->(PrefixMap k v) build alphabet val pairs = Node val $ Map.fromDistinctAscList treePairs where treePairs = [(c,mkITree l)|(c,l)<-pairs] mkITree l = build alphabet x (partList l' alphabet) where (x,l') = findNode $ snipKeys l snipKeys :: Ord k => [([k],v)]->[([k],v)] snipKeys l = [(k,v) | (_:k,v) <- l] findNode :: Ord k => [([k], v)] -> (Maybe v, [([k], v)]) findNode l = if null suffix then (Nothing,l) else ((Just $ snd.head $ suffix),prefix++(tail suffix)) where (prefix,suffix) = span (not.null.fst) l \end{code} searchMap applies a function to each object in the PrefixTree that is on the path specified by the key and the subtree below it and returns a list of the results. \begin{code} searchMap :: Ord k => (v -> vv) -> [k] -> PrefixMap k v -> [vv] searchMap f [] t = walk f t [] searchMap f (k:ks) (Node v al) = maybe rest ((:rest) . f) v where rest = maybe [] (searchMap f ks) (Map.lookup k al) walk :: (a -> b) -> PrefixMap k a -> [b] -> [b] walk f (Node Nothing al) z = Map.fold (walk f) z al walk f (Node (Just x) al) z = Map.fold (walk f) (f x:z) al test1 = TestCase (do input <- readFile "words.txt" let dict = words input pairs = zip dict dict alpha = ['a'..'z'] ftree = fromDistinctAscPairList alpha pairs fAnswer = searchMap id "assert" ftree rtree = fromDistinctAscPairList alpha $ sort $ zip (map reverse dict) dict rAnswer = searchMap id "tressa" rtree assertEqual "forward search" ["as","ass","assertedly","asserted", "asserters","asserter","asserting", "assertions","assertion","assertively", "assertivenesses","assertiveness", "assertive","assertors","assertor", "asserts","assert"] fAnswer assertEqual "reverse search" ["reassert","overassert","assert"] rAnswer ) tests = TestList [TestLabel "Tree Test" test1] \end{code} \end{document} -------------------------------- David F. Place mailto:d@vidplace.com

16 38

mediawiki syntax highlighting plugins
by Johannes Ahlmann 06 Mar '06

06 Mar '06

hi, i've noted that the new haskellwiki has dropped syntax highlighting support for haskell code fragments. while i think that full highlighting might be overkill, at least different color markup of code and comments would certainly be nice. investigating the options for syntax highlighting in mediawiki i found the following two extensions using GNU enscript: http://www.wickle.com/wiki/index.php/Syntax_Highlight_extension http://www.milab.is.tsukuba.ac.jp/~bushuhui/index.php?title=Enhanced_syntax… where the second is an alteration of the first, with haskell support already added. an alternative would be geshi (http://qbnz.com/highlighter/) for which a mediawiki plugin also exists (http://meta.wikimedia.org/wiki/GeSHiHighlight) but it says on the geshi site "GeSHi supports PHP5 and Windows". and i'm not clear whether they mean it _also_ supports those options or exclusively. it would be cool if one of the wiki maintainers could look into this matter and possibly install/setup one of the above extensions. thank you, Johannes Ahlmann

3 2

Comparing programs
by Harry Chesley 06 Mar '06

06 Mar '06

This is more of an algorithm question than a language question, but any insights would be much appreciated. The problem is to input a series of programs and find previous occurrences of the same algorithm. The programs consist of a set of input parameters (a, b, c, ...), and a set of side-effect-free functions (f, g, h, ...). Since the functions are side-effect-free, they can be reordered without changing the algorithm ("f(a), g(b)" is the same as "g(b), f(a)"). Subsequent calls of the same function with the same parameters have no effect ("f(a), f(a)" is the same as "f(a)"); in fact, you can assume duplicates have been removed in earlier processing. But here's the thing that makes it hard (at least for me): two programs are considered the same if they can be made to match by rearranging the order of the input parameters. I.e., "f(a), g(b)" is the same as "f(b), g(a)". Although parameters can be reordered, they cannot be substituted ("f(a), g(b)" is _not_ the same as "f(a), g(a)"). Example: "f(a), g(b), h(a, b)" is the same as "f(b), g(a), h(b, a)" but _not_ the same as "f(a), g(b), h(b, a)". I need a way to compare the input programs, and preferably to order them. In Haskell terms, given the programs are represented by a type Prog, I want Prog to be a member of class Ord, letting me use tools like Data.Map to look up information about previous instances. I can do a brute-force compare by trying all the parameter permutations, but that only gives me Eq, not Ord, and seems terribly inelegant as well.

4 3

Credit Card Authorization code
by S. Alexander Jacobson 06 Mar '06

06 Mar '06

I am looking for Haskell code that does credit card authorization? e.g. paypal website pro does not supply a Haskell lib. Does anyone know where to find something like this? -ALex- ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com

2 1

Hacking Hawk
by szefirov＠ot.ru 06 Mar '06

06 Mar '06

Hawk didn't updated from GHC v4.04. It does contain dependencies on functions that are present in my current (6.04) GHC distribution, but they are not documented. Those functions and constructors are (just a error log from ghc): --------------------------- AQ.lhs:17:16: Not in scope: type constructor or class `STArray' AQ.lhs:82:14: Not in scope: `newSTArray' AQ.lhs:92:21: Not in scope: `writeSTArray' AQ.lhs:258:27: Not in scope: `readSTArray' AQ.lhs:262:27: Not in scope: `writeSTArray' --------------------------- They are in GHC.Arr module now. I found that googling for their name. They also changed their types so that they are not compatible with Control.Monad.ST (previous versions were compatible with LazyST). What does they do? Is it possible to rewrite them for current version of ghc?

3 2

Haskell documentation and GADTs
by Jim Apple 06 Mar '06

06 Mar '06

I'm having trouble generating automatic documentation in a module with GADTs. Haddock gives a parse error, and http://www.cse.ogi.edu/~hallgren/Programatica/tools/features.html seems to indicate that Programmatica will as well. Any ideas? Jim

1 0

afrp code base
by Instinctive 04 Mar '06

04 Mar '06

I've been coming up to speed on afrp, and I see the code base is almost two years old. Is this the state of the art? Thanks.

3 2

trying to understand runProcess handles
by Matthias Fischmann 03 Mar '06

03 Mar '06

hi there, I am running some unix command. I just realized there is runInteractiveProcess in System.Process, so my problem is solved in practice: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ showPlot :: String -> IO (Handle, Handle, Handle, ProcessHandle) showPlot file = runInteractiveProcess executable arguments wd env where executable = "/usr/bin/gnuplot" arguments = ["-geometry", "-19+3", file, "-"] wd = Nothing env = Nothing ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ But first I tried to create the handles myself with createPipe from System.Posix.IO, and I failed for a reasons that I have no clue how to learn to understand. This is what the code looked like: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ showPlot :: String -> IO (ProcessHandle, Handle, Handle, Handle) showPlot file = do (stdinR, stdinW) <- createPipeHandles (stdoutR, stdoutW) <- createPipeHandles (stderrR, stderrW) <- createPipeHandles h <- runProcess executable arguments wd env (Just stdinR) (Just stdoutW) (Just stderr W) return (h, stdinW, stdoutR, stderrR) where executable = "/usr/bin/gnuplot" arguments = ["-geometry", "-19+3", file, "-"] wd = Nothing env = Nothing createPipeHandles :: IO (Handle, Handle) createPipeHandles = do (fR, fW) <- createPipe hR <- fdToHandle fR hW <- fdToHandle fW return (hR, hW) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ The problem is that gnuplot terminates right away after it tries to read from stdin (I can see the shadow of a window appear and vanish immediately). I tried setFdOption, with no effect. Is this because the handles passed to runProcess are closed in the parent process, and therefore the pipe is teared down and useless? I don't think so: If I run 'find /' instead of gnuplot, the process happily starts and I can hGetLine from stdout. If you have any clue I'd love to learn. Anyway, as I said, it's really better to simply use runInteractiveProcess in this simple case. thanks, Matthias

2 3

rounding errors with real numbers.
by Matthias Fischmann 03 Mar '06

03 Mar '06

hi, I think this is the well-known issue of using real numbers in decimal representation on a machine that thinks binary, but I don't know what to do with it, and some of you maybe do. I want to shift+stretch a list of doubles into a given interval. example: | x1 = [2, 3, 4, 5, 10] | y1 = normInterval x1 0 1 | => y1 = [0.0,0.125,0.25,0.375,1.0] The function that does this looks something like this: | normInterval :: [Double] -> Double -> Double -> [Double] | normInterval ps lower upper = map (\ x -> (x - oldLower) * stretch + lower) ps | where | oldLower = head ps | oldUpper = last ps | stretch = (upper - lower) / (oldUpper - oldLower) However, with bigger numbers I get rounding errors: | x2 = [0.0,1.9569471624266144e-3,5.870841487279843e-3,1.5655577299412915e-2,3.913894324853229e-2,9.393346379647749e-2,0.2191780821917808,0.5009784735812133,1.1272015655577299,2.504892367906066] | y2 = normInterval x2 0 1 | => y2 = [0.0,7.8125e-4,2.3437500000000003e-3,6.25e-3,1.5625000000000003e-2,3.7500000000000006e-2,8.750000000000001e-2,0.2,0.45000000000000007,0.9999999999999999] The solution that pops to my mind is very simple: | normInterval :: [Double] -> Double -> Double -> [Double] | normInterval ps lower upper = repair (map (\ x -> (x - oldLower) * stretch + lower) ps) | where | oldLower = head ps | oldUpper = last ps | stretch = (upper - lower) / (oldUpper - oldLower) | | -- fix rounding error: | repair [i] = [upper] | repair (h:t) = h : repair t It works, but it's ugly. Is there a better way to do this? Thanks, Matthias

7 14

Re: Template haskell instance checking
by heatsink 02 Mar '06

02 Mar '06

>>Is there a way, in template haskell, to find out what instance >>declarations >>exist? >Not at the moment, I'm afraid, but it's the kind of question that TH >ought to be able to answer. I could offer guidance if someone wanted to >implement it. I have a concern about how computed class memberships would work. Class membership is global, so creating a class instance is a globally visible side effect of TH code. Once you add the ability for TH code to inspect instances, the side effects mean that the order in which different splices get executed affects the compiler output. This is probably a bad thing. I'm not sure how it could be designed to work nicely; the only approach I can think of at the moment is to give splice evaluation a dataflow execution semantics that causes splices to execute and possibly reexecute at the "appropriate" times. I'd like to hear if anyone else has ideas on how to solve this problem. .....tian: I think that's a good point in general about conditional code generation. I wasn't thinking about conditional generation based on compile-time settings, but rather reusable TH library functions that inspect the class memberships of their arguments. Of course, this can be used for good or evil :) --heatsink

1 0

Help with Type Class
by Alson Kemp 02 Mar '06

02 Mar '06

Although the discussion about Array refactoring died down quickly on the Haskell' mailing list, I've been noodling on refactoring the various Collections in Haskell. In doing so, I've bumped into a problem with type classes that I can't resolve. The issue is as follows: I'm designing a Collections class heirarchy that is a blend between that of Java and of Haskell. The problem is that, whereas in OOP it is easy to do so, Haskell class mechanism seems to make it difficult to add *new* member variable to subclasses. Simple goal: create a top-level Collection with an *indexed* Array subclass (and various other subclasses). The problem I'm running into is Collection has no need of an "index" variable and I can't seem to figure out how to add an "index" to Array when subclassing from Collection Mock up: -- class CollectionClass c e where -- every Collection supports toList... toList :: c e -> [e] class (CollectionClass a e)=> ArrayClass a e where ... data Array i e = Array i i instance CollectionClass Array e where -- Since Array is a Collection -- toList :: c e -> [e] -- but with an Array the type would be -- toList :: a i e -> [e] toList = ... -- I think that the problem goes away if: class CollectionClass c x e where ... with "x" used an index for Array or a key for Map or () for Set, but it doesn't seem clean to scatter member variables in the parent class in case the subclass requires them... Another possible solution that I couldn't get to work would be to use (Array i) as the type for "c" in "Collection c": instance CollectionClass (Array i) e where toList = ... -- (Array i) e -> [e] ? This seems clean because it says the Collection holds "e"s and is organized by an (Array i). Similarly, Set would be a Collection of "e"s organized by Set and Map would be a Collection of "e"s organized by (Map k). Undoubtedly, I've missspoken some crucial aspect of the type/kind/class/instance magical incantation. Help! - Alson

3 4

Template haskell instance checking
by heatsink 02 Mar '06

02 Mar '06

Is there a way, in template haskell, to find out what instance declarations exist? I'm not trying to accomplish anything specific right now, but I can see two potential uses for this. One is to emit compile-time error messages from TH code which would be more informative than the typechecker's output. The other is to produce TH functions that conditionally generate code depending on the instances satisfied by their arguments. I offer the following as a motivational example. Suppose you want to write an extensible library to handle files for, e.g., image data: class FileFormat a where formatName :: a -> String read :: Handle -> IO a write :: Handle -> a -> IO () instance FileFormat TheStandardFormat where .... class (FileFormat a, FileFormat b) => Convert a b where convert :: a -> b Now it would be nice to generate instances of (Convert a TheStandardFormat, Convert TheStandardFormat b) => Convert a b _except_ where there is an explicit definition for (Convert a b). AFAIK, there's no way to do this at present, but it seems like something that could be computed in TH. --heatsink

2 1

RE: [Haskell-cafe] Template haskell instance checking
by Simon Peyton-Jones 02 Mar '06

02 Mar '06

Not at the moment, I'm afraid, but it's the kind of question that TH ought to be able to answer. I could offer guidance if someone wanted to implement it. Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | heatsink | Sent: 02 March 2006 00:55 | To: haskell-cafe(a)haskell.org | Subject: [Haskell-cafe] Template haskell instance checking | | Is there a way, in template haskell, to find out what instance declarations | exist? I'm not trying to accomplish anything specific right now, but I can | see two potential uses for this. One is to emit compile-time error messages | from TH code which would be more informative than the typechecker's output. | The other is to produce TH functions that conditionally generate code | depending on the instances satisfied by their arguments. | | I offer the following as a motivational example. Suppose you want to write | an extensible library to handle files for, e.g., image data: | | class FileFormat a where | formatName :: a -> String | read :: Handle -> IO a | write :: Handle -> a -> IO () | | instance FileFormat TheStandardFormat where .... | | class (FileFormat a, FileFormat b) => Convert a b where | convert :: a -> b | | Now it would be nice to generate instances of (Convert a TheStandardFormat, | Convert TheStandardFormat b) => Convert a b _except_ where there is an | explicit definition for (Convert a b). AFAIK, there's no way to do this at | present, but it seems like something that could be computed in TH. | | --heatsink | | | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

module for probability distributions
by Matthias Fischmann 01 Mar '06

01 Mar '06

hei again, (-: I wrote a module for sampling arbitrary probability distribution, so far including normal (gaussian) and uniform. http://www.wiwi.hu-berlin.de/~fis/code/ For those who need something like this: feel free to take it, it's BSD. For those who feel like growing their karma: - There are a few questions in the code (marked with 'XXX'). - There are probably far better way to do this. I am eager to learn. - There is probably a better implementation out there already. Please point me to it. cheers, Matthias

3 2

enforcing strictness on arbitrary subexpressions
by Matthias Fischmann 01 Mar '06

01 Mar '06

hei, I want to force evaluation on an arbitrary expression. What I have found is only strict datatypes (the '!' thing), but not a strictness idiom for arbitrary subexpressions. (I want this for debugging mostly, so if there is a better way to unsafePerformIO something in one piece I would be happy with that, too.) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ veryLongString = "..." data StrictThingy = StrictThingy ! String main :: IO () main = do hPutStr stdout veryLongString -- lazy veryLongString `seq` hPutStr stdout veryLongString -- still lazy? (StrictThingy veryLongString) `seq` hPutStr stdout veryLongString -- strict (or at least i hope it is) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Problem with the last line is that it doesn't work for arbitrary types, and it's kind of ugly. What I would like to have is something like: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ hPutStr stdout ! veryLongString ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ but I guess it's not that easy? Sorry for asking without consulting the list archives, but I promise I'll add it to the faq in the wiki once i understood. (-: I am using ghci and ghc, latest ubuntu package, but I am happy to switch to new versions. thanks, matthias

3 3

Code snippet, a `trace' with line and column numbers
by dons＠cse.unsw.edu.au 01 Mar '06

01 Mar '06

Suggested by a question from sethk on #haskell irc channel. Solves an FAQ where people have often resorted to cpp or m4: a `trace' that prints line numbers. > module Location (trace, assert) where > > import qualified Control.Exception as C (catch) > import System.IO.Unsafe (unsafePerformIO) > import GHC.Base (assert) > import System.IO > > -- An identity function that also prints the current line and column number > trace :: (Bool -> IO () -> IO ()) -> a -> a > trace assrt f = (unsafePerformIO $ C.catch (assrt False $ return ()) printIt) `seq` f > where > printIt e = let (x,_) = break (== ' ') $ show e > in hPutStrLn stderr (x ++ " trace") for example: > import Location > > main = do > let x = trace assert (1+2) > > putStrLn . show $ x Generates: $ ./a.out M.hs:4:18-23: trace 3 This continues a theme I've noticed: catching internal exceptions can yield some interesting results, i.e. with undefined, missing class methods, and here, assertion failures. Hope this little thing is useful. Cheers, Don

1 0

My piece of an IRC bot
by ihope 01 Mar '06

01 Mar '06

Today I started on a simple IRC bot framework thingy. I decided to post the source code here so people can look at it and tell me what the heck I did wrong :-P > module IRC where > > import Control.Monad.State > import System.IO > import Network > > {----------------------}{------------------------------------------------------} > > data IRCMessage = IRCMessage (Maybe String) String [String] > > type IRCBot a = IRCMessage -> State a [IRCMessage] > type IRCConnection a = IRCBot a -> IO () > > ircConnect :: String -> Integer -> a -> IRCConnection a > > ircConnect server port > state bot = withSocketsDo (do > connection <- connectTo server (PortNumber (fromInteger port)) > ircLoop connection state bot) > > ircLoop connection state > bot = do > eof <- hIsEOF connection > if eof then hWaitForInput connection 500 >> return () else do > message <- hGetLine connection > hPutStr connection (fst (runState (bot (ircParseMessage message)) state) >>= > decodeMessage) > ircLoop connection (snd (runState (bot (ircParseMessage message)) state)) > bot > > -- Oh noes. Let's hope we'll never, ever have to read that ;-) > > {-End I/O capable code-}{------------------------------------------------------} > > ircParseMessage x = let rx = filter (/='\r') x > (p:u:us) = words rx in > if (head p) == ':' then IRCMessage (Just p) u > (ircParseParams us) > else IRCMessage Nothing p (ircParseParams (u:us)) > > ircParseParams (x:xs) = if head x == ':' then [unwords (x:xs)] > else x : ircParseParams xs > > decodeMessage (IRCMessage > Nothing command params)= (command ++ ' ' : unwords (init params) ++ ' ' : > (':' : last params)) > > decodeMessage > (IRCMessage (Just > prefix) command params)= ((':' : prefix) ++ ' ' : command ++ ' ' : unwords > (init params) ++ (':' : last params)) > > {-Thus ends the IRCbot-}{------------------------------------------------------} The very simple bot I've been trying to run with it: > module Main where > > import IRC > import Control.Monad.State > > {----------------------}{------------------------------------------------------} > > main = ircConnect "brown.freenode.net" 6667 False bot > > bot _ = State (\x -> if x then ([],True) else ( > [IRCMessage Nothing "NICK" ["EagleBot"], > IRCMessage Nothing "USER" ["EagleBot", "Null", > "Null", "EagleBot"], > IRCMessage Nothing "PRIVMSG" ["NickServ", > "IDENTIFY censored"], > IRCMessage Nothing "JOIN" ["#esoteric"]],True))

1 0

Picking a shell for runCommand
by Tom Hawkins 28 Feb '06

28 Feb '06

It appears runCommand uses /bin/sh by default, but our environment needs tcsh. Is there any way to set an alternative shell? -Tom

2 1

socket TChan problem
by Stefan Aeschbacher 28 Feb '06

28 Feb '06

Hi I try to write a program that reads from a socket and communicates the result over a TChan and writes it to stdout. Somehow I can't seem to get it right, the result is only printed when I send ETX on the socket. Attached is a sample program that shows the behvaviour. Any hints on where my error is or how I could debug such a problem is appreciated. regards Stefan

2 3

standard poll/select interface
by Bulat Ziganshin 28 Feb '06

28 Feb '06

Hello John, Thursday, February 09, 2006, 3:19:30 AM, you wrote: >> JM> If we had a good standard poll/select interface in System.IO then we >> JM> actually could implement a lot of concurrency as a library with no >> JM> (required) run-time overhead. I'd really like to see such a thing get >> JM> into the standard. Well, mainly it would just be a really useful thing >> JM> to have in general. If others think it is a good idea I can try to come >> JM> up with a suitable API and submit it to the repo. >> >> i have delayed answering to this letter until i announced my Streams >> library. now i can say that such API already exists - in terms of my >> library you need just to write an transformer that intercepts >> vGetBuf/vPutBuf calls and pass them to the select/poll machinery. so >> you can write such transformer just now and every program that uses >> Streams will benefit from its usage. Converting programs that use >> Handles to using Streams should be also an easy task. JM> I was actually asking for something much more modest, which was the JM> routine needed to pass them to the select/poll machinery. but yeah, what JM> you say is one of my expected uses of such a routine. Once a standard IO JM> library settles down, then I can start working on the exact API such a JM> routine would have. but if all will wait while the library settles down, it will never occur :) your work can change design of library, like the my library itself can change the shape of haskell' :) at this moment, i just developed the library which satisfy demands in extending current I/O library by new features, such as Unicode support, high speed, portability to other compilers, binary i/o, i/o for packed strings, and asynchronous i/o using methods other than select(). but i don't implement all these features actually, i just developed infrastructure, in which all these features can be easily added. unlike the System.IO library, you don't need to ask someone to implement new features or make corrections in foreign sources. you just need to develop module what implements this standard Stream interface and then it can be used as easy as transformers from the library itself as i understand this idea, transformer implementing async i/o should intercept vGetBuf/vPutBuf calls for the FDs, start the appropriate async operation, and then switch to another Haskell threads. the I/O manager thread should run select() in cycle and when the request is finished, wake up the appropriate thread. what's all. if you will ever need, this implementation can then be used to extend GHC's System.IO internals with the support for new async i/o managers (as i understand, select() is now supported by GHC, but poll(), kqueue() is not supported?). the only difference that my lib gives an opportunity to test this implementation without modifying GHC I/O internals, what is somewhat simpler. so, interface for async vGetBuf/vPutBuf routines should be the same as for read/write: type FD = Int vGetBuf_async :: FD -> Ptr a -> Int -> IO Int vPutBuf_async :: FD -> Ptr a -> Int -> IO Int i think that implementations for ghc and jhc should be slightly different, though, because of different ways to implement multi-threading. but the I/O manager should be the same - it just receives info about I/O operations to run and returns information about completed ones. ... well, this I/O manager should implement just one operation: performIO :: Request -> IO () type Request = (IOType, FD, Ptr a, Int, Notifier) data IOType = Read | Write | ... type Notifier = Result -> IO () data Result = OK Int | Fail ErrorInfo "performIO" starts new I/O operation. On the completion of this operation, Notifier is called with information about results of execution. so, for the GHC the following should work: vGetBuf_async fd ptr size = do done <- newMVar let notifier = putMVar done () performIO (Read, fd, ptr, size, notifier) takeMVar done for JHC, the body of "vGetBuf_async" may be different if you will find this interface reasonable, at least for the first iteration, i will develop appropriate transformer, so for you remains "only" the implementation of "performIO" >> of course, Streams library is not some standard just now, and moreover >> - it is not compatible with JHC. the greatest problem is what i using >> type classes extensions available in GHC/Hugs what is not in H98 >> standard. so, i'm interested in pushing Haskell' to accept most >> advanced possible extensions in this area and, of course, in actual >> implementing these extensions in the Haskell compilers. alternative >> way to make Streams available to wider range of Haskell compilers is >> to strip support of streams working in monads other that IO. JM> Don't take the absence of a feature in jhc to mean I don't like or want JM> that feature. There are a lot of things I don't have but that I'd JM> definitly want to see in the language simply because I was only shooting JM> for H98 to begin with and was more interested in a lot of the back end JM> stuff. You should figure out the nicest design that uses just the JM> extensions needed for the design you want. it could help us decide what JM> goes into haskell-prime to know what is absolutely needed for good JM> design and what is just nice to have. this simply means that the Streams library cannot be used with JHC, what is bad news, because it is even more rich than GHC's System.IO. jhc had chance to get modern I/O library. but it lost that chance :) >> if you can make select/poll transformer, at least for testing >> purposes, that will be really great. JM> Yeah, I will look into this. the basic select/poll call will have to be JM> pretty low level, but hopefully it will allow interesting higher level JM> constructs based on your streams or an evolution of them. please look. at this moment Sreams library lacks only a few important features, already implemented in GHC's System.IO: sockets, line buffering and async i/o. moreover, i don't have an experience in implementing the async i/o, so foreign help is really necessary addressing these three issues will allow to propose the Streams library as possible System.IO replacement. and as you can see, implementing the "performIO" will allow us to use async i/o for all possible i/o operations, including "get/put_" or vGetContents, for example -- Best regards, Bulat mailto:bulatz@HotPOP.com

8 18

Associated Type Synonyms question
by Niklas Broberg 28 Feb '06

28 Feb '06

Hi, I'm playing around with associated type synonyms (ATS) [1] and the PHRaC interpreter, trying to model existing uses of FDs. I really enjoy working with ATS, but I've come across a situation that I don't quite know how to handle, or indeed if it can be handled at all. The scene is Control.Monad.Writer from mtl, where we can find the following definition (simplified for presentation): class (Monoid w, Monad m) => MonadWriter m w | m -> w where tell :: w -> m () The class MonadWriter has two type parameters, one for the monad itself and the other for that which is written. The Monoid constraint on the output is (I guess) there only as a documentation of sorts, stating that the intention is that the output of subsequent tell's should be combinable using mplus. A simple custom monad that just does output could be written as: data MyWriterM w a = MyWriterM (a, [w]) instance Monad (MyWriterM w) where return x = MyWriterM (x, []) MyWriterM (a, xs) >>= k = let MyWriterM (b, xs') = k a in MyWriterM (b, xs ++ xs') instance MonadWriter (MyWriterM w) w where tell x = MyWriterM ((), [x]) Now, to model this using ATS we would write, ignoring the Monoid constraint, the following class declaration*: class Monad m => MonadWriter m where type Output m tell :: Output m -> m () instance MonadWriter (MyWriterM w) where type Output m = [w] tell x = MyWriterM ((), [x]) This works fine, but the obvious question is then, where to put back the Monoid restriction? This time we want the type Output m to be constrained, so my naive first guess was to write: class (Monad m, Monoid (Output m)) => MonadWriter m where .. but phrac says "illegal context for class MonadWriter: only type variables can be constrained". I can't really think of anywhere else to put the restriction, other than making up an ad hoc class constraint syntax for associated types like class Monad m => MonadWriter m where type (Monoid) Output m ... My first question is already stated: where do I put the Monoid constraint? But since I suspect the answer is "you don't", a number of followup questions spring to mind: - why not? Apart from possibly having to use some ugly syntax for it, are there any fundamental reasons why this should not be allowed? - when looking at the definition of MonadWriter the Monoid constraint is not strictly necessary, and none of the other mtl monads have anything similar. Is it the assumption that this kind of constraint is never really necessary, and thus no support for it is needed for ATS? Hope someone can shed some light on this matter :-) Regards, /Niklas [1] http://www.cse.unsw.edu.au/~chak/papers/CKP05.html * Using Haskell syntax instead of the PHRaC equivalent

11 27

-fno-monomorphism-restriction makes type-inference ambiguous?
by Eike Scholz 27 Feb '06

27 Feb '06

Note: This Question has already been asked on the haskell mailing list. But haskell-cafe seems to be more adequate for for this question. Hi, i have encountered a problem and I don't quite understand the reason why I get the results I get. ghci seems to infer different types for the same expression. Consider that I have disabled the monomorphism restriction in module AGC.lhs (which is attached). and I have a toplevel definition of: > mylength = synAttr listLength loding the module in ghci (6.4) gives (beside some correct warnings): $ Ok, modules loaded: Main. $ *Main> :type synAttr $ synAttr :: (Data b) => ((?stack::[Dyn]) => b -> a) -> Attr a $ *Main> :type listLength $ listLength :: (?stack::[Dyn]) => List -> Float $ *Main> :type (synAttr listLength) $ (synAttr listLength) :: Attr Float $ *Main> :type mylength $ mylength :: (?stack::[Dyn]) => Dyn -> Dyn -> [Dyn] -> Maybe Float $ *Main> let mylength = synAttr listLength $ *Main> :type mylength $ mylength :: Dyn -> Dyn -> [Dyn] -> Maybe Float where > type Attr a = Dyn -> Dyn -> [Dyn]-> Maybe a the problem I have is that inferred types for the toplevel declaration mylength differ from the verbatim equal definition in the Let experssion. for the toplevel it infers: mylength :: (?stack::[Dyn]) => Dyn -> Dyn -> [Dyn] -> Maybe Float for the let-Binding mylength :: Dyn -> Dyn -> [Dyn] -> Maybe Float and this is what I expected. Has anyone an Idea, why this happens? best regards, Eike Scholz PS: Beware of the comments in the attached file. This file is under heavy development. I am dyslexic and don't correct the comments while continuously rewriting code and comments. I hope that the comments are useful anyway. The (+>) (~>) (#>) operators are broken at the moment and don't work the way intended.

2 1

Question about Haskell types
by Pete Chown 26 Feb '06

26 Feb '06

I've been trying to get to the point with Haskell where I can write useful programs, and I've come across something I don't understand with the type system. I hope this is the right place to ask. I came up with the following list of declarations: a = (<) b x = (x <) c x y = (x < y) It turns out that 'a' is badly typed and gives an error at compile time. 'B' and 'c' are equivalent and have type "Ord a => a -> a -> Bool". What I don't understand is why 'a' doesn't behave the same way as the other two. Thanks for any help you can give me, and in the meantime I'll go back to relearning everything I thought I knew about programming. :-) Pete

3 2

Monads (was "how to write an interactive program ? gui library to use ?")
by Jared Updike 25 Feb '06

25 Feb '06

(Note, moved to haskell-cafe.) > Essentially, the answer is "yes", the state needs to be passed around > (neglecting hackery to simulate global variables that is better > avoided). However, this can be made convenient by using a monad. BTW, Minh, If you don't know what monads are, then read this. Monads are an indispensable part of programming in Haskell: http://www.nomaware.com/monads/html/ http://haskell.org/hawiki/Monad Monads are good. Monads are your friend. Jared. -- http://www.updike.org/~jared/ reverse ")-:"

1 0

Context in data and class declarations (was haskell programming guidelines)
by Brian Hulley 25 Feb '06

25 Feb '06

Hi - In http://www.informatik.uni-bremen.de/agbkb/forschung/formal_methods/CoFI/het… one of the recommendations states: "Don't put class constraints on a data type, constraints belong only to the functions that manipulate the data." This made me think: what on earth was the point of allowing contexts on a data declaration in the first place? I've always found it a confusing feature of Haskell since you in any case need to "repeat" all the (relevant) constraints when declaring the type of any function that manipulates the data. There does not appear to be any sensible reason for requiring the constraints for constructor functions, because the constructor functions would never ever need to use them... Therefore would it be a good idea to get rid of this feature altogether? Another confusing thing is the use of the word "inheritance" in tutorials/books about class declarations. Unlike object oriented languages, where a class or interface gets all the methods of its ancestor classes/interfaces in addition to some new methods declared at that level, each Haskell type class is completely independent of any other type class. For example, the class Ord contains methods for (<) (<=) (>=) (>) max min but does not contain the methods of Eq even though this confusing word "inheritance" or "superclass" would imply that it should. Ord does *not* "inherit" anything at all - the meaning of the Eq context in the class declaration is just that we will need the Eq dictionary in addition to the Ord dictionary when calling any of Ord's methods. Thus I propose that the contexts don't really have any place in a class declaration either ie class Eq a => Ord a where (<), (<=), ... :: would be better written as: class Ord a where (<), (<=), .... :: Eq a => a->a->Bool so the language wouldn't be so confusing to learn. Classes are after all extremely simple! :-) Regards, Brian.

1 1

graphics on mac os x
by jeff p 24 Feb '06

24 Feb '06

Hello, I am running ghc 6.4.1 on mac os X (10.4.5). Can anyone give me some pointers for getting graphics functionality? I have tried wxhaskell, but it gives me the error HelloWorld.hs:4:0: Failed to load interface for `Graphics.UI.WX': Bad interface file: /usr/local/wxhaskell/lib/imports/Graphics/UI/WX.hi mismatched interface file versions: expected 6041, found 6040 when I try to compile the HelloWorld.hs program following the mac os x instructions. I have also tried to run Graphics.HGL in X11, but I get the error: Loading package X11-1.1 ... can't load .so/.DLL for: X11 (dlopen(libX11.dylib, 10): image not found) when I try to run the obligatory "Hello World" program from inside ghci. Are there other high/medium level graphics options for haskell on macs? Any help would be appreciated. thanks, Jeff

2 1

Best representation of graph for use in a zipper?
by Daniel McAllansmith 24 Feb '06

24 Feb '06

Hi I've been having a look at zippers over homogenous tree data types, and was wondering how best to represent a heterogeneous graph for manipulation with a zipper. The main example of zippers I've been looking at is http://okmij.org/ftp/Computation/Continuations.html#zipper-fs and http://okmij.org/ftp/Computation/Continuations.html#zipper from which I've included a small extract at the end of this email to provide extra context if necessary. For contrived example, given a relational model: .Album . |1 . | . | . |1..n 0..n 1 .Performance--------Song . |0..n |1 . | | . | |0..n . |1 WritingCredit . Performer |0..n . ^ ^ | . | |------ | . | | | . | 1 1..n | |1 .Group--------Artist I could write a data type: > data MC > = Album {perfs ::[MC]} > | Performance {album :: MC, song :: MC, performer :: MC} > | Song {perfs :: [MC], artistCredits :: [MC]} > | Group {perfs ::[MC], artists :: [MC]} > | Artist {perfs :: [MC], songCredits :: [MC]} > | Root {albums :: [MC]} The first problem I have with this is that it doesn't enforce enough structural constraints. Secondly, as I understand it, whilst zippers can handle cyclic structures they do so by doing a 'copy-on-write'. I would like to maintain shared instances. I could flatten the data type graph to a minimal spanning tree: > data MCFK = MCFK > data MC > = Album {fKey :: MCFK, perfs ::[MC]} > | Performance {fKey :: MCFK, songFK :: MCFK, performer :: MCFK} > | Song {fKey :: MCFK, artistCredits :: [MCFK]} > | Group {fKey :: MCFK, artists :: [MC]} > | Artist {fKey :: MCFK} > | Root {albums :: [MC], songs :: [MC], groups :: [MC], soloArtists :: [MC]} This seems a bit better. The traversal function doesn't have to worry about cycles and there's less mainenance updates to do. But it still doesn't offer any structural or foreign key guarantees. I thought that I would be able to use a GADT to give structural guarantees, though not FK guarantees, but once I move to a GADT I don't know how to write a traversal function as the next node could be of several different types. Any advice on how to get a safer data structure, and write the necessary traversal function, would be much appreciated. Cheers Daniel Following is an extract from the links above. Note that I have floated the functions local to traverse up to the top level to get at them with GHCi > data Term = Var String | A Term Term | L String Term deriving (Show) > > data Direction = Down | DownRight | Up | Next deriving (Eq, Show) > > traverse :: (Monad m) => (Direction -> Term -> m (Maybe Term, Direction)) -> Term -> m Term > traverse tf term = traverse' tf id Down term >>= maybeM term id > > > traverse' tf next_dir init_dir term = do > (term', direction) <- tf init_dir term > let new_term = maybe term id term' > select tf (next_dir direction) new_term >>= maybeM term' Just > > next next_dir dir = if dir == Next then next_dir else dir > > maybeM onn onj v = return $ maybe onn onj v > > select tf Up t = return Nothing > select tf Next t@(Var _) = return Nothing > select tf dir t@(L v t1) | dir == Next || dir == Down = do > t' <- traverse' tf id Down t1 >>= (return . fmap (L v)) > traverse' tf (next Up) Up (maybe t id t') >>= maybeM t' Just > select tf DownRight t@(A t1 t2) = do > t' <- traverse' tf id DownRight t2 >>= > (return . fmap (\t2'->(A t1 t2'))) > traverse' tf (next Up) Up (maybe t id t') >>= maybeM t' Just > select tf dir t@(A t1 t2) | dir == Next || dir == Down = do > t' <- traverse' tf id Down t1 >>= > (return . fmap (\t1'->(A t1' t2))) > traverse' tf (next DownRight) Up (maybe t id t') >>= > maybeM t' Just > > > --Testing > trav dir term = do print dir; print term; return (Nothing,Next) > > > term1 = A (Var "v1") (L "l1" (A (Var "v2") (Var "v3"))) > > test1 = traverse trav term1

1 0

RE: [Haskell-cafe] Re: Hashtable woes
by Simon Marlow 23 Feb '06

23 Feb '06

On 21 February 2006 17:21, Chris Kuklewicz wrote: > From the shooutout itself: > > http://shootout.alioth.debian.org/gp4/benchmark.php?test=knucleotide&lan g=ghc&id=3 > > and > > http://shootout.alioth.debian.org/gp4/benchmark.php?test=knucleotide&lan g=ghc&id=2 > > (I forget the exact different between them) > > From the wiki (the Current Entry): > > http://haskell.org/hawiki/KnucleotideEntry#head-dfcdad61d34153143175bb9f 8237d87fe0813092 Thanks... sorry for being a bit dim, but how do I make this test run for longer? I downloaded the example input. The prog doesn't seem to take an argument, although the shootout suggests it should be given a parameter of 250000. Cheers, Simon

3 2

Re: [Haskell] page renaming on the Haskell Wiki
by Graham Klyne 22 Feb '06

22 Feb '06

Wolfgang, [Switching to haskell-cafe] Re: [1] http://www.mail-archive.com/haskell@haskell.org/msg18352.html [2] http://www.mail-archive.com/haskell@haskell.org/msg18356.html [3] http://www.w3.org/Provider/Style/URI Wolfgang Jeltsch wrote (in [2]): > On the other hand, I think that the above W3C article is far too extreme. It > tells you that stability is the most important thing concerning URIs. I will pursue this a little further, because I think that getting the web presence right is very important to maintaining an online community. It may be that we must agree to disagree, but based on my experience of using the web, stability of URIs *is* the most important thing (after content, of course). I have been using the W3C web site now for many years, and the inconsistencies you mention have never been a problem for me -- indeed, I hadn't even noticed them until you mentioned them. Why is this? I hypothesize that it is because, when the Web is used effectively, it is really quite rare to enter a URI manually. Instead, one uses various index pages, RSS feeds, search tools and so on to find a URI, and then simply click on it. Many URIs are never seen by human eye, but placed behind descriptive links. W3C themselves use URIs very intensively in transient communications, and their mailing system is set up to facilitate this (see their x-archived-at mail headers). A result of this is that the email archives, together with the web site pages, form a tightly interlinked collection of documents and comments that can be, and are, frequently cross-referenced rather than reinvented. But, for this to work, once a link has been placed in a document, feed, archive or whatever, it is crucially important that it continues to work for as long as the information it references is of interest to people. Without this, all the devices we use to find our way around the web simply fail -- not all at once, but over time. Even with every intent to maintain stability, this happens, but if you allow that URI stability is somehow less important than other conveniences, then I think all hope is lost for information continuing to be accessible. As for the difficulty of designing a consistent URI naming scheme for all time, the W3C position explicitly recognizes this, and this is why they recommend incorporating dates near the the root of the URI path. That way, fashions can change without requiring that pages published using older conventions be removed. How to do this in a wiki, I'm not sure, though I don't take that to mean we shouldn't try. I think the mediawiki mechanism you mention is reasonable if not ideal, though this would clearly be overwhelmed if page-renaming were to become the norm. There are, as you indicate, other technical concerns. But I still think they are more easily solved that the problems that arise by failing to maintain URI stability. Best regards, #g -- Graham Klyne For email: http://www.ninebynine.org/#Contact

3 4

Emulating bash pipe/ process lib
by Marc Weber Marc Weber 22 Feb '06

22 Feb '06

Hi. I want to write a little haskell program executing about 4 programs passing data via pipes. As my python script seems to be slower than a bash script I want to try a ghc executable now. It should invoke different parts of a text to speech chain. This way I have one interface then. Talar und #haskell told me that I might use runProcess and pass handles for stdin and out created by createPipe and fdToHandle. So my simple test looks like this: module Main where import System.IO import System.Posix.IO main = do (fdIn,fdOut) <- createPipe let (iohIn, iohOut) = (fdToHandle fdIn, fdToHandle fdOut) hIn <- iohIn hOut <- iohOut hPutStr hIn "test" line <- hGetLine hOut print line -- should now print test having been piped through my pipe but I get the error: pipe2: <file descriptor: 3>: hPutStr: illegal operation (handle is not open for writing) And in current CVS docs in base.System.Process.hs it is said that createPipe is no longer exported ? I've also found this library: http://www.haskell.org/communities/11-2005/html/report.html#processlib which seems to do something similar but is meant to pipe haskell types between different threads (? I haven't understood what's going on there because I can't understand Russian ;-) Is this of any help for me? Greetings Marc

6 12

getChar + System.Cmd.system + threads causes hangups
by Einar Karttunen 22 Feb '06

22 Feb '06

Hello Using system or any variant of it from System.Process seems broken in multithreaded environments. This example will fail with and without -threaded. When run the program will print "hello: start" and then freeze. After pressing enter (the first getChar) System.Cmd.system will complete, but without that it will freeze for all eternity. What is the best way to fix this? I could use System.Posix, but that would lose windows portablity which is needed. import Control.Concurrent import System.Cmd main = do forkIO (threadDelay 100000 >> hello) getChar getChar hello = do putStrLn "hello: start" system "echo hello world!" putStrLn "hello: done" - Einar Karttunen

3 4

Re: Array interface refactoring
by bulat.ziganshin＠gmail.com 22 Feb '06

22 Feb '06

Hello Alson, Tuesday, February 21, 2006, 11:33:49 PM, you wrote: AK> As a Haskell new-ish-bie, the various Array interfaces AK> seem a bit inconsistent and make learning/using arrays AK> complicated. I *do* understand how to use arrays in AK> Haskell, but I think that the interface could be AK> cleaned up. sorry, but i think that you don't understand the whole situation. btw, are you read http://haskell.org/haskellwiki/Arrays ? AK> Examples of current confusions: AK> IArray and Array are dupes (obvious); Array is a type constructor, while IArray is a class AK> listArray for IArray, but newListArray for MArrays; AK> "!" for IArray, but readArray for MArrays. they have different types (!) :: IArray -> Ix -> Element readArray :: MArray -> Ix -> IO Element can you unify these two operations - one monadic and one pure to common type signature? AK> Proposal: I would propose the following for Haskell': AK> "Array" is the interface for arrays; drop IArray; AK> "MArray" is the interface for arrays in monads (IO, AK> ST, etc); and these two interfaces should support operations with the same names but different types? :) i partially agree with your other suggestions -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0

(Un)termination of overloading resolution
by oleg＠pobox.com 22 Feb '06

22 Feb '06

Martin Sulzmann wrote: > Let's consider the general case (which I didn't describe in my earlier > email). > In case we have an n-ary type function T (or (n+1)-ary type class > constraint T) the conditions says for each > > type T t1 ... tn = t > > (or rule T t1 ... tn x ==> t) > > then rank(ti) > rank(t) for each i=1,..,n ... > Sorry, I left out the precise definition of the rank function > in my previous email. Here's the formal definition. > > rank(x) is some positive number for variable x > > rank(F t1 ... tn) = 1 + rank t1 + ... + rank tn > > where F is an n-ary type constructor. > > rank (f t) = rank f + rank t > > f is a functor variable Yes, I was wondering what rank means exactly. But now I do have a problem with the criterion itself. The following simple and quite common code > newtype MyIOState a = MyIOState (Int -> IO (a,Int)) > > instance Monad MyIOState where > return x = MyIOState (\s -> return (x,s)) > > instance MonadState Int MyIOState where > put x = MyIOState (\s -> return ((),x)) becomes illegal then? Indeed, the class |MonadState s m| has a functional dependency |m -> s|. In our case, m = MyIOState, rank MyIOState = 1 s = Int rank Int = 1 and so rank(m) > rank(s) is violated, right? BTW, the above definition of the rank is still incomplete: it doesn't say what rank(F t1 ... tm) is where F is an n-ary type constructor and m < n. Hopefully, the rank of an incomplete type application is bounded (otherwise, I have a non-termination example in mind). If the rank is bounded, then the problem with defining an instance of MonadState persists. For example, I may wish for a more complex state (which is realistic): > newtype MyIOState a = MyIOState (Int -> IO (a,(Int,String,Bool))) > instance MonadState (Int,String,Bool) MyIOState Now, the rank of the state is 4...

2 1

Constructor classes implementation
by Sean Seefried 22 Feb '06

22 Feb '06

Hey all, If you're interested in an implementation of constructor classes (type classes which can take constructors as arguments; already implemented in Haskell) please see: http://www.cse.unsw.edu.au/~sseefried/code.html This should help understanding the paper by Mark P. Jones called "A system of constructor classes: overloading and implicit higher-order polymorphism" much easier. The implementation not only infers the type but also prints out a trace of the derivation tree for the syntax directed rules. Cheers, Sean p.s. If you find any bugs, please let me know.

3 4

RE: [Haskell-cafe] typesafe non-local returns in the IO monad
by Simon Peyton-Jones 22 Feb '06

22 Feb '06

I'm not sure this works. Consider this newContinuation (\k -> return (callContinuation k)) ... The partial application (callContinuation k) has no 's' in its type, and so can go anywhere. Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of John | Meacham | Sent: 21 February 2006 12:40 | To: haskell-cafe(a)haskell.org | Subject: [Haskell-cafe] typesafe non-local returns in the IO monad | | Although I am sure I am not the first to discover this, I thought it was | a neat application of the runST trick. Safe non-local returns for | the IO monad. What I mean by safe is that it is impossible to return to | a context that no longer exists. the api is simple: | | > module System.IO.Continuation(IOCont(),newContinuation,callContinuation) where | > | > data IOCont s a = .... | > | > newContinuation :: (forall s . IOCont s a -> IO b) -> (a -> IO b) -> IO b | > newContinuation act cc = ... | > | > callContinuation :: IOCont s a -> a -> IO b | > callContinuation cont x = ... | | newContinuation runs its first argument passing a fresh jumppoint into | it, if it is jumped to then the argument is passed to the second | argument of newContinuation. | | the universal quantification means that the continuation is unable to | escape the action so you know its context is still available on the | stack. | | in jhc these are just implemented as straight FFI calls to setjmp(2) and | longjmp(2) and an IORef. | | I feel using the term 'continuation' is something of a misnomer as true | continuations would allow jumping between multiple stacks I would think | but am unsure what a good name for this is then. Is there a fully | typesafe interface for 'true' IO continuations for some definition of | 'true'? hmm.... | | John | | -- | John Meacham - ⑆repetae.net⑆john⑈ | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1

Re: Streams: the extensible I/O library
by Simon Marlow 21 Feb '06

21 Feb '06

Bulat Ziganshin wrote: > I have developed a new I/O library that IMHO is so sharp that it can > eventually replace the current I/O facilities based on using Handles. > The main advantage of the new library is its strong modular design > using typeclasses. I've taken a brief look, and I must say it's nice (but you knew that anyway :-)). My initial thoughts: I would prefer to see more type structure, rather than putting everything in the Stream class. You have classes ByteStream, BlockStream etc, but these are just renamings of the Stream class. There are many compositions that are illegal, but we don't find out until runtime; it would make a lot more sense to me to expose this structure in the type system. My view is that the most basic level of stream is a byte stream, supporting only two operations: read an array of bytes and write an array of bytes, i.e. vGetBuf/vPutBuf. This makes implementing a stream, or transformer, much easier and shorter. Also I'd like to see separate input/output streams for even more type safety, and I believe simplicity, but this is less important than separating byte streams from text streams. I believe certain other operations would benefit from being moved into separate classes: eg. vSeek into a Seekable class, vSetBuffering into a Buffered class, and so on. This will improve performance too - your Stream class has dictionaries with 20+ elements. I see that buffering works on vPutChar/vGetChar, and yet you seem to be buffering bytes - which is it? Are you supposed to buffer before or after doing character encoding? It seems before, because otherwise buffering will strip out all but the low 8 bits of each character. Using a more explicit type structure would help a lot here. Incedentally, I'm suprised that you can use list-based character encoding/decoding and still get good performance, I expected to need to do encoding directly between buffers. Still, as I said, I think the general approach is excellent, and is definitely heading in the right direction. Oh, and some of the code is GPL'd, which is a problem for incorporation in standard libraries. This is just something to bear in mind if the aim is for this to be a candidate for a/the standard IO library. Cheers, Simon

4 7

Re: [Haskell-cafe] Re: Hashtable woes
by Chris Kuklewicz 21 Feb '06

21 Feb '06

Ketil Malde wrote: > Chris Kuklewicz <haskell(a)list.mightyreason.com> writes: > >> Is Jan-Willem Maessen's Hash available anywhere? I could benchmark it. > > Did you ever get around to run the benchmark? I browsed around a bit, > and found that the knucleotide is probably the worst GHC benchmark in > the shootout (even TCL beats GHC by a factor of two!) - which is > disheartening, because I rely a lot on associative data structures > (usually Data.Map) in my programs. > > Or have Adrian Hey's AVL-trees been tried? > > -k No, I did not try it. This message from Simon Marlow > Jan-Willem's HashTable attached. It uses unsafeThaw/unsafeFreeze tricks > to avoid the GC overheads, for this you need an up to date GHC due to a > bug in the garbage collector: grab a STABLE snapshot (6.4.1 won't work). > Or remove the unsafeThaw/unsafeFreeze to use it with 6.4.1, and be > prepared to bump the heap size. > > In GHC 6.6 the unsafeThaw/unsafeFreeze tricks aren't required, because > the GC is essentially doing it for you - we put a write barrier in the > IOArray implementation. indicates that it triggers a bug in 6.4.1, which is what the shootout is using. And I suspected bumping the heap size just won't cut it for the amount of data we are processing. But I did not test that suspicion. We never pounded on Data.Map, but I suspect it cannot be as bad as Data.Hashtable. -- Chris

6 7

typesafe non-local returns in the IO monad
by John Meacham 21 Feb '06

21 Feb '06

Although I am sure I am not the first to discover this, I thought it was a neat application of the runST trick. Safe non-local returns for the IO monad. What I mean by safe is that it is impossible to return to a context that no longer exists. the api is simple: > module System.IO.Continuation(IOCont(),newContinuation,callContinuation) where > > data IOCont s a = .... > > newContinuation :: (forall s . IOCont s a -> IO b) -> (a -> IO b) -> IO b > newContinuation act cc = ... > > callContinuation :: IOCont s a -> a -> IO b > callContinuation cont x = ... newContinuation runs its first argument passing a fresh jumppoint into it, if it is jumped to then the argument is passed to the second argument of newContinuation. the universal quantification means that the continuation is unable to escape the action so you know its context is still available on the stack. in jhc these are just implemented as straight FFI calls to setjmp(2) and longjmp(2) and an IORef. I feel using the term 'continuation' is something of a misnomer as true continuations would allow jumping between multiple stacks I would think but am unsure what a good name for this is then. Is there a fully typesafe interface for 'true' IO continuations for some definition of 'true'? hmm.... John -- John Meacham - ⑆repetae.net⑆john⑈

1 0

Unexpected results with simple IO
by Maurício 21 Feb '06

21 Feb '06

Dear Haskell users, I have a problem using IO. The small test program below asks the user to guess from a list of random numbers between 1 and 10. Everything works well excepts for one problem: all the messages ("Guess a number...", "Right..." and "Wrong...") are printed after the program finishes, i.e., I have to use it blind. I'm afraid I misunderstand something important about lazyness or monads... What am I doing wrong? Thanks, Maurício module Main where import Random main = do r_gen <- getStdGen --random generator let r_list = (randomRs (1,10) r_gen) --random list guess_loop (r_list) guess_loop (r:r_others) = do putStrLn "Guess a number between 1 and 10:" n <- readLn if n==r then do putStrLn "Right! :)" return () else do putStrLn "Wrong... :(" guess_loop r_others

3 5

Code completion? (IDE)?
by Marc Weber 21 Feb '06

21 Feb '06

vim7 has introduced "omni-completion"... So I'm interested wether there are any projects which support any kind of completion.? I've read the thread about Eclipse IDE haskell plugin. Would you recommend picking up code from a haskell compiler and adapt it for this purpose? I'm interested but don't plan to implement this in the near future. Marc

4 5

Lazy read
by Neil Mitchell 21 Feb '06

21 Feb '06

Hi, I have a nice big data structure that I serialise to a file using "show", and read back in using "read". This data structure has deriving (Read, Show), which makes it all nice and easy to save and load this data structure, without worrying about parsing code etc. The problem is that this data structure can become quite big, and while show operates lazily, read does not. I understand the reason for this - that it internally calls reads and that on a parse error reads will not return a result - i.e. it has to get to the end to determine whether the parse was valid or not. However, in my particular case, I know the data structure is valid, and if it isn't then I'm quite happy with the parser throwing an error half way through - after having lazily returned half of the data. A short example, which shows up the exact same issue is: head ((read $ show [1..n]) :: [Int]) The time of this operation is dependant on n, because of the strictness of read. What is the best way to modify the code to have read operate lazily? Is there any method that doesn't require writing a custom parser? Is there any standard way for solving a problem like this? Thanks Neil

4 4

RE: [Haskell-cafe] building ghc on win with gcc of cygwin, without cygwin1.dll (-mno-cygwin flag) ?
by Simon Peyton-Jones 20 Feb '06

20 Feb '06

| Googling around I've found that there exists the -mno-cygwin flag which | you can use to not include this lib.. So would it might be possible to | get a ghc build not using cygwin.dll with just cygwin ? I don't know. It sounds plausible. But we only have enough resource to maintain one route for building GHC on Windows. We'd be delighted if other folk were engaged enough to push other routes through and make them work. Another route we don't have, but which in principle is definitely feasible is to compile GHC using Cygwin for Cygwin. The advantage would be that the resulting GHC would have a working Posix library. The disadvantage is that programs it compiles would require Cygwin to run. Anyway, it's up for grabs. Please grab away! We need more Windows-savvy expertise on GHC. Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of Marc | Weber | Sent: 12 February 2006 04:45 | To: haskell-cafe(a)haskell.org | Subject: [Haskell-cafe] building ghc on win with gcc of cygwin,without cygwin1.dll (-mno-cygwin flag) | ? | | Hi.. I've found the nice documentation about building ghc on | haskell.org/ghc -> documentation. | There is one chapter (#1) about C compilers and environments to use: | Either MSYS or cywin and | gcc of MinGW because gcc of cygwin will link to cygwin1.dll by default | which may change and therefore can brake your apps. | Googling around I've found that there exists the -mno-cygwin flag which | you can use to not include this lib.. So would it might be possible to | get a ghc build not using cygwin.dll with just cygwin ? | I haven't read anything about that in those docs. | | Or does this flag simply include cygwin.dll within your apps (statically | linked) ? | | #1 :http://www.haskell.org/ghc/docs/latest/html/building/platforms.html#ghc -cygwin | | Marc | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

HaXml: ampersand in attribute value
by Koen.Roelandt＠mineco.fgov.be 20 Feb '06

20 Feb '06

HaXml seems to choke on finding an ampersand in an attribute value. Is this normal? Is there any workaround? Cheers, Koen.

4 6

Haskell as scripting language?
by Marc Weber 20 Feb '06

20 Feb '06

Is there a way to use haskell as scripting language in a) your own project? b) other projects such as vim (beeing written in C)? At the moment I'm interested, I don't have any real project..

4 4