- Haskell-Cafe - Haskell.org

newbie question on Parsers from "Programming In Haskell"
by Juozas Gaigalas 05 Jun '07

05 Jun '07

Hello, I am a somewhat experienced programmer and a complete Haskell newbie, so I hope this is the correct ML for my question. I have decided to learn Haskell and started with Graham Hutton's book. Everything was going nicely until section 8.4, on sequencing functional parsers. I am trying to write an elementary parser that produces the 1st and 3d elements from a string. I am using the code from the book. --------------------- type Parser a = String -> [(a, String)] return :: a -> Parser a return v = \inp -> [(v, inp)] failure :: Parser a failure = \inp -> [] item :: Parser Char item = \inp -> case inp of [] -> [] (x:xs) -> [(x, xs)] parse :: Parser a -> String -> [(a, String)] parse p inp = p inp (>>=) :: Parser a -> (a -> Parser b) -> Parser b p >>= f = \inp -> case parse p inp of [] -> [] [(v, out)] -> parse (f v) out p :: Parser (Char, Char) p = do x <- item item y <- item return (x, y) -- LINE 34 -------------------- BUT, when I try to :load parse.hs from hugs I get the following error: ERROR "parse.hs":34 - Last generator in do {...} must be an expression I have no idea what I am doing wrong and why Hugs is complaining. I hope this question is not too simply for this mailing list, but I have honestly googled for an answer and had found nothing. Juozas Gaigalas

7 6

QuickCheck Arbitrary - infinite recursion on recursive GADTs?
by Marc Weber 05 Jun '07

05 Jun '07

example: data A = A INt | B [A] instace Arbitrary A where arbitrary = oneof [ liftM A arbitrary , liftM B arbitrary ] But now QuickCheck will propably create a test value A ( B [ A ( B [ A .... -> no end Is there an easy QuickCheck way to prevent this? I can think of: a) using sized to pass when to stop (decrement the value ..) b) using some type hackary data Recursive a = R a then use arbitrary :: R ( R ( a )) and remove one R each time.. c) pass a recursion indicator manually and decrement that... Which would you choose? Marc

2 1

Java Monads?
by Greg Meredith 05 Jun '07

05 Jun '07

HaskellyCaffeinated, i noticed that there was a JavaMonad lib kicking around on the web, but all the links i can find are stale. Does anybody have a live pointer to this lib? Best wishes, --greg -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

1 0

Re: Has anyone looked into adding subtyping to Haskell?
by oleg＠pobox.com 05 Jun '07

05 Jun '07

Polymorphic extensible records with subtyping are already expressible in Haskell. There is nothing needs to be added: http://homepages.cwi.nl/~ralf/HList/ http://homepages.cwi.nl/~ralf/OOHaskell/ The full code is available via darcs http://darcs.haskell.org/OOHaskell/ As to polymorphic variants, they too are implementable in Haskell right now. No new extensions are required. http://www.haskell.org/pipermail/haskell/2006-July/018172.html http://darcs.haskell.org/HList/src/VariantP.hs The code shows that the expression problem is solved in Haskell as it is.

2 3

Idiomatically using lists
by kevin birch 05 Jun '07

05 Jun '07

Hello all, I have an implementation question that I hope someone can help out with. Say I have a fixed-size list: [1, 2, 3, 4, 5] that I want to treat as circular in a function in order to rotate one of the elements n positions. So rotating the second element 2 positions would result in: [1, 3, 4, 2, 5], or rotating the fourth element 2 positions would result in: [1, 2, 4, 3, 5]. There are two cases: if the element can be moved w/o rotating and where the element must be inserted into the list at the front. Is there an idomatic way to handle both of these cases in a function? Thanks, kevin

2 1

Fwd: [Haskell-cafe] Optimising UTF8-CString -> String marshaling, plus comments on withCStringLen/peekCStringLen
by Alistair Bayley 04 Jun '07

04 Jun '07

(this time include the list, too) ---------- Forwarded message ---------- From: Alistair Bayley <alistair(a)abayley.org> Date: 04-Jun-2007 16:13 Subject: Re: [Haskell-cafe] Optimising UTF8-CString -> String marshaling, plus comments on withCStringLen/peekCStringLen To: Duncan Coutts <duncan.coutts(a)worc.ox.ac.uk> On 04/06/07, Duncan Coutts <duncan.coutts(a)worc.ox.ac.uk> wrote: > > Are you sure fromUTF8Ptr is strict in its ptr arg? Try with a ! pattern > on that arg. You'll need -fbang-patterns. Is there some semantic advantage to bang-patterns, or is it just a syntactic convenience? 'cause once the guard is in there, it's not much bother to maintain. > You can also get ghc to tell you what strictness it inferred for your > functions. It's shown in the .hi file. Use ghc --show-iface UTF8.hi. I tried -ddump-hi and got: $wfromUTF8Ptr :: base:GHC.Prim.Int# -> base:GHC.Ptr.Ptr base:GHC.Word.Word8 -> base:GHC.Base.String -> base:GHC.Prim.State# base:GHC.Prim.RealWorld -> (# base:GHC.Prim.State# base:GHC.Prim.RealWorld, base:GHC.Base.String #) {- Arity: 4 Strictness: LSSL -} Assuming the LSSL tokens are in the same order as the function arguments, the first argument is lazy - GHC.Prim.Int#. hmmm.... some cognitive dissonance here. I'm a bit puzzled as to why it's in the .hi file at all - it's not an exported function. (I also see quite a bit of code in the hi-dump. Presumably this permits cross-module inlining, for those selected functions?) Alistair

1 0

RE: [Haskell] boilerplate boilerplate
by Simon Peyton-Jones 04 Jun '07

04 Jun '07

[Redirecting to haskell-cafe; the main list is a good place to open discussions but not so good for continuing them] | > derive (Ord,Eq,Read,Show,Typeable) (BlogEntry Name Title Body Emai) | | according to the most recent status report, the syntax is not quite | settled yet, so what is in ghc head might still change. more info here: | | http://haskell.org/haskellwiki/GHC/StandAloneDeriving Indeed... but nothing much is happening at the moment because there's not been much feedback so it's drifted off the radar (so to speak). Refining the wiki and evolving a consensus would be great. Simon

4 10

small hack on hasktags to make it collect class names
by Marc Weber 04 Jun '07

04 Jun '07

You can download the modified version from http://mawercer.de/marcweber/hasktags.hs Marc Weber

2 1

enumFrom* strangeness on GHC?
by Felipe Almeida Lessa 04 Jun '07

04 Jun '07

Hello =), I'm puzzled, and maybe someone can help me out. Why does this happens? $ time ghci -e "last $ take 1000000 $ [1..1000000]" 1000000 real 0m0.673s user 0m0.554s sys 0m0.024s $ time ghci -e "last $ take 1000000 $ [1..]" *** Exception: stack overflow real 0m1.305s user 0m1.057s sys 0m0.062s $ ghci -V The Glorious Glasgow Haskell Compilation System, version 6.6 Looking at http://darcs.haskell.org/ghc-6.6/packages/base/GHC/Enum.lhs , I still have no clue of what may be happening. Any ideas? Should I file a bug on GHC? Thanks, -- Felipe.

4 7

Just for a laugh...
by Andrew Coppin 04 Jun '07

04 Jun '07

If you're bored... can you come up with a solution to this? http://warp.povusers.org/ProgrammingChallenge.html (Obviously a pretty silly challenge, but hey.) My first instinct was to use Data.Bits - but I see no instance for Double. (Presumably because performing bitwise operations on a Double is a pretty odd thing to want to do.) So my next guess is to do some bizzare type system hackery that allows you to transform a Double into... whichever integer type is the same size, and proceed from there. Does anybody know how to do that? (Otherwise... wasn't there some library somewhere for serialising values in binary?)

16 32

Re: I just don't get it (data structures and OO)
by Stefan O'Rear 04 Jun '07

04 Jun '07

(Sorry to break the thread, but mutt somehow managed to eat the message I'm replying to...) Arie Peterson: > You could also use 'compositional functional references'. These are > introduced in the paper "A Functional Programming Technique for Forms in > Graphical User Interfaces" by Sander Evers, Peter Achten and Jan Kuper. > > === Introduction === > > There are two things one typically wants to do when working with a > substructure of some larger data structure: (1) extract the substructure; > and (2) change the larger structure by acting on the substructure. A 'Ref > cx t' encodes both of these functions (for a substructure of type 't' and > larger structure (context) of type 'cx'). > > > data Ref cx t > > = Ref > > { > > select :: cx -> t > > , update :: (t -> t) -> cx -> cx > > } ... > I've written a template haskell function to derive Refs from a data > structure definition (with record syntax): given I've implemented this in Derive[1] in 12 minutes, counting the time required to re-familiarize with the code. The patch is at [2] and has also been darcs sent. [1] http://www-users.cs.york.ac.uk/~ndm/derive [2] http://members.cox.net/stefanor/derive-Ref-patch Stefan

3 3

happs tutorial
by Anatoly Yakovenko 04 Jun '07

04 Jun '07

can someone help me get the first part of the tutorial working with happs 0.8.8 http://happs.org/HAppS/doc/tutorial.html this part at least : module Main where import HAppS import Control.Monad.State data MyState = MyState String deriving (Read, Show) instance StartState MyState where startStateM = return $ MyState "Hello World!" instance Serialize MyState where typeString _ = "MyState" encodeStringM = defaultEncodeStringM decodeStringM = defaultDecodeStringM app :: Method -> Host -> [String] -> Ev MyState Request Result app _ _ _ = do MyState message <- get sresult 200 message main = stdMain $ simpleHTTP "" [] app :*: End I am having a hard time getting everything to compile. Also, why is > :t HAppS.simpleHTTP HAppS.simpleHTTP :: forall st. [ServerPart (Ev st Request) Request IO Result] -> Conf -> Handler st but the type in this http://happs.org/auto/apidoc/HAppS-Protocols-SimpleHTTP.html#v%3AsimpleFile… docs is simpleHTTP :: XSLPath -> [(String, String)] -> (Method -> Host -> [String] -> Ev st Request Result) -> Conf -> Handler st

11 18

Re: [Haskell-cafe] Implementing Mathematica
by Chaddaï Fouché 03 Jun '07

03 Jun '07

---------- Forwarded message ---------- From: Chaddaï Fouché <chaddai.fouche(a)gmail.com> Date: 2 juin 2007 00:00 Subject: Re: [Haskell-cafe] Implementing Mathematica To: Andrew Coppin <andrewcoppin(a)btinternet.com> 2007/6/1, Andrew Coppin <andrewcoppin(a)btinternet.com>: > I looked, I didn't find anything interesting. Well maybe you should look one more time with your brain on... Your claim that : > Last I heard, Maple is simply another fast number-chrunking engine. Show that you never even bothered to read the feature list of the software ! http://www.maplesoft.com/products/Maple11/academic/index.aspx?D=3040 I tried both Mathematica and Maple and while I'll be the first to admit the Mathematica interface was more attractive, it's the only obvious point I concede to it (and my version of Maple was quite old so this might not even be true anymore). As others who knows the subject have said, Mathematica and Maple are quite close and outperforms each other regularly in their fields of excellence. -- Jedaï

5 4

New (?) Partial Monad
by Christopher Lane Hinson 03 Jun '07

03 Jun '07

Some time ago I noticed that a function I was writing had the exact type as liftM2, and I so I ended up generalizing a monad. I thought I should document it really well, and the result is this: http://www.downstairspeople.org/darcs/partial/Partial.pdf $ darcs get http://www.downstairspeople.org/darcs/partial I would appreciate any feedback. Is this even original? --Lane

2 2

OpenGL
by Jon Harrop 02 Jun '07

02 Jun '07

I've found HOpenGL and the Debian package libghc6-opengl-dev. The former seems to be very out of date (last release 2003) but I can't find any demos for the latter. Where should I go to get started with OpenGL and Haskell? -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. OCaml for Scientists http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

8 10

Resolved: [Haskell-cafe] ffi linking problem
by jeff p 02 Jun '07

02 Jun '07

Hello, In case anyone else finds this useful... My linking problem was finally resolved by using the -fvia-C flag when compiling with ghc. Thanks to Stefan O'Rear who pointed out the possibility and wrote: > > Does using -fvia-C help at all? The C compiler understands header > files and is sometimes better equipped to resolve things. > regards, Jeff

3 5

how do I pass customization items in syb code?
by Alex Jacobson 01 Jun '07

01 Jun '07

I'm looking at the XML SYB example http://www.cs.vu.nl/boilerplate/testsuite/xmlish/Main.hs I'd like to find a way to pass other type customizations as arguments to data2content and content2data. I modified data2Content as follows: data2content f = element `ext1Q` list `extQ` string `extQ` f But I can't figure out how to give f a type such that (data2Content $ myFooElem `extQ` myBarElem) operates on both Foo and Bar elements. Right now I am giving f the type f::(a->[Content]) which compiles but causes the wrong behavior. Any recommendations on how to fix this? -Alex-

1 0

Haskell Quiry
by ashutosh dimri 01 Jun '07

01 Jun '07

I want to read some data from a file "Signature.ken" , for that I have written a program but its showing some errors (the file "signature.ken" contains data of the type = (122,152) ) main = do j <- readFile "sig1.key" let (x,y) = (read j) putStrLn ("value=" ++ (show (x,y))) ERROR file:.\-as.hs:5 - Unresolved top-level overloading *** Binding : main *** Outstanding context : (Read c, Read b, Show c, Show b)

2 1

Has anyone looked into adding subtyping to Haskell?
by Al Falloon 01 Jun '07

01 Jun '07

OCaml has been getting a lot of mileage from its polymorphic variants (which allow structural subtyping on sum types) especially on problems relating to AST transformations and the infamous "expression problem". Has there been any work on extending Haskell's type system with structural subtyping? What is the canonical solution to the expression problem in Haskell? What techniques do Haskellers use to simulate subtyping where it is appropriate? I bring this up because I have been working on a Scheme compiler in Haskell for fun, and something like polymorphic variants would be quite convinent to allow you to specify versions of the AST (input ast, after closure conversion, after CPS transform, etc.), but allow you to write functions that work generically over all the ASTs (getting the free vars, pretty printing, etc.). -- Alan Falloon

9 14

Crazy idea: overloading function application notation
by Jon Harrop 01 Jun '07

01 Jun '07

This is a crazy idea I've been working on: overload the syntax "x y" so it can mean function application "f x = f(x)" or multiplication "x y = x*y". The reason is simply that I appreciate the brevity of MLs function application but I also appreciate the brevity of Mathematica's multiplication. Is it possible to implement this in Haskell using type classes? Is there any way this could actually be practicable? -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. OCaml for Scientists http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

7 7

Re: Monads and constraint satisfaction problems (CSP)
by Greg Meredith 01 Jun '07

01 Jun '07

Brandon, Jeremy, et al, Thanks for the pointers. The paper by OlegK, et al, articulates exactly the structure i was noticing, except that i was coming at it from the other end. i was noticing that a wide range of these CSP-style problems could be decomposed into a trivial monad (e.g., list, multiset, set) and some additional search machinery (over which a good solution should be parametric). They show how to add a reasonable upper limit on the search machinery to any monad. Best wishes, --greg Date: Thu, 31 May 2007 11:36:55 -0700 > From: "Jeremy Shaw" <jeremy.shaw(a)linspireinc.com> > Subject: Re: [Haskell-cafe] Monads and constraint satisfaction > problems (CSP) > To: "Greg Meredith" <lgreg.meredith(a)biosimilarity.com> > Cc: haskell-cafe <haskell-cafe(a)haskell.org> > Message-ID: <ejkwj0vs.wl%25jeremy.shaw(a)linspireinc.com> > Content-Type: text/plain; charset=US-ASCII > > At Thu, 31 May 2007 10:42:57 -0700, > Greg Meredith wrote: > > > BTW, i think this could have a lot of bang-for-buck because the > literature i > > read exhibited two basic features: > > > > - the "standard" treatments (even by CS-types) are decidedly not > > compositional > > - the people in the field who face industrial strength csp problems > > report that they have to take compositional approaches because the > problems > > are just too large otherwise (both from a human engineering problem > as well > > as a computational complexity problem) > > This paper describes a non-monadic, compositional method for solving CSPs: > > > http://www.cse.ogi.edu/PacSoft/publications/2001/modular_lazy_search_jfp.pdf > > There is also the LogicT monad transformer: > > http://okmij.org/ftp/Computation/monads.html > > j. > -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

1 0

New book: Real-World Haskell!
by dons＠cse.unsw.edu.au 01 Jun '07

01 Jun '07

Bryan O'Sullivan, Don Stewart and John Goerzen are pleased, and frankly, very excited to announce that were developing a new book for O'Reilly, on practical Haskell programming. The working title is Real-World Haskell. The plan is to cover the major techniques used to write serious, real-world Haskell code, so that programmers can just get to work in the language. By the end of the book readers should be able to write real libraries and applications in Haskell, and be able to: * design data structures * know how to write, and when to use, monads and monad transformers * use Haskells concurrency and parallelism abstractions * be able to write parsers for custom formats in Parsec. * be able to do IO and binary IO of all forms * be able to bind Haskell to foreign functions in C * be able to do database, network and gui programming * know how to do exception and error handling in Haskell * have a good knowledge of the core libraries * be able to use the type system to track and prevent errors * take advantage of tools like QuickCheck, Cabal and Haddock * understand advanced parts of the language, such as GADTs and MPTCs. That is, you should be able to just write Haskell! The existing handful of books about Haskell are all aimed at teaching programming to early undergraduate audiences, so they are ill-suited to people who already know how to code. And while theres a huge body of introductory material available on the web, you have to be both tremendously motivated and skilled to find the good stuff and apply it to your own learning needs. The time has come for the advanced, practical Haskell book. Heres the proposed chapter outline: 1. Why functional programming? Why Haskell? 2. Getting started: compiler, interpreter, values, simple functions, and types 3. Syntax, type system basics, type class basics 4. Write a real library: the rope data structure, cabal, building projects 5. Typeclasses and their use 6. Bringing it all together: file name matching and regular expressions 7. All about I/O 8. I/O case study: a DSL for searching the filesystem 9. Code case study: barcode recognition 10. Testing the Haskell way: QuickCheck 11. Handling binary files and formats 12. Designing and using data structures 13. Monads 14. Monad case study: refactoring the filesystem seacher 15. Monad transformers 16. Using parsec: parsing a bioinformatics format 17. Interfacing with C: the FFI 18. Error handling 19. Haskell for systems programming 20. Talking to databases: Data.Typeable 21. Web client programming: client/server networking 22. GUI programming: gtk2hs 23. Data mining and web applications 24. Basics of concurrent and parallel Haskell 25. Advanced concurrent and parallel programming 26. Concurrency case study: a lockless database with STM 27. Performance and efficiency: profiling 28. Advanced Haskell: MPTCs, TH, strong typing, GADTs 29. Appendices We're seeking technical reviewers from both inside and outside the Haskell community, to help review and improve the content, with the intent that this text will become the standard reference for those seeking to learn serious Haskell. If you'd like to be a reviewer, please drop us a line at book-review-interest(a)realworldhaskell.org, and let us know a little about your background and areas of interest. Finally, a very exciting aspect of this project is that O'Reilly has agreed to publish chapters online, under a Creative Commons License! Well be publishing chapters incrementally, and seeking feedback from our reviewers and readers as we go. You can find more details and updates at the following locations: * The web site, http://www.realworldhaskell.org/blog/welcome/ * The authors, http://www.realworldhaskell.org/blog/about/ * The blog, http://www.realworldhaskell.org/blog/ -- Bryan O'Sullivan, Don Stewart and John Goerzen.

36 51

Frisby grammars that have context
by Mark.Carroll＠Aetion.com 01 Jun '07

01 Jun '07

I've been playing with Text.Parsers.Frisby to see how it stacks against other options and, while it's been great so far, I am finding that I can't encode a grammar where what's acceptable depends on what's already been parsed in some nontrivial way. To take a simple example, imagine a grammar where the only lower-case letters that are acceptable are those where their upper-case equivalent occurred earlier in the text. In Parsec I'd code this sort of thing as, nextChar = do allowed <- getState char <- oneOf $ ['A'..'Z'] ++ allowed updateState (union [toLower char]) return char test = runParser (many1 nextChar) [] "" Is this supposed to not be possible in Frisby, or (quite likely) am I missing something that allows me to? I've thought about things like trying to fmap further calls to apply runPeg to rest, but I've not figured out a trick that will actually work. -- Mark

6 11

Monads and constraint satisfaction problems (CSP)
by Greg Meredith 01 Jun '07

01 Jun '07

All, All this talk about Mathematica and a reference to monadic treatments of backtracking reminded me that a year ago i was involved in work on a Mathematica-like widget. At the time i noticed that a good deal of the structure underlying LP, SAT and other solvers was terribly reminiscent of comprehension-style monadic structure. i think i asked Erik Meijer if he knew of any work done on this and posted to LtU, but nobody seemed to have understood what i was mumbling about. So, let me try here: does anybody know of references for a monadic treatment of constraint satisfaction? BTW, i think this could have a lot of bang-for-buck because the literature i read exhibited two basic features: - the "standard" treatments (even by CS-types) are decidedly not compositional - the people in the field who face industrial strength csp problems report that they have to take compositional approaches because the problems are just too large otherwise (both from a human engineering problem as well as a computational complexity problem) Best wishes, --greg -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

3 3

Parse error on input "|"
by Akijmo 01 Jun '07

01 Jun '07

Hi everyone. I am new to this Forum, Haskell and i am german, so i am sorry for "noob" failures or spelling mistakes. I am currently learning for an informatic exam (11th class) and i tried to code a function to sum a polynom with a pair of polynoms... (I actually want to to code a polynomdivision in which i need this) But I get the parse error mentioned in the headline. It is referring to the first line of the case differentiation. Hopefully you can help me, here's the code: polyplusd :: Polynom -> (Polynom, Polynom) -> Polynom polyplusd [] p = p polyplusd p [] = p polyplusd p@((g1,e1):p1) (n, (q@((g2,e2):p2)) | g1>g2 = (g1,e1):(polyplusd p1 (n,q)) | g2>g1 = (g2,e2):(polyplusd p (n,p2)) | g1==g2 && e1+e2 /=0 =(g1, e1+e2):(polyplusd p1 (n,p2)) | otherwise = polyplusd p1 (n,p2) -- View this message in context: http://www.nabble.com/Parse-error-on-input-%22%7C%22-tf3847082.html#a108958… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 3

Network.HTTP+ByteStrings Interface--Or: How to shepherd handles and go with the flow at the same time?
by Thomas Schilling 01 Jun '07

01 Jun '07

Hello Cafe! I'd greatly appreciate any ideas/comments on the design of the interface to the Network.HTTP library with a LazyByteString (LBS) backend. As has been discussed previously on this list [1] lazy evaluation can complicate resource management, which is especially critical if resources are seriously limited--in this case network sockets and/or file handles. In [2] Oleg shows how we can use left folds as a general mechanism to traverse collections and shows that this is superior to cursors, generators or streams. I agree with his arguments, however, I still don't see that this can be a good interface for the http library. For a start, what should the collection type be? Word8, Char8, (strict) ByteString (BS)? Unless we get some kind of fusion for the first two we're pretty much stuck with the latter. The interface could look like this (untested): import Data.ByteString (ByteString) -- i.e., strict BSs import qualified Data.ByteString as BS handleRequest :: MonadIO m => Request -> a -> (ByteString -> a -> m (Either a a)) -> m a Ignoring error handling for now, this might be implemented as: handleRequest req seed processor = do a <- iter seed bodySize closeConnection req return a where iter seed 0 = return seed iter seed n = do let c = min chunkSize n bs <- liftIO $ readBlock req c -- calls BS.hGet handle c next <- processor bs seed case next of Left rslt -> return rslt Right seed' -> iter seed' (n-c) -- insert catchError stuff here (requires signature change, of course) This should work fine and if the 'processor' function does not hold on to the chunk would run in constant space. Unfortunately, this has a big disadvantage. Most operations on the returned data will probably be stream-like functions, such as parsing the data into some kind of tree. [2] shows a method how to convert enumerators to streams, but the used stream type data MyStream m a = MyNil (Maybe a) | MyCons a (m (MyStream m a)) is incompatible with [a] which is used by lazy ByteStrings due to the embedding of m. I also don't know if fusion can work on monads. My current suggestion would therefore be a less "save"[*] solution (again, untested and modulo error handling). -- | Execute the request and call @f@ with the returned response body. -- The socket will be closed immediately after @f@ terminates. You must therefore -- make sure that any data you might want to returned has to be forced, e.g. using -- (length . take) lbs withRequest :: MonadIO => Request -> a -> (LazyByteString -> a -> m a) -> m a The implementation would lazily read the contents (implemented as described in [3]) and forcing it would be left to the function parameter. E.g. getHTML :: String -> IO HTMLParseTree getHTML addr = do r <- mkRequest addr tree <- withRequest r emptyTree parseHTML seq tree $ return tree -- ! (I'm afraid this is necessary) tricky :: LazyByteString -> String -> IO LazyByteString -- result will not really be lazy trickyt str addr = do r <- mkRequest addr withRequest r L.empty dropNTake -- we might have to force the result here where dropNTake s _ = L.take 100000 . L.drop 100000 If these 'seq's are really necessary, then this would be a pretty hard to use interface. So, any ideas / suggestions ? / Thomas [*] .. "save" in the sense that it does not enforce certain behavior by means of the type signature or API design. [1] .. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/20528/focus=20635 [2] .. http://okmij.org/ftp/papers/LL3-collections-enumerators.txt [3] .. http://nominolo.blogspot.com/2007/05/networkhttp-bytestrings.html -- "Remember! Everytime you say 'Web 2.0' God kills a startup!" - userfriendly.org, Jul 31, 2006

7 8

Re: [Haskell-cafe] Has anyone looked into adding subtyping to Haskell?
by Al Falloon 01 Jun '07

01 Jun '07

Mark T.B. Carroll wrote: > I don't know what the infamous "expression problem" is, nor am I > familiar with polymorphic variants or structural subtyping, but have you > looked at the Data.Generics.* stuff and Scrap Your Boilerplate papers? > They may be relevant. > The expression problem is "a new name for an old problem", basically being able to extend a data type and functions over the data type in seperate modules with no knowledge of each other. Here is a link to (I think) the original description: http://www.daimi.au.dk/~madst/tool/papers/expression.txt Structural subtyping is something like "duck typing" in dynamic languages, but checked at compile time. For records, it means that if you only access two labels then the function will work on any record that has those labels with those types, even if it may have more labels. For variants (or sum-types, or tagged unions, or whatever they are called in Haskell) it means that if your function can handle certain cases, then it can also handle values that range over less cases. So in pseudo-Haskell with imaginary subtyping: data Vertical a = U a | D a data Horizontal a = L a | R a data Direction a = #Vertical a | #Horizontal a -- borrowing ocaml syntax: this means that Direction shares constructors with Vertical and Horizontal getData :: Direction a -> a getData (U a) = a getData (D a) = a getData (L a) = a getData (R a) = a getLeftStick :: IO (Vertical Int) getRightStick :: IO (Horizontal Int) main = do { accel <- getLeftStick; print (getData accel) } So getData doesn't care that accel is Horizontal and not Direction because Horizontal is a sub-type of direction. Of course, in this syntax since you named the subtyping relationship its more technically nominal subtyping (like in traditional static OO languages) not structural subtyping (which figures out the subtype relationship from the structure automatically, so if we just reused the U,D,L, and R constructors in Direction). I have looked into SYB briefly. I will probably end up using it to keep the amount of code to a minimum, but it won't save me from having to define a different data type for each version of the AST if I want to preserve type safety.

1 0

equations and patterns
by mingli yuan 31 May '07

31 May '07

Hi, buddies. I am a newbie on Haskell. Recently I want to implement a simple Lattice in Haskell, but I met some difficulties. Scrap of the code is as below, but I met syntax error: > class Lattice e where > join :: e -> e -> e > meet :: e -> e -> e > > -- associative law > join x (join y z) = join (join x y) z > join (join x y) z = join x (join y z) The main problem is that mathematic equations is bi-directed, but in Haskell the pattern matching is only in one direction - from left to right. And only variables and constructors could be occur in the right side of the pattern matching. Seems mathematic axioms and pattern matching are different things. So how could I rewrite the equations to pattern matching? Which technique should I learn? Thanks for your help. Regards, Mingli

6 7

Building error Gtk2Hs under GHC 6.6.1 on Solaris 10 x86
by lebed 31 May '07

31 May '07

Hi, haskell-caffe! I'm trying to build Gtk2Hs 0.9.11 under GHC 6.6.1 on Solaris 10 x86: ./configure --with-hcflags=-O0 --disable-split-objs OK! gmake ........................ ........................ ........................ if test -f glib/libHSglib_a.deps; then touch glib/libHSglib_a.deps; else touch glib/libHSglib_a.deps; gmake glib/System/Glib/FFI.hs glib/System/Glib/UTFString.hs glib/System/Glib/Types.hs glib/System/Glib/GType.hs glib/System/Glib/GValue.hs glib/System/Glib/GValueTypes.hs glib/System/Glib/GObject.hs glib/System/Glib/Properties.hs glib/System/Glib/GError.hs glib/System/Glib/GList.hs glib/System/Glib/Signals.hs glib/System/Glib/MainLoop.hs glib/System/Glib/GTypeConstants.hs glib/System/Glib/GParameter.hs glib/System/Glib/StoreValue.hs glib/System/Glib.hs glib/System/Glib/Attributes.hs glib/System/Glib/Flags.hs; /usr/local/bin/ghc -M -optdep-f -optdepglib/libHSglib_a.deps -fglasgow-exts -O0 -fffi -iglib -package-conf package.conf.inplace -hide-all-packages -ignore-package glib -package base -package haskell98 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include glib/System/Glib/FFI.hs glib/System/Glib/UTFString.hs glib/System/Glib/Types.hs glib/System/Glib/GType.hs glib/System/Glib/GValue.hs glib/System/Glib/GValueTypes.hs glib/System/Glib/GObject.hs glib/System/Glib/Properties.hs glib/System/Glib/GError.hs glib/System/Glib/GList.hs glib/System/Glib/Signals.hs glib/System/Glib/MainLoop.hs glib/System/Glib/GTypeConstants.hs glib/System/Glib/GParameter.hs glib/System/Glib/StoreValue.hs glib/System/Glib.hs glib/System/Glib/Attributes.hs glib/System/Glib/Flags.hs; fi; gmake[1]: Entering directory `/usr/export/home/lebed/tmp/gtk2hs-0.9.11' ./mk/chsDepend -iglib:gtk:sourceview sourceview/Graphics/UI/Gtk/SourceView/Types.chs could not find {#import.chs on search path glib gtk sourceview gmake[1]: *** [sourceview/Graphics/UI/Gtk/SourceView/Types.dep] Error 1 gmake[1]: Leaving directory `/usr/export/home/lebed/tmp/gtk2hs-0.9.11' <no location info>: can't find file: glib/System/Glib/FFI.hs gmake: *** [glib/libHSglib_a.deps] Error 1 gmake: *** Deleting file `glib/libHSglib_a.deps' Where is my mistake? (I've got the same error under GHC 6.6 on Solaris 10 sparc.) -- View this message in context: http://www.nabble.com/Building-error-Gtk2Hs-under-GHC-6.6.1-on-Solaris-10-x… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 3

updating packages
by jeff p 31 May '07

31 May '07

Hello, I just moved to ghc-6.6.1and was wondering if there is an automatic way to update the various packages I had installed previously. thanks, jeff

2 1

ANNOUNCE: xmonad 0.2
by Spencer Janssen 31 May '07

31 May '07

The xmonad dev team is pleased to announce the 0.2 release of: xmonad: a tiling window manager http://xmonad.org About: Xmonad is a tiling window manager for X. Windows are arranged automatically to tile the screen without gaps or overlap, maximising screen use. All features of the window manager are accessible from the keyboard: a mouse is strictly optional, greatly increasing productivity in X. Xmonad is written and extensible in Haskell, and custom layout algorithms, and other extesions, may be implemented by the user in config files. Layouts may be applied dynamically, and separate layouts can be used on each workspace. A guiding principle of the user interface is predictability: users should know in advance precisely the window arrangement that will result from any action, leading to an intuitive user interface. Features: * Automatic window tiling and management * First class keyboard support: a mouse is unnecessary * Full multihead/Xinerama support * XRandR support to rotate, add or remove monitors * Per-workspace layout algorithms * Per-screen non-built in status bars, with arbitrary geometry * Dynamic restart/reconfigure preserving workspace state * Tiny code base (~500 lines of Haskell) * Fast, small and simple. No interpreters, no heavy extension languages Since 0.1, the following notable features and bug fixes have appeared: New features: * XRandR support, for dynamically adding, removing or rotating monitors * State-preserving dynamic restart * Popup, customisable status bar support * Multiple clients may appear in the master pane * mod-shift-j/k, to swap windows with their neighbours * mod-n, to resize windows * User-specified layout algorithms may be written in config files * All layouts may be 'mirrored' (rotated) * configurable window border size and colour Design changes: * Reimplemented core of xmonad with a 'zipper' data type to track focus by construction. We believe this is a first. * Use of Neil Mitchell's 'catch' program to verify pattern match safety * Use of ReaderT and StateT to partition read-only and modifiable values * Custom layout messages handled with open data type simulation * More QuickCheck properties Bug fixes: * numlock handling is fixed More information, screenshots, documentation and community resources are available from: http://xmonad.org Xmonad is available from hackage, and via darcs. Happy hacking! The Xmonad Team: Spencer Janssen Don Stewart Jason Creighton Xmonad has also received patches from: Alec Berryman Chris Mears Daniel Wagner David Glasser David Lazar David Roundy Joe Thornber Miikka Koskinen Neil Mitchell Nick Burlett Robert Marlow Sam Hughes Shae Erisson

1 0

Distributing a program with support files
by Neil Mitchell 31 May '07

31 May '07

Hi, I'm wanting to release a Haskell program, but am confused how I should distribute the associated files it needs. On Windows I would use the functions to find the path of the executable, and find the support files relative to that - in Haskell (because of Linux) that isn't the case. The basic setup I have is: foo.exe - main binary library.hs - required by the binary examples\*.hs - a massive tree of examples, which can be used by the binary foo.exe also needs to create temporary files relative to library.hs and the examples. Thanks Neil

5 8

Re: [Haskell] ST vs State
by Bulat Ziganshin 31 May '07

31 May '07

Hello Federico, Wednesday, May 30, 2007, 12:54:35 PM, you wrote: > Control.Monad.ST > And > Control.Monad.State ST monad is just reduced IO monad which like IO organizes sequential (imperative) ordr of execution but unlike IO supports only a small closed set of operations - those working with STRef and STArray State monad provides just two operations - get and put, which provides access to some "monad state". unlike ST/IO monads operations in State monad (and all other monads) can be performed in any order as typical for lazy computations. of course, there are guarantees that put operation will be performed before get that reads appropriate state you may be interested looking at http://haskell.org/haskellwiki/IO_inside although it doesn't say about ST/State monads directly (btw, there is also Lazy.ST monad but it is not used too much :) -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0

Re: [Haskell-cafe] The C Equiv of != in Haskell (Apologies)
by PR Stanley 31 May '07

31 May '07

>>However, I don't think these other individuals had any business >>poking their hooters into this. > >If you don't want other individuals "poking their hooters" in what you >write, I recommend you to avoid sending open questions to public >mailing lists. yes, I was indeed referring to you and your large beak over which you clearly have no control. Nobody invited you to this discussion and as you can see I have already apologized to Neil for the misunderstanding. Yet, you seem to be desperate to keep the thread alive. Uh, save me from the ...

13 21

Data.Generics
by mark＠ixod.org 30 May '07

30 May '07

Do we have a simple example somewhere of how to use gzipWithQ ? I can get things like everything and everywhere working with mkQ and mkT, but I can't work out how to make a curried query thing for gzipWithQ - I'm sure I'm missing the obvious. -- Mark

1 0

Efficiency question
by Evil Bro 30 May '07

30 May '07

I'm pretty new to Haskell, so forgive me if my question is due to my non-functional way of thinking... I have the following code: module Main where main = print solution solution = solve 1000000 solve d = countUniqueFractions d 2 1 0 canBeSimplified (a,b) = gcd a b > 1 countUniqueFractions stopD currentD currentN count | currentD > stopD = count | currentN == currentD = countUniqueFractions stopD (currentD + 1) 1 count | canBeSimplified (currentN, currentD) = countUniqueFractions stopD currentD (currentN+1) count | otherwise = countUniqueFractions stopD currentD (currentN+1) (count + 1) When I run this code, I get a stack overflow. I don't understand why. Could anyone explain please? -- View this message in context: http://www.nabble.com/Efficiency-question-tf3823154.html#a10823572 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

4 4

System.Timeout problems
by Neil Mitchell 30 May '07

30 May '07

Hi I'm using the System.Timeout module from base, copied into my local repo, so that I can work with GHC 6.6.1. My copy is at: http://www.cs.york.ac.uk/fp/darcs/catch/catch_1/System/TimeoutGHC.hs (but it is identical to the one in base) Sadly, it doesn't seem to work for me. Here are the tests I've been using, the results I get, and what I would have liked. All are GHC 6.6 on Windows. -- TEST 1 import System.TimeoutGHC main :: IO () main = do r <- timeout (5 * 10^6) (putStrLn "here") print r Without -threaded: here >> Just () >> wait 5 seconds Without -threaded: here >> wait 5 seconds >> Just () So, either way, I get a 5 second delay - not something I want. -- TEST 2 import System.TimeoutGHC main :: IO () main = do r <- timeout (length [1..]) (putStrLn "here") print r Now, with either -threaded, or without, it never terminates. Basically I can't get the timeout to do anything I would like with any flags. Can someone come to my rescue? Am I getting timeout wrong? Thanks Neil

3 3

Shared libraries in GHC
by Georg Sauthoff 30 May '07

30 May '07

Hi, while searching, if ghc can create packages as shared libraries I found a ticket with a kind of non-accepted status: http://hackage.haskell.org/trac/summer-of-code/ticket/46 But at the google SoC page it looks like an accepted project: http://code.google.com/soc/haskell/appinfo.html?csaid=D0137F8B637176F1 Well what is the status of the project? Does the student have a blog/webpage where one can track the progress of the project? Btw, the problem I want to solve with shared libraries is the case, where I want to program 2 frontends (==2 executables), which share a lot of Haskell-Code. I am afraid, if both frontends are linked statically, the result will look a bit 'bloated' ... Best regards Georg Sauthoff

4 3

Is there a Template lib like Cheetah in python?
by Albert Lee 30 May '07

30 May '07

I am writing some webpage using haskell, I know Xhtml, but I also need some other persons to write simple htmls so I need a template system like cheetah in python, but I didn't find anything through google. any help? -- http://www.kamang.net

2 1

ffi linking problem
by jeff p 30 May '07

30 May '07

Hello, Can anyone give me some tips concerning the following error: myPrompt> ghc --make -fffi f.hs -l mylib.lib ghc --make -fffi f.hs -l mylib.lib [1 of 1] Compiling Main ( f.hs, f.o ) Linking f.exe ... d:\ghc\ghc6.6\gcc-lib\ld.exe: cannot find -l-Ld:/ghc/ghc6.6 collect2: ld returned 1 exit status thanks, Jeff

3 9

Coding Standards (Coding Conventions)
by Philipp Volgger 30 May '07

30 May '07

I wonder if there are any Coding Standards or Coding Conventions for Haskell. Does anybody know something about it? Kind regards, Philipp Volgger

5 5

Help with terminal IO
by Ryan Ingram 30 May '07

30 May '07

I was hoping that hSetBuffering would turn off the line buffering for stdin, but it doesn't seem to work. ---- module Main where import System.IO main :: IO () main = do hSetBuffering stdin NoBuffering hSetBuffering stdout NoBuffering hPutChar stdout '>' c <- hGetChar stdin hPutChar stdout '<' ---- This program should terminate immediately after the first character is typed into the terminal, but it waits until I type a newline. It also looks like it's using GNU readline (it handles the up & down arrow keys.) How do I turn this off and use raw character-based IO? I'm using GHC6.6 on Win32 if that makes a difference. -- ryan

2 1

teaming up for the IFCP contest
by Tim Docker 30 May '07

30 May '07

I've put aside the weekend of July 20-23 for the ICFP contest (http:// www.icfpcontest.org/) and am looking to form or join a haskell wielding team. Any interest? Geographically I'm in Sydney, but have entered in a previous year with a team of 3 from around the globe which worked fine. Tim

1 0

Control.Monad.State.Strict, mdo and let
by Gracjan Polak 30 May '07

30 May '07

Hi, I stumbled at some interaction of Control.Monad.State.Strict, mdo and let I do not understand. The following program: {-# OPTIONS_GHC -fglasgow-exts #-} module Main where import Control.Monad.State.Strict thenumber :: Float thenumber = flip execState 1.3 $ mdo c <- donothing [] let donothing x = return x return () main = print thenumber Says (in GHC 6.6.1): Stack space overflow: current size 8388608 bytes. Use `+RTS -Ksize' to increase it. Why is this so? -- Gracjan

2 1

shared oneShot IO (was top-level state proposals)
by Claus Reinke 30 May '07

30 May '07

i thought the discussion had actually progressed a little further than might be obvious from http://www.haskell.org/haskellwiki/Top_level_mutable_state here is my summary of what i thought was the state of the discussion, followed by a hopefully simpler proposal. first, i'd like to distinguish between two aspects of the problem: (a) shared identifiers (b) shared initialisation by (a), i mean identifiers shared between several functions, referring to the same item, such as 'System.IO.stdin' referring to _the_ standard input handle. by (b), i mean initialisation code that needs to be run once before a set of functions may be used, such as 'Network.Socket.withSocketsDo'. second, note that neither (a) nor (b) represents a problem for non-IO code: let-binding takes care of (a) and (b). the problem arises when (a) and (b) are combined with IO-based code, in particular, if the shared identifiers of (a) stand for IO-based items, such as IO-based initialisation in (b). the source of trouble lies in the interaction of let-bindings with IO-based code. we know how to share descriptions of IO actions: let a = putStr "hi ho" -- 1 in a >> a we also know how share the results of IO actions: do r <- getLine -- 2 return (r,r) in (1), the action description is shared, but the action itself is executed, possibly repeatedly, after substitution, in (2), the action is executed before substitution and before continuation (through monadic bind), and its result is shared. what we do not know is how to share IO actions themselves in a demand-driven way, ie how to describe an IO action that is executed at most once, only on demand, with shared result. i thought this had become clear through Adrian's oneShot examples, but it seems to be mentioned only as a sideline on the Top_level_mutable_state page. if we had the ability to specify shared IO actions, this would directly address the issue of (a) in the case of IO-based things, and that IO-based (a) could then be used to make IO-based (b) more convenient. aside: even IO-based (b) is not in itself impossible, it is just inconvenient and error-prone. a module could provide an initialisation action and require that to be executed before any of its other actions may be called. this is inconvenient, especially if initialisation generates results that need to be passed to several other actions, and it is error-prone, because Haskell does not directly support protocol types (guaranteeing that initialisation is always called before any of the other actions, and is only called once). we can address the 'before' typing by having all other actions take a parameter of a type that can only be produced by the initialisation code, but we cannot guarantee that initialisation will be called at most once, without relying on the user, or on a solution to (a). the latter brings us back to the sharing of IO actions. that is exactly what "the unsafePerformIO hack" tries to achieve: myGlobalVar :: IORef Int {-# NOINLINE myGlobalVar #-} myGlobalVar = unsafePerformIO (newIORef 17) we specify an IO action ('newIORef'), we specify a shared name for it ('myGlobalVar'), with a monomorphic type ('IORef Int'), we specify that we do not want the action description to be substituted before execution ('NOINLINE', usually also '-fno-cse'), to avoid the repeated execution shown in (1) above, and we do _not_ specify that the action should be executed before continuation, as it would be in (2) above, by _not_ using monadic bind. what the 'unsafePerformIO' does is to ensure that the action is executed before substitution. taken together, we get a by-need sharing of IO action execution similar to by-need sharing of expression evaluation. the aspects that make this a somewhat brittle and unsafe 'hack' are the use of a pragma to ensure semantics, the use of the 'unsafePerformIO' hook to extend the evaluator, the type that is no longer IO-based (it is 'IORef Int', not 'IO (IORef Int)'), and the implicit constraint to a monomorphic type. quite a complex interaction of features. it is great that these features allow us to experiment with possibilities not originally planned for in language or evaluator. but now that experimentation has settled down to a common pattern of using these extension hooks for a particular class of problems, it seems sensible to integrate that pattern into the language and evaluator proper, addressing the safety issues at the same time. which is what all this discussion has been about. among the approaches suggested, we have seen first-class modules (do the initialisation on import or export, then pass the result to the whole module, rather than to each function in it), top-level "mdo" (collect commuting IO actions, and execute them at a sensible point in time out-of-line), and type-based indexing (use types as shared identifiers). i like first-class modules, but they would be a rather substantial change to Haskell; i almost like the top-level 'mdo', but only if it can be made to behave exactly as a non-top-level 'mdo', something current proposals don't seem to achieve, because it would again require rather substantial changes; i think that type-based indexing is just another workaround, rather than a solution (in particular, types as globally shared identifiers have their own issues; cf the first-class labels proposal for Haskell': http://hackage.haskell.org/trac/haskell-prime/ticket/92 ). the most pragmatic approach seems to be the top-level 'mdo', but it would still be a substantial change in language and implementation, and it introduces a difference between top-level and non-top-level 'mdo' which would complicate the language. but if i'm not mistaken, none of that is necessary - the whole 'mdo' aspect was introduced only as an after-the-fact justification of a special syntax for addressing the shared-IO issue. and the complications arise because that special syntax really has a new semantics, and top-level bindings do not really behave like the 'let . = . ' and '<-' in an 'mdo', even if the former might be translated into the latter. ---------- proposal: introduce support for shared-on-demand IO actions if i try to remove all that 'mdo'-related justification, and focus on the shared-IO issue of the proposal, i end up with something like this (which is implied, but somewhat hidden in Top_level_mutable_state): -- library mkOnceIO :: IO a -> IO (IO a) mkOnceIO io = do mv <- newEmptyMVar demand <- newEmptyMVar forkIO (takeMVar demand >> io >>= putMVar mv) return (tryPutMVar demand () >> readMVar mv) -- usage, desugared {-# OPTIONS_GHC -fno-cse #-} {-# NOINLINE myGlobalVar #-} myGlobalVar :: IO (IORef Int) myGlobalVar = unsafePerformIO (mkOnceIO (newIORef 42)) main = do gv <- myGlobalVar doSomeThing gv and the syntax extension would be something like -- usage, sugared myGlobalVar <= newIORef 42 main = do gv <- myGlobalVar doSomeThing gv where '<=' compares to the existing '<-' and '=' as follows: '<=' vs '=': the binding is shared, but involves an IO action, and shares the IO action itself, not just its description '<=' vs '<-': the binding is monomorphic and involves the result of an IO action, but that action itself wrapped in IO, and is only executed on demand, at most once apart from the IO type, there is nothing global about this, '<=' could be used to specify oneShot actions whereever an IO action is defined. in particular, one could define initialisation actions in a module and import them: module MyIOBase(mkStdIn) where mkStdIn <= initialiseStdIn -- shared IO action, run at most once module MyIO where import MyIOBase(mkStdIn) getLine = do stdin <- mkStdIn hGetLine stdin module Main where import MyIO(getLine) main = getLine >>= ... since the oneShot actions are wrapped in IO, this extension does not allow IO action to be executed in pure code, and possible points of execution are clearly specified in the code, which is safer, but slightly more inconvenient than 'the unsafePerformIO hack', and simpler than the toplevel '<-' plus 'ACIO monad' proposal. since the proposal could be implemented by a local transformation, it should also be easier to realise. okay, now: are there any holes in this proposal?-) claus

2 2

data PLZ a
by dons＠cse.unsw.edu.au 30 May '07

30 May '07

We got the names wrong! data PLZ a = AWSUM_THX a | O_NOES String instance Monad PLZ where return = AWSUM_THX fail = O_NOES O_NOES s >>= _ = O_NOES s AWSUM_THX x >>= f = f x Thanks to mauke on #haskell. -- Don

4 4

Mysterious monads
by Andrew Coppin 30 May '07

30 May '07

Take a look at the following: data Writer o v = Writer [o] v instance Monad (Writer o) where return v = Writer [] v (Writer os v) >>= f = let (Writer os' v') = f v in Writer (os ++ os') v' write :: o -> Writer o () write o = Writer [o] () writes :: [o] -> Writer o () writes os = Writer os () By this code, I define a new monad where I can "write" stuff into a big list. (Although I notice this is going to get slower and slower as the list grows...) For example, test = do write 1 write 2 write 3 yields "Writer [1,2,3] ()". Now, how do I implement the following? data Reader i v = Reader [i] v instance Monad (Reader i) where return = ??? (>>=) = ??? read :: Reader o o such that a Reader is created with an initial list, and the read function fetches 1 element out of that list. That is, the expression "x <- read" will take the head element of the list and put it into x, keeping the tail to be read later. (Oh yeah - and apparently that clashes with Prelude.read. Oh well!) I can't figure out how to implement this... The closest I managed was to make a Reader object also contain a function that tells (>>=) what to do to the Reader object you're binding against... But that seems to be horribly buggy. Any thoughs?

6 12

Re: [Haskell-cafe] Cute code [was: The C Equiv of != in Haskell miscommunication thread]
by Roberto Zunino 30 May '07

30 May '07

(re-joining the list -- I forgot to "reply all") Vincent Kraeutler wrote: > Roberto Zunino wrote: >>Vincent Kraeutler wrote: >>>i see that the definition of fix (from Control.Monad.Fix) could not be >>>any simpler: >>> >>>>fix f = let x = f x in x >> >>I actually consider >> >>fix f = f (fix f) >> >>to be simpler. Alas, it breaks sharing... > > ;-) > sharing? > v. The two functions fix1 f = let x = f x in x fix2 f = f (fix2 f) have the same semantics. However I believe many implementations run them with different performance. Consider y = fix1 (2:) This would be expanded to y = let x = 2:x in x A typical implementation would then represent the infinite list using (roughly) a circular pointer-list, i.e. x = cons(2, pointer-to-x) . So, the tail of the list is shared with the list itself, causing a constant space to be allocated for the list, even if a large portion of the list is demanded as in (take 1000000 y). On the contrary, y = fix2 (2:) would be y = 2 : fix2 (2:) and, unless some optimization magic kicks in, the representation for y is not a circular list. Each time a new list element is demanded, a new cons cell will be allocated. Running (take 1000 y) would then "waste" space for 1000 copies of 2. This is because the tail is not shared. Zun.

1 0

Slower with ByteStrings?
by Jason Dagit 30 May '07

30 May '07

Hello, We recently had a challenge as follows: Given a word, find all the words in the dictionary which can be made from the letters of that word. A letter can be used at most as many times as it appears in the input word. So, "letter" can only match words with 0, 1, or 2 t's in them. I opted for simplicity in my implementation including hard coding the input word and using /usr/share/dict/words as the dictionary: -- Begin Words.hs module Main where import List -- I was lazy and borrowed perms from the Haskell wiki -- but I wrote everything else perms [] = [[]] perms xs = [ x : ps | x <- xs, ps <- perms (xs\\[x]) ] -- creates permutations of all lengths then cleans up duplicates and gets rid of the -- empty list, this is probably the least efficient way possible allPerms x = drop 1 $ sort $ nub $ concatMap inits $ perms x main = do wordList <- readFile "/usr/share/dict/words" let words = lines wordList mapM_ print $ filter (`elem` words) $ allPerms "ubuntu" -- End Words.hs Next I decided to try it with byte stings: -- Begin ByteStringWords.hs module Main where import List -- import qualified Data.ByteString.Char8 as C import qualified Data.ByteString.Lazy.Char8 as C -- I was lazy and borrowed perms from the Haskell wiki -- but I wrote everything else perms [] = [[]] perms xs = [ x : ps | x <- xs, ps <- perms (xs\\[x]) ] -- creates permutations of all lengths then cleans up duplicates and gets rid of the -- empty list, this is probably the least efficient way possible allPerms x = drop 1 $ sort $ nub $ concatMap inits $ perms x main = do wordList <- C.readFile "/usr/share/dict/words" let words = C.lines wordList mapM_ print $ filter (`elem` words) $ map C.pack $ allPerms "ubuntu" -- End ByteStringWords.hs I don't think the overhead to compute the permutations matters here as the input to the permutations calculation is so small. Any ideas why the byte string version is slower? (Strict bytestrings appear to be about 2 seconds slower and lazy bytestrings appear to be about 1 second slower). I think, given my simple algorithm that means that (==) for ByteStrings is slower than (==) for String. Is this possible? I think the program might be spending more time cleaning up after execution with the ByteString versions as it seems to "stall" after printing the last match. Thanks, Jason

6 8

Cabal can't install in home directory
by Grzegorz 29 May '07

29 May '07

Hi, It seems that if GHC is installed non-user-writable directory, and you want to install a package in the home directory (using "runghc Setup configure --prefix=$HOME") this isn't possible: when running "runghc Setup install" you get an error like this: Unable to rename "/usr/lib/ghc-6.6.1/package.conf" to "/usr/lib/ghc-6.6.1/package.conf.old" Saving old package config file... ghc-pkg.bin: /usr/lib/ghc-6.6.1/package.conf: renameFile: permission denied (Permission denied) Shouldn't that be fixed? Best, -- Grzegorz

2 2