- Haskell-Cafe - Haskell.org

Re:Explaining monads
by Gregory Propf 15 Aug '07

15 Aug '07

Sorry to spam you Jeff, again I sent my email to the poster rather than the list. I'm using Yahoo beta webmail and don't see a way to set it to reply to the list rather than the originator. Anyway, this was my post: Hence the need to perform a "run" operation like runIdentity, evalState or runParser (for Parsec) to get something useful to happen. Except for lists we don't seem to do this. I suppose lists are so simple that the operators :, ++ and the [] constructor do all we ever need with them. Finally there is no runIO because "main" is essentially that function in every real program? - Greg ----- Original Message ---- From: Jeff Polakow <jeff.polakow(a)db.com> To: lanny(a)cisco.com Cc: haskell-cafe-bounces(a)haskell.org; Haskell-Cafe <haskell-cafe(a)haskell.org> Sent: Tuesday, August 14, 2007 8:45:06 AM Subject: Re: [Haskell-cafe] Explaining monads One general intuition about monads is that they represent computations rather than simple (already computed) values: Boardwalk for $500? In 2007? Ha! Play Monopoly Here and Now (it's updated for today's economy) at Yahoo! Games. ____________________________________________________________________________________ Sick sense of humor? Visit Yahoo! TV's Comedy with an Edge to see what's on, when. http://tv.yahoo.com/collections/222

3 2

ANNOUNCE: Guihaskell and PropLang 0.1
by Asumu Takikawa 15 Aug '07

15 Aug '07

Hello Haskellers. I'm one of the Google Summer of Code students for '07 and I'd like to announce the project my mentor, Neil Mitchell, and I have been working on. == GuiHaskell Guihaskell is a graphical REPL using PropLang, a GUI combinator library built on top of Gtk2hs, which aims to be an IDE for Haskell written in Haskell. It's still rough around the edges, so think of this as an alpha release. As such, I'd appreciate any feedback very much! Here's a feature list for 0.1: * Support for GHCi (default) and Hugs * Quick switching between compilers * Simple one-click profiling * Command history This first release of Guihaskell is mostly infrastructure. For future releases I aim to integrate more tools like Cabal and make it easier to use with an editor. == PropLang PropLang is a GUI library built on Gtk2hs that allows for high level design. The GUI is expressed as a series of relationships between GUI elements and data sources. Here's a "Hello World" example: import PropLang.Gtk import PropLang.Event main = do initPropLang window <- getWindow "foobar.glade" "wndFoo" let tb = getCtrl window "button" :: ToolButton tb!onClicked += putStrLn "Hello World!" showWindowMain window This example prints "Hello World!" when the user presses a button defined in a Glade file. PropLang is used with glade to define the interface. You can define more complicated relationships using the combinators in PropLang.Variable. Here's a snippet from GuiHaskell: tie (txtSelect!text) filename (\t -> if null t then Nothing else Just t) (maybe "" id) "tie" takes two PropLang variables and relates them so that when one is updated, it will inject its value into another. It also takes two functions to run on the data before injection. This snippet is used to tie the representation of the currently selected file in GuiHaskell (a Maybe String) to Gtk's TextView buffer (a String). If you injected a new value into filename... filename -< Nothing then txtSelect's text buffer would be set to "". You can also build other behaviors into PropLang variables to do interesting things. GuiHaskell has a configuration API built around PropLang. Configuration items are defined as special PropLang variables: filename <- newVarWithName "selected_filename" (newConfValueWithDefault Nothing "selected_filename") "newVarWithName" in PropLang.Variable lets you make new variables with custom actions to retrieve and set values. "newConfValue" is defined in GuiHaskell to serialize configuration items to disk so they can be read back after closing the program. For more information you can generate the Proplang docs with haddock. == Install Get the packages here: http://hackage.haskell.org/packages/archive/GuiHaskell/0.1/GuiHaskell-0.1.t… http://hackage.haskell.org/packages/archive/proplang/0.1/proplang-0.1.tar.gz Install with cabal: runhaskell Setup.lhs configure runhaskell Setup.lhs build runhaskell Setup.lhs install == You can send feedback to my e-mail, the list, or contact me on IRC (I'm Shimei on #haskell). Thanks. Cheers, Asumu Takikawa

3 2

ANN: HAppS-Data 0.9: XML, Pairs, HList, deriveAll
by Alex Jacobson 15 Aug '07

15 Aug '07

We've refactored the happs repos and are now going to releasing components of HAppS as individual useful packages. HAppS-Data is the first one. Don't pull a tag, pull the most recent stuff in the repos. --- HAppS-Data v0.9: XML, Name/Value Pairs, HList, deriveAll * toXml and fromXml transform your haskell values to and from XML. Declare your own instances of class Xml to customize the Xml representation. * toPairs and fromPairs transform haskell values to and from name-value pairs (e.g. for url-encoded data). Pairs are converted between xpath expressions. Use toPairsX if you want a conversion without the top level constructor, fromPairs can handle that as long as your type has only one top level constructor. * toHTMLForms to produce an HTML forms representation of your data that can be consumed by fromPairs in a urldecoding context. toHTMLForms uses toPairsX for shorter input field names. * $(deriveAll) to batch derive Default and as well as the standard derivable without all the boring per data "deriving" declarations * Default missing values by declaring your own instances of class Default or have default values derived autotomatically. * Normalize your values by declaring your own instance of class Normalize. * Type safe easy-to-use heterogenous collections. t1 .&. t2 .&. t3 are a heterogenous lists of values. (HasT hlist t) is a class constraint to that the hlist contains a particular type. (x hlist)::t obtains a value of type t from inside the hlist. (u hlist v) updates the hlist with the value v if the hlist has type. x and u return compile time errors if the type is not inside the hlist. fromPairs is currently broken for hlist. darcs get http://happs.org/HAppS/HAppS-Data

1 0

Monad explanation from a newbie to newbies having C# (or other OO) experience
by Peter Verswyvelen 15 Aug '07

15 Aug '07

See attachment. This is an early draft, but I’m afraid it will just be another tutorial that does not solve anything, so I’ll better throw it in the arena for review right now, so I don't waste more time ;-) The idea of this tutorial is not explaining monads, bet getting to the monad concept step by step, and then finally in the end talking about the real monad abstraction. Note that I’m a self-made man, so much of the terminology and even approach could be wrong (I learned it adhoc). I also hardly have any Haskell experience (maybe 5 full days of writing example code now), but anyway, writing this tutorial was a good exercise. To make things even worse I’m also not a native English speaker, so it will most likely be some kind of Belgian English (without the chocolate) ;) So horror is coming your way! Any feedback is welcome! ☺ Cheers, Peter

1 0

Re: Bathroom reading
by Chad Scherrer 15 Aug '07

15 Aug '07

Maybe something of these? http://www.haskell.org/haskellwiki/Blow_your_mind -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

1 0

Converting Emacs syntax coloured Haskell code to HTML
by Peter Verswyvelen 14 Aug '07

14 Aug '07

I noticed many code snippets on the wiki that have syntax colouring. How is this done? Can I convert syntax coloured code from Emacs to HTML? I'm using the Haskell mode for Emacs to get the syntax colouring. I'm writing a "monads for C# programmers tutorial" (oh nooooooooo) and would like to use this feature. Of course I won't publish this tutorial before sending it to this mailing list, because when a newbie writes a tutorial, it is usually a disaster ;-) But the feedback I get from this community is super handy (that is when it is not PhD talk which I don't understand ;), so I guess comments on this tutorial will give me a better understanding. Thanks, Peter

3 2

Explaining monads
by Brian Brunswick 14 Aug '07

14 Aug '07

(Better view the below in a fixed-width font!) With all the recent monad discussions, I embarked on trying to clarify my own thoughts about them, and started to think about things in terms of just /where/ extra structure is 'understood'. I think I can explain why 'a->IO b' is better than 'IO a->b'. The full title of this is really 'Explaining monads by comparison with comonads and arrows', but I didn't want to scare people off without putting in the above hook! We start with a simple single value of type 'a', and then we move into some other category, where the objects are 'thing a' instead, encapsulating some additional complexity - perhaps the possible absence or multiplicity of the value, perhaps extra state, opacity, etc. But whatever it is, the a-ness is still key for combing these objects. So lets look how they combine. Pay special attention to the f column. g f ??? g ??? f application a a->b flip ($) b monad bind m a a->m b >>= m b comonad cobind w a w a->b =>> w b arrow arr a b arr b c >>> arr a c simple application: f takes one argument, returns one result. monad: f still takes one argument, but now understands how to put things /into/ m. (Perhaps it just uses return::a->m a) comonad: f has access to the entire complexity of 'w a', understands how to get thing(s) out of it (coreturn), and distills it all down to one simple b. arrow: f has access to the entire complexity of the 'input' of arr b c, and does whatever is needed, to make the complexity of the 'output' of arr b c. Input/output may even be bidirectional! Also we can look at the job that ??? does. Remember that ??? has access to f as a function and can call it as many or as few times as it wishes. $: feeds a to f, once. >>=: picks zero or more a's from 'm a', feeds each one separately to f. opens up each of the 'm b' results to combine them into one 'm b'. =>>: feeds one or more versions of 'w a' to f, then builds a 'w b' in some way using the single b's (Perhaps inspired by 'w a') >>>: links g to f in some way, so they can interact in as complex a way as they like. Maybe it also contributes to that complexity. So now perhaps we can come to some conclusion about why monads are so useful and universal as control structures. It seems that monads are somehow the /simplest/ way of adding general control structure on top of single values. Notice how in a monad, the things that are combined together, the f's, still take just one 'a' argument. So theres no extra complexity for f in understanding its input. f can, however, put some additional complexity into its output - it can fail, or return multiple values, or whatever else is possible to encode in 'm a'. Still, f can be dumb, and just pass the problem onto some other function, maybe return. The complexity of the monad lives in one place, bind, >>=. It is bind that has the choice of calling f multiple times if it feels like it, and has the job of combining the results. bind is in control. f can only give it directions by returning one 'm b' for a given a. Contrast a comonad. Each f has to cope with an entire 'w a' on input. Moreover, it can't communicate any of that complexity back to cobind - it can only return one b. cobind only has the structure of 'w a' to inspire it in how to put together 'w b', it can receive /no/ instructions from f. Arrows are of course most general. Nothing is determined except that f talks with g in some way, and the compatibility is named 'b'. So given the choice of the above, which would /you/ choose, when the nature of the problem means one-on-one application is too simple? Surely a monad is the pick of the bunch! * f gives merely directions on control to >>= * f has to understand merely one single argument. (the monad can supply extra specialized functions like get/put, if we do want some complexity in there) * All the complex control structure is handled in one place - bind. And it has all the information available to do it well. Pity the poor comonad, only really suitable for infinite sequences! Shudder at the thought of the total complexity possible using arrows, and use them only when /really/ necessary. monad is king! -- Brian_Brunswick____brian@ithil.org____Wit____Disclaimer____!Shortsig_rules!

16 27

Parsec: Parenthesized expressions and more!
by Vimal 14 Aug '07

14 Aug '07

Hi I was trying out some parsing with parsec. I tried: Accepting proper parenthesized expressions, this was the code: parens :: Parser () parens = do char '(' parens char ')' parens <|> return () Implementing basically: S -> (S)S | e. I doubt the fact that 'e' was actually considered, because the program seems to be accepting all strings of the form ())*. Did I go wrong somewhere? I guess this could be because, the input was "partially" accepted. Can I force it to derive the entire input string? And, btw, is there a method to implement an epsilon production? I tried do { string "" ; rules ... } And it didn't seem to work. I am also trying out this problem just for fun, but I seem to be getting wrong answers! http://spoj.pl/problems/FOOL Maybe I implemented something wrong. So, i will wait for some comments on the above parsing, and try one more time before I ask questions on that :D Cheers -- -- Vimal Department of Computer Science and Engineering Indian Institute of Technology Madras

2 1

a regressive view of support for imperative programming in Haskell
by Paul Hudak 14 Aug '07

14 Aug '07

All of the recent talk of support for imperative programming in Haskell makes me really nervous. To be honest, I've always been a bit uncomfortable even with monad syntax. Instead of: do x <- cmd1 y <- cmd2 ... return e I was always perfectly happy with: cmd1 >>= \x-> cmd2 >>= \y-> ... return e Functions are in my comfort zone; syntax that hides them takes me out of my comfort zone. In my opinion one of the key principles in the design of Haskell has been the insistence on purity. It is arguably what led the Haskell designers to "discover" the monadic solution to IO, and is more generally what inspired many researchers to "discover" purely functional solutions to many seemingly imperative problems. With references and mutable data structures and IO and who-knows-what-else to support the Imperative Way, this discovery process becomes stunted. Well, you could argue, monad syntax is what really made Haskell become more accepted by the masses, and you may be right (although perhaps Simon's extraordinary performance at OSCOM is more of what we need). On the other hand, if we give imperative programmers the tools to do all the things they are used to doing in C++, then we will be depriving them of the joys of programming in the Functional Way. How many times have we seen responses to newbie posts along the lines of, "That's how you'd do it in C++, but in Haskell here's a better way...". I hope I don't start a flame war with this post -- I'm just expressing my opinion, which admittedly is probably regressive rather than progressive :-). -Paul -- Professor Paul Hudak Department of Computer Science Office: (203) 432-1235 Yale University FAX: (203) 432-0593 P.O. Box 208285 email: paul.hudak(a)yale.edu New Haven, CT 06520-8285 WWW: www.cs.yale.edu/~hudak

21 33

Small proof intro
by Tim Newsham 14 Aug '07

14 Aug '07

I put together a small intro lesson on proving haskell code using quickcheck, equational reasoning and Isabelle/HOL. Its very elementary, but might be of interest to some people here. http://www.thenewsh.com/%7Enewsham/formal/reverse/ Feedback is appreciated. Tim Newsham http://www.thenewsh.com/~newsham/

1 0

A few questions on primes generating.
by L.Guo 14 Aug '07

14 Aug '07

Hi All: I am reading http://www.haskell.org/haskellwiki/Prime_numbers The code in sector "1 Bitwise prime sieve". I have 3 questions about it. 1) In function go, what does the number 46340 mean ? Is it sqrt(MAX_LONG) ? 2) We have this type definition : pureSieve :: Int -> Int Why there is no error (type mismatch) of this call in func main : pureSieve 10000000 3) In main again, what does expression [| x |] mean ? Why this cannot be execute in GHCi ? Thanks for any advice. Regards -------------- L.Guo 2007-08-13

8 9

monad subexpressions
by Chris Smith 14 Aug '07

14 Aug '07

I've heard Simon (Peyton-Jones) twice now mention the desire to be able to embed a monadic subexpression into a monad. That would be http://article.gmane.org/gmane.comp.lang.haskell.prime/2267 and in the recent OSCON video. Is someone working on implementing this? If no, I'll take a crack at it. If yes, I'd be slower than someone else, since I'm new to GHC. This seems like something a tad easier than type system extensions and the like since it's just desugaring... but a little harder than my "remove the GHCi banner" patch! In other words, a perfect step for me. Also, I got so frustrated that I ended up abandoning some code recently because STM is, in the end, so darn hard to use as a result of this issue. I'd love to see this solved, and I'm quite eager to do it. Proposals for syntax I've seen include: $( expr ) -- conflicts with template haskell ( <- expr ) -- makes sense, and I think it's unambiguous Other ideas: ``expr`` -- back-ticks make sense for UNIX shell scripters (| expr |) -- I don't think anything uses this yet Thoughts? -- Chris Smith

33 101

Re: [Haskell-cafe] out of core computing in haskell
by Carter T Schonwald 14 Aug '07

14 Aug '07

The main two use cases I have in mind are 1) really really really big abstract syntax trees or proof trees (a la compilers or theorem provers) 2) random access to numerical data does that help clarify what i'm asking about? In each case, is there a standard way of dealing with this? in the case of (1) the sensible way seems to me to do some sort of zipper representation which loads adjacent nodes to some depth surrounding your current location in the tree, and in the case of (2) it seems like the sensible way would be load subsequences of the data into memory. ----- Original Message ---- From: Andrew Coppin <andrewcoppin(a)btinternet.com> To: haskell-cafe(a)haskell.org Sent: Monday, August 13, 2007 3:55:57 PM Subject: Re: [Haskell-cafe] out of core computing in haskell Carter T Schonwald wrote: > Hello Everyone, > I'm not quite sure if I'm posing this question correctly, but what > facilities currently exist in haskell to nicely deal with > datastructures that won't fit within a given machine's ram? > And if there are no such facilities, what would it take to fix that? If you just want to process a big chunk of data from one end to the other without loading it all into RAM at once... that's fairly easy. Haskell is a lazy language. By playing with functions such as getContents, you can automatically load the data as you access it. No tricky programming required. If you're asking for something more specific -- e.g., "how do I talk to a standard database like Oracle / MySql / et al.", there are a couple of libraries for that. (Unfortunately, no one standard one.) See Stefan's answer. I'd you'd like to be more specific about what you'd like to do... _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1

Help with a project design
by Andrea Rossato 14 Aug '07

14 Aug '07

Hi, I'm going to be long, sorry for it. And probably also off topic, a bit at least...;-) I need a way to manage bibliographies, pretty common problem isn't it? I used to use a wiki I developed also for such a task.[1] The wiki was basically based on Bibtex. I thought I could rewrite that bibliographic management system in Haskell, but I've been also following the work of some guys who are trying to develop a style citation language in XML.[2] Since my confidence with Haskell is growing, I though I could try to write an implementation of that Citation Style Language, but now I start hitting my basic lack of computer science education. Such an effort would be useful if I could write a library and release it, which requires a clean architecture and a simple exported API. But, while I can grasp difficult computational concepts like monads or arrows, choosing a given path of development and create that API is probably out of my reach. This is why I'm asking for help. Or, probably better, for directions on how to start acquiring such capacities. The task this library should do is simple: given an xml object (representing a bibliographic reference), render it with rules stored in a different xml object (the citation style). While I think I can find solutions for this problem - the rendering -, what I find difficult is the design of the reference xml objects. Bibliographic entries have different types, which must be rendered differently. These types can be classified into 3 main classes (books, articles, parts of a book) that can be rendered with the same methods. That seems to fit Haskell perfectly. Now, I basically see 2 approaches: 1. create some data structures (most part of them is common) to map different types of bibliographic entries, and create the needed classes with the render methods; 2. keep the xml objects as xml and create an abstract interface to the xml objects to get the data required for rendering and classifying the xml objects. This way I would have to: - create data types to store different types of xml objects (data Book = Book XmlTree, data Artilce, etc.): these data types represent my reference classes; - create a class of 'render'-able types with the render method and define the instances; - create an existential type to set the type of the xml objects with some kind of setType :: XmlTree -> ExistentialContainer I think that the first approach is not abstract enough and requires a lot of boilerplate code to translate into a Haskell type a specific type of bibliographic entry. Moreover, this brings me back to Bibtex, that maps each entry type to a set of rendering rules, while xml objects (MODS[3]) have no type (type must be deduced by the presence of given elements). The second one is the one I'm leaning to. But I'm also thinking that probably I should first study a bit the "scrap your boilerplate" approach ... on the other side I think that I should probably take a path, follow it and see what happens. In other words, I keep on testing the feasibility of different approaches, probably because I did not grasp the problem entirely. And then there is the API, function names, argument disposition, and so on. Is there some material I could read to have some guidelines for such a task? I know that this is some kind of meta question that is not really Haskell specific, even though I would like to have Haskell specific answers...;-) But any kind of suggestion will be appreciated, especially if you can give me directions to materials that, even if not directly connected with my specific problem, can help me in understanding the basic principle of functional programming design. Thanks for your kind attention and sorry for such a long message. Andrea [1] http://uniwakka.sf.net [2] xbiblio.sf.net [3] "Metadata Object Description Schema" (MODS) http://www.loc.gov/standards/mods/

2 1

out of core computing in haskell
by Carter T Schonwald 14 Aug '07

14 Aug '07

Hello Everyone, I'm not quite sure if I'm posing this question correctly, but what facilities currently exist in haskell to nicely deal with datastructures that won't fit within a given machine's ram? And if there are no such facilities, what would it take to fix that? thanks -Carter

3 2

GHC optimisations
by Andrew Coppin 14 Aug '07

14 Aug '07

Does GHC do dead code elimination? I observe that if you take a module and edit it so that some function is now no longer exported or called by any exported function, the size of the *.o file seems to go down. This suggests that dead code within a single module is eliminated. However... how about this? module Foo where f = ... g = ... h = ... module Main where import Foo main = ...f... Will the generated executable contain the code for g and h, even though they aren't called? Or does the unused code get eliminated? How about the standard libraries? I read somewhere that if one funtion returns a tuple, and the caller immediately extracts the values from the tuple, GHC tries to optimise away the tuple - so it's as if the function can just return multiple values at once. Is this true? Does it apply only to tuples, or to all types?

2 4

zip3, zip4 ... -> zipn?
by Frank Buss 14 Aug '07

14 Aug '07

Is it possible to write a function like this: zipn n list_1 list_2 list_3 ... list_n which implements zip3 for n=3, zip4 for n=4 etc.? Looks like variable number of arguments are possible, like printf shows, so a general zipn should be possible, too. If it is possible, why there are functions like zip5 and not just zipn? -- Frank Buss, fb(a)frank-buss.de http://www.frank-buss.de, http://www.it4-systems.de

12 13

xpath types for SYB/generic haskell type system?
by Alex Jacobson 14 Aug '07

14 Aug '07

The SYB papers provide really powerful functions for accessing and manipulating a values in arbitrary shaped containers. The cost of this capability appears to be loss of type checking. For example gfindtype x returns a maybe y. Given that the type checker actually has to know whether or not x actually contains a y inside of it, is there a way to annotate a gfindtype sort of function that just returns a value and if applied with the wrong type has a compiler enforce error? It may not be in this version of haskell, but it seems like there is no technical reason you could not have partial type annotations that describe the traversal strategies described in SYB. Perhaps it is a type version of an xpath expression e.g myFindType::(.//y) x => x->y The (.//y) x says that y is a type nested somewhere in x. Note, since this is happening at compiler time, this capability will still not prevent you from doing a (fromJust Nothing), but it still seems super valuable if you are doing generic haskell type stuff? Is there a mathematical reason why this wouldn't work? -Alex-

1 0

Re: [Haskell-cafe] IO within parser
by Sam Hughes 13 Aug '07

13 Aug '07

Malte Milatz wrote: > Sam Hughes <hughes(a)rpi.edu>, Sun, 12 Aug 2007 20:12:55 -0400: > [A parser like Parsec, with monad transformers:] >> $ darcs get http://samuelhughes.com/darcs/partran/ > > Is this related in any way to the following GSoC project? > > http://code.google.com/soc/2007/haskell/appinfo.html?csaid=B97EF4562EF3B244 > > No, I just wanted it for my own purposes. - Sam

1 0

Suffix tree
by Jon Harrop 13 Aug '07

13 Aug '07

Suffix trees are a data structure used to search for a substring of length "m" in a string of length "n" in O(m) time. Suffix trees can also be used for efficient approximate searches. This data structure is of particular importance in bioinformatics. Does anyone have any Haskell code implementing suffix trees? I'm particularly interested in high-performance construction. -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. OCaml for Scientists http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

3 2

IO within parser
by Gregory Propf 13 Aug '07

13 Aug '07

I've been struggling with writing a parser that needs to parse include files within source files. So far I cannot get this to work (in reality to get work done I wrote a kludge that returns a list of include filenames to be run later in a pure IO function. I realized that this just amounted to creating my own half-assed monad system so I really don't want to use this approach). I have read the tutorials I could find on monad transformers but I still don't see what's going on. I'm using the Parsec parser library. Here's an simple example of what I've tried. I also tried using liftIO and got a message about needing to add an instance of MonadIO. This made more sense but the type of liftIO is baffling class Monad m => MonadIO m where liftIO :: IO a -> m a But how do you define this function? There is no constructor for "IO a" that you can "take apart". Anyway, here is the code that just uses lift. Keep in mind that the outer monad is just "GenParser Char st [Char]". I'm guessing this is wrong and I should have a transformer monad as the outer layer. But which one? and how to use it? pio = do { s <- many1 alphaNum; input <- lift (readFile s); return input; } go6 = runParser pio () "" "This is a test" ================================= ghc output from trying to load this is ================================= Couldn't match kind `* -> * -> *' against `(* -> *) -> * -> *' When matching the kinds of `GenParser Char :: * -> * -> *' and `t :: (* -> *) -> * -> *' Expected type: GenParser Char st Inferred type: t IO In a 'do' expression: lift (writeFile "Foo" s) ____________________________________________________________________________________ Fussy? Opinionated? Impossible to please? Perfect. Join Yahoo!'s user panel and lay it on us. http://surveylink.yahoo.com/gmrs/yahoo_panel_invite.asp?a=7

4 3

Infinity v0.1
by Austin Seipp 13 Aug '07

13 Aug '07

Hello! Over the past couple of days I've been working on an IRC bot in the essence of lambdabot; that is, it should be extendable through plugins and plugins should be easy to write, modify and contribute. I also wanted the bot to be small in terms of LOC (as of 0.1, about ~360 including the two bundled plugins,) but still be usable. Well, now I have something to show for it, and I introduce infinity v0.1: http://austin.youareinferior.net/infinity-0.1.tar.gz (there is no darcs repo yet, although I have emailed someone about a possible account for darcs.haskell.org.) Everything from building to writing plugins should become fairly self evident from reading the README. You will need the hs-plugins to use it. As it stands, the bot is incredibly primitive and there are almost no plugins (I only wrote 'hello world' and 'goodbye world' plugins to test the code as it moved forward) as of yet, however, I had fun with this thing and I hope maybe someone could do something interesting with it. There're some parts of the code that I'm not particularly happy with. For the 0.2 release I have a couple of goals in mind: 1. To move the basic ad-hoc IRC parsing code (lots of drop and dropWhile and whatnot) to a more robust implementation such as parsec. This should hopefully clean up some of the code I'm not on good terms with. 2. To add support for in-situ reloading and re-compilation of modules, so you won't even have to restart the bot if you update a plugin. This will probably require some reworking of my threading code so that the environment stays safe and stable (STM?) 3. To move all of the built-in core commands to plugins as well; this will probably require encapsulating plugins in a monad (StateT) henceforth. I'm not exactly the most advanced haskell programmer ever born, but I enjoyed working on this code and while it isn't and probably won't ever be the next lambdabot, I hope someone can learn something from it or just have fun with it. If anybody would like to take the time to write a plugin or something for some interesting purpose, I would be happy to include it in the source tree (I'm sure you guys can come up with something more interesting than I can.) I would really appreciate any and all comments on the code. I still feel myself to be in an 'intermediate' area with Haskell, so anything you guys can add that would improve the code would be incredibly appreciated. PS: I've only tested this on an i386 linux box so if anybody here can confirm it works on other systems (bsd, solaris?) where hs-plugins is available, that would be awesome. Thanks! -- - Austin

2 1

howto install ghc-6.7.* ?
by Marc A. Ziegert 13 Aug '07

13 Aug '07

i just don't get it. please, can anybody explaim me how to do that? i tried it the last few days with ghc-6.7.20070807, ghc-6.7.20070809, and ghc-6.7.20070810. it always results in a broken library (without Prelude): # ghc-pkg list /usr/local/lib/ghc-6.7.20070810/package.conf: {ghc-6.7.20070810}, rts-1.0 i did this on my gentoo-i386-box (pretty old, takes 1h for quick build, 3.5h without mk/build.mk): T=20070810 tar xjf ghc-6.7.$T-src.tar.bz2 tar xjf ghc-6.7.$T-src-extralibs.tar.bz2 cd ghc-6.7.$T ( #echo BuildFlavour = quick #cat mk/build.mk.sample echo HADDOCK_DOCS = YES ) > mk/build.mk ./configure && ( time nice -n 19 make all install ) those extralibs seem to be installed in /usr/local/lib/ghc-6.7.20070810/lib/ but registered in ghc-6.7.20070810/driver/package.conf.inplace instead of /usr/local/lib/ghc-6.7.20070810/package.conf . - marc

4 3

towards a new foundation for set theory with atoms
by Greg Meredith 12 Aug '07

12 Aug '07

Haskellians, i have a particular interest in FM-set theory in that it simplifies a host of otherwise non-trivial aspects of programming language semantics, especially, fresh names. You can provide semantics without sets with atoms, but the functor category machinery is more than a little on the heavy side. The down side of FM-set theory is that it posits an infinite collection of atomic entities -- atomic in the sense that they have no observable internal structure. This poses a real problem for computational accounts. No where do we have an infinite supply of atomic entities. All our infinite collections need some finite presentation -- some basic starting structure and then a finite set of rules that say how to generate the rest. This is particularly important since the atoms have to come with a equality predicate. If the predicate cannot inspect internal structure, then the equality predicate is too big to hold in any finitely presentable computation. Thus, there's a little conundrum: how do you get all the conveniences of a set theory with atoms and still have a finite presentation? Here's one approach. The issue is that atoms cannot have internal structure observable by the set-theoretic operators, \in : Set -> Atom + Set -> Bool, and { - } : [Atom + Set] -> Set. That doesn't mean they can't have structure. Where would this structure come from? Well, it's related to another observation about sets: they're really collections of pointers. More specifically, the axiom of extensionality says that two sets are equal iff they have exactly the same members. Thus, wherever we see the set { } it's the same. Therefore, in { { }, { { } } } we see the very same set occurring in two locations. This is not very physical. These notions of location or identity must be more logical notions. And, one obvious way to resolve this is that what's "inside" the braces are references or pointers. We can start to formalize this naively using a simple grammar-nee type formulation. Ordinary sets can be specified like this Set ::= { Set* } for some appropriately infinite version of Kleene-star. (Note, this grammar is really sugar for a domain equation.) Now, if we want sets over references, we could modify the grammar, like this RSet ::= { Ref* } Ref ::= `Set*' R-sets only contain references and references point to (collections of) sets. Then, you can add a dereference operation to you theory to get back the sets being referenced. But, while under the quotes, the internal structure is not observable by the element-of and brace operators. Thus, from the point of view of these operators, they look like atoms. Note that as written, the quotes are serving a role isomorphic to the role of the braces. They are essentially two different collection operators that have been intertwined in an alternating manner. This alternation is in perfect correspondence with games semantics. We interpret { as opponent question, } as opponent answer, ` as player question, ' as player answer. This means that winning strategies for opponent yield sets while winning strategies for player yield references. The observation leads to a further generalization. Nothing restricts us to two kinds of collection operators. We could posit n different "colored" braces and element-of operators, written {i - i}, \in_i, for color i. Then we have the following specification for these sets Set(i) ::= {i Set(0 <= j < n : j <> i)* i} i have coded up (in my pidgin Haskell) a version for 3 colors and then shown how to do the von Neumann encoding of the naturals in this setting. The code can be found here: http://svn.biosimilarity.com/src/open/mirrororrim/rsets/trunk/MPSet.hs 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

2 3

Re: default for quotRem in terms of divMod?
by Henning Thielemann 12 Aug '07

12 Aug '07

On Sun, 12 Aug 2007, Lennart Augustsson wrote: > CPU design cannot be changed, because they implement well defined ISA. What is ISA? Why is it not possible to add CPU functions for `div` and `mod`? > The only processor I know of (NS 32k) with a different division is long > dead. If efficiency on current CPUs is the only advantage of `quot` and `rem`, then for future versions of Haskell I propose to fix these functions to the type Int rather than making them class methods. For non-machine types like Integer the efficiency argument does certainly not hold.

2 1

Re: Fw: [Haskell-cafe] IO within parser
by Gregory Propf 12 Aug '07

12 Aug '07

I noticed that StateT can enclose IO actions for instance. So you are saying the whole Parsec library would need to be rewritten as something like a ParsecT transformer monad for this to work? If this is the case I suppose I will stick with returning my list of include files. - Greg ----- Original Message ---- From: Bulat Ziganshin <bulat.ziganshin(a)gmail.com> To: Gregory Propf <gregorypropf(a)yahoo.com> Cc: haskell-cafe(a)haskell.org Sent: Saturday, August 11, 2007 11:33:00 PM Subject: Re: Fw: [Haskell-cafe] IO within parser Hello Gregory, Sunday, August 12, 2007, 9:32:04 AM, you wrote: >> I've been struggling with writing a parser that needs to parse include >> files within source files. Parsec can't accomplish with without using unsafePerformIO because it's monad is pure. it's algorithmically impossible to have any i/o actions inside it. there was plans to rewrite Parsec in monad-transformer way and afair it was even one of GSOC projects -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com ____________________________________________________________________________________ Fussy? Opinionated? Impossible to please? Perfect. Join Yahoo!'s user panel and lay it on us. http://surveylink.yahoo.com/gmrs/yahoo_panel_invite.asp?a=7

1 0

Fw: [Haskell-cafe] IO within parser
by Gregory Propf 12 Aug '07

12 Aug '07

Well the docs ( http://legacy.cs.uu.nl/daan/download/parsec/parsec.html ) hint that setInput and getInput are good for this. I can certainly how they *would* be - if I knew how to pull in files within the parse. Actually I use those functions to do multiple recursive passes but of course you already have the output from the first pass in the parser there. runParser only *looks* like it takes input from a file. Actually it just parses the string you give it and uses the filename arg for error messages only. You still need a way to pull the data into the string from the file. (Note: I accidentally sent this to Andrew instead of the list originally) ----- Original Message ---- From: Andrew Coppin <andrewcoppin(a)btinternet.com> To: haskell-cafe(a)haskell.org Sent: Saturday, August 11, 2007 1:25:16 PM Subject: Re: [Haskell-cafe] IO within parser Gregory Propf wrote: > I've been struggling with writing a parser that needs to parse include > files within source files. So far I cannot get this to work (in > reality to get work done I wrote a kludge that returns a list of > include filenames to be run later in a pure IO function. I realized > that this just amounted to creating my own half-assed monad system so > I really don't want to use this approach). I have read the tutorials > I could find on monad transformers but I still don't see what's going > on. I'm using the Parsec parser library. Here's an simple example of > what I've tried. I also tried using liftIO and got a message about > needing to add an instance of MonadIO. This made more sense but the > type of liftIO is baffling The fun part is that Parsec already has a feature for include files... (I can't remember where the heck it is or how you use it though.) _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe Fussy? Opinionated? Impossible to please? Perfect. Join Yahoo!'s user panel and lay it on us. ____________________________________________________________________________________ Choose the right car based on your needs. Check out Yahoo! Autos new Car Finder tool. http://autos.yahoo.com/carfinder/

2 1

Re: default for quotRem in terms of divMod?
by Henning Thielemann 12 Aug '07

12 Aug '07

Btw. is there any application, where 'quot' and 'rem' are needed? All occurrences of 'quot' and 'rem' I found in code so far were actually wrong and should have been 'div' and 'mod'. http://www.haskell.org/haskellwiki/Things_to_avoid#Forget_about_quot_and_rem

3 4

Defining new operators
by rodrigo.bonifacio 11 Aug '07

11 Aug '07

Hi all, Given the follwing function: > owner :: Step -> Scenario > owner (Step id scenario action state response) = scenario Is it possible to define the owner function in such way that I can write x.owner (returning the scenario related with the Step x)? Thanks in advance, Rodrigo.

5 4

How odd...
by Andrew Coppin 11 Aug '07

11 Aug '07

> 0^2 0 > (0 :+ 0)^2 0 :+ 0 > 0**2 0 > (0 :+ 0)**2 NaN :+ NaN (Is this a bug?)

10 16

arrow question HXT related
by Andrea Rossato 11 Aug '07

11 Aug '07

Hi, I think this is just a stupid arrow question. Still I cannot find where my mistake is located. Suppose I have a simple xml document I want to process with HXT: <root> <elem> <sub /> <risub>text</risub> </elem> </root> After extracting <elem> I want to duplicate the children trees with the arrow operator (&&&) and process them to get each sub element, like I try in treMe2. Below the example code. While I can get each sub element with tryMe and tryMe1, tryMe2 will produce a []. Instead I want something like tryMe3. I think I'm missing something stupid but right now I just feel stupidly blind. Thanks for your help, Andrea import Text.XML.HXT.Arrow xml = "<root><elem><sub /><risub>text</risub></elem></root>" tryMe = runLA arrow [] where arrow = constA xml >>> xread >>> deep (hasName "elem") >>> getChildren >>> (hasName "risub" >>> getChildren >>> getText) tryMe1 = runLA arrow [] where arrow = constA xml >>> xread >>> deep (hasName "elem") >>> getChildren >>> (hasName "sub" >>> withDefault (getChildren >>> getText) "ciao") tryMe2 = runLA arrow [] where arrow = constA xml >>> xread >>> deep (hasName "elem") >>> getChildren >>> (hasName "sub" >>> withDefault (getChildren >>> getText) "ciao") &&& (hasName "risub" >>> getChildren >>> getText) tryMe3 = runLA arrow [] where arrow = constA xml >>> xread >>> constA "first" &&& constA "second" The output: *test> tryMe ["text"] *test> tryMe1 ["ciao"] *test> tryMe2 [] *test> tryMe3 [("first","second")] *test>

1 1

Small question
by Andrew Coppin 11 Aug '07

11 Aug '07

Which of these is likely to go faster? type Quad = (Bool,Bool) foo (r,t) = let x = if r ... y = if t ... in ... data Quad = BL | BR | TL | TR foo q = let x = if q == TL | q == TR ... y = if q == BR | q == TR ... in ... (Unless somebody has a better idea...) I'm hoping that the latter one will more more strict / use less space. But I don't truely know...

14 31

Problem with question 3 about knights and knaves on wikipedia
by Peter Verswyvelen 11 Aug '07

11 Aug '07

I was writing some haskell code for fun to solve some "knights and knaves" problems, and I have troubles with http://en.wikipedia.org/wiki/Knights_and_knaves#Question_3 So knights always tell the truth and knaves always lie. John and Bill are two persons, but you don't know what they are, and you have to find out. Question 3 You: Are you both knights? John: answers either Yes or No, but you don't have enough information to solve the problem. You: Are you both knaves? John: answers either Yes or No, and you can now solve the problem. My haskell code gave the following result: --(what is john, what is bill, first answer from john, second answer from john) ("John is a knight","Bill is a knight","Yes","No ") ("John is a knight","Bill is a knave ","No ","No ") ("John is a knave ","Bill is a knight","Yes","Yes") ("John is a knave ","Bill is a knave ","Yes","No ") Anyone has an idea what I missed here? Thanks, Peter PS: The (quick and dirty) haskell code I wrote for this is: infixl 1 <=> infixl 1 ==> -- Equivalence x <=> y = (x == y) -- Implication True ==> False = False _ ==> _ = True -- Knights tell the truth name `isa` True = name ++ " is a knight" -- Knaves always lie name `isa` False = name ++ " is a knave " answer True = "Yes" answer False = "No " --Logician: Are you both knights? --John answers either Yes or No, but the Logician does not have enough information to solve the problem. --Logician: Are you both knaves? --John answers either Yes or No, and the Logician can now solve the problem. condition j b answer1 answer2 = (j <=> ((b && j) == answer1)) && (j <=> ((not b && not j) == answer2)) solution = [("John" `isa` j, "Bill" `isa` b, answer answer1, answer answer2) | j <- [True,False], b <- [True, False], answer1 <- [True, False], answer2 <- [True, False], condition j b answer1 answer2 ] main = mapM_ putStrLn (map show solution)

3 3

listify
by Chad Scherrer 11 Aug '07

11 Aug '07

Don't be too impressed, I think I was way off base. Looks like just a homomorphism: http://en.wikipedia.org/wiki/Homomorphism Chad > > I wonder, is listify a contravariant functor? > I wonder - will I ever reach the stage where I too make off-hand remarks > like this? :-} > Now I know how all the "normal" people feel when I tell them that a > relation is simply a subset of the extended Cartesian product of the > respective domains of its attributes...

1 0

re: [Haskell-cafe] Pure functional GUI (was "a regressive view of support for imperativeprogramming in Haskell")
by Peter Verswyvelen 11 Aug '07

11 Aug '07

As a newbie (okay I will not write this again, you all know I'm a newbie by now ;-), I don't understood what the problem of a pure functional GUI is. To me, having an imperative background, a graphical application is just a big tree of data that evolves when events from the OS come in. (this data is NOT per se the data for the GUI element; instead use the model-view-controller design pattern) In Haskell, instead of mutating the data (as done in C/C++), a infinite stream of this tree-data is generated responding to an infinite steam of events, as in Paul's SOE book (the reactive stuff). Since most of the data can be shared, the performance impact should be minimal. So could you please tell me more about the problem with pure functional GUIs and why this is not part of the Haskell library? I mean a GUI library completely written in Haskell, not wrapping a popular library. Thanks, Peter >----- Oorspronkelijk bericht ----- >Van: Donn Cave [mailto:donn@drizzle.com] >Verzonden: woensdag, augustus 8, 2007 08:56 PM >Aan: haskell-cafe(a)haskell.org >Onderwerp: Re: [Haskell-cafe] a regressive view of support for imperative programming in Haskell > >On Wed, 8 Aug 2007, Paul Hudak wrote: >... >> Well, you could argue, monad syntax is what really made Haskell become >> more accepted by the masses, and you may be right (although perhaps >> Simon's extraordinary performance at OSCOM is more of what we need). On >> the other hand, if we give imperative programmers the tools to do all >> the things they are used to doing in C++, then we will be depriving them >> of the joys of programming in the Functional Way. How many times have >> we seen responses to newbie posts along the lines of, "That's how you'd >> do it in C++, but in Haskell here's a better way...". > >It seems to me that Brian Hulley threw the glove down hard. Does >pure functional Haskell offer a better way to write a GUI? > >I love the functional stuff myself, but if real applications depend >on extensive imperative logic, we're best served by a language that >cheerfully embraces the inevitable and handles it well. Monads, the >do syntax, whatever it takes (I have a soft spot for O'Haskell, but >alas I must be nearly alone on that.) Hopefully, it's still better, >and not at all irreconcilable with the Functional Way. > > Donn Cave, donn(a)drizzle.com > >(That's a genuine question, by the way - my attempt to build a >current Haskell GUI library on NetBSD foundered and I have no >experience with Haskell GUI coding, but it's on the list of things >I would like to look at. So if there's one that really illustrates >the virtues of pure functional Haskell programming, that would be >a welcome tip!) > >_______________________________________________ >Haskell-Cafe mailing list >Haskell-Cafe(a)haskell.org >http://www.haskell.org/mailman/listinfo/haskell-cafe > >

7 6

where to put handy functions?
by Chad Scherrer 11 Aug '07

11 Aug '07

Is there process for submitting functions for consideration for inclusion into future versions of the standard libraries? For example, I'd like to see this in Data.List: extract :: [Int] -> [a] -> [a] extract = f 0 where f _ _ [] = [] f _ [] _ = [] f k nss@(n:ns) (x:xs) = if n == k then x:f (k+1) ns xs else f (k+1) nss xs This behaves roughly as extract ns xs == map (xs !!) ns except that it's a lot more efficient, and it still works if ns or xs (but not both) are infinite. Oh, and "ns" are required to be ordered and non-negative. I'm guessing there are a lot of similarly simple handy functions, and I'm wondering if there's anything in place to avoid (1) reinventing the wheel, and (2) name clashes. Someone else may have written "extract" as well, meaning one of us wasted our time. And chances are, if they did, it has a different name, leading to forced qualified imports. Finally, even if no one else is using it, it would be good to settle on reasonable names for things more easily. Is there a better name for this function? Is there a reason not to call it "extract"? -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

9 11

Matters of precision
by Andrew Coppin 11 Aug '07

11 Aug '07

Hi folks. I'm trying to write a Mandelbrot generator, and I've having a few problems with precision. First of all, currently I'm just using Double to represent coordinates. Can anybody tell me what the smallest value you can represent with one is? (Not including denormals.) (I've built a function that checks for cycles in the orbit - by looking for previous points that are sufficiently "near" to the current one. But I want to know how much precision a Double gives me so I can figure out how near is "near".) Next up, at some point I'm going to need more precision than a Double can give me. (But, obviously, I still want the thing to go as fast as humanly possible.) In particular, I do NOT want to go into "infinite" precision. (E.g., exact arithmetic with arbitrary fractions.) I want to be able to make the precision arbitrarily high, but still finite and fixed. (The idea being that the further you zoom in, the more the computer turns up the precision.) Is there anything useful for this in the standard libraries? Or will I have to write something?

3 2

Erlang-style concurrency
by Kyle Consalus 11 Aug '07

11 Aug '07

In digest #69, Hugh Perkins mentioned the coolness of Erlang-style message passing concurrency. It just so happened that I was playing with that yesterday, so I figured I'd post a link to a 'ping-pong' thing that I based on an example in the erlang tutorial. I figured "Haskell has lightweight threads, higher order functions, and pattern matching. No reason that with a little bit of STM and some monadic convenience we can't do message passing." It's really simplistic and doesn't parameterize message type (well, not this version; that version is still in the works), but I thought someone might find it amusing just the same. http://hpaste.org/2174

1 0

Interval Arithmetics
by Mitar 10 Aug '07

10 Aug '07

Hi! First, disclaimer: everything I know about interval arithmetics comes from this video: http://video.google.com/videoplay?docid=-2285617608766742834 I would like to know if there is any implementation of interval arithmetics in Haskell? I would like to play a little with that. I checked the web and the straightforward approach I found: http://cs.guc.edu.eg/faculty/sabdennadher/Publikationen/paper-wflp99.ps.gz has from my point of view invalid implementation. For example, lower bound in the sum should not be just calculated as the sum of lower bounds of summands. It should return the greatest representable number which is smaller or equal to the exact value of the sum. With just boldly making a sum we ignore any errors we could introduce and this is somehow against the idea of interval arithmetics. And as it is said at the end of the talk, a system behind interval arithmetics should do a lot of work to make those intervals as small as possible while still correct and counting in all the errors we accumulated. I think a strict-typed and lazy language like Haskell would be a good place to implement this. But I would like to know if this would be possible to do from the language itself, without making changes to the compiler and/or runtime itself? Because, for example, a good implementation should reformulate equations at the runtime accordingly to exact values it wants to compute them on. Has it been done already? Mitar

2 1

Polymorphic variants
by Jon Harrop 10 Aug '07

10 Aug '07

Does Haskell have anything similar to OCaml's polymorphic variants? They act as inferred sum types: # let rec eval = function | `Int n -> n | `Add(f, g) -> eval f + eval g | `Mul(f, g) -> eval f * eval g;; val eval : ([< `Add of 'a * 'a | `Int of int | `Mul of 'a * 'a ] as 'a) -> int = <fun> -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. OCaml for Scientists http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

4 4

Monad Description For Imperative Programmer
by Kaveh Shahbazian 10 Aug '07

10 Aug '07

This is about to put a definition/description to test. So please cooperate! ;) Is this a useful – sufficient, not complete – definition/description for a monad; for an imperative mind: (?) "A monad is like a loop that can run a new function against it's variable in each iteration." (I insist on the simplicity! And I will resist any expansion of this sentence (except for an exceptional note that I think of it hardly). I think there is not any complete definitions in computer world. At least there are many things to know when you want to use them in practice. So please have this in mind and review me!) Cheers :)

10 13

Haskell DB tutorial link is broken.
by Edward Ing 10 Aug '07

10 Aug '07

Hi, The following link is broken. http://www.haskell.org/hawiki/HaskellDbTutorial Edward Ing

2 1

Derivation of Eq given Ord
by Dougal Stanton 10 Aug '07

10 Aug '07

Is there a reason why automatic derivation of Ord without Eq doesn't do "the sensible thing" and just derive Eq anyway? > newtype Id a = Id { a :: String } > deriving (Read, Show, Eq, Ord) > newtype Ego a = Ego { b :: String } > deriving (Read, Show, Ord) Both will type check, but if you try any (in)equality operators on the second they'll be spat back at you. > *Main> let e1 = Ego "" > *Main> let e2 = Ego "" > *Main> e1 < e2 > > <interactive>:1:0: > No instance for (Eq (Ego a)) > arising from use of `<' at <interactive>:1:0-6 > Possible fix: add an instance declaration for (Eq (Ego a)) > In the expression: e1 < e2 > In the definition of `it': it = e1 < e2 It doesn't seem *much* of a hardship, but it wasn't what I expected. I'm not used to GHC accepting input and silently dropping stuff it doesn't like... Cheers, D.

5 6

Re: [Haskell-cafe] Problem with question 3 about knights andknavesonw ikipedia
by Peter Verswyvelen 10 Aug '07

10 Aug '07

Oh boy, never mind, after a good night sleep the solution is super obvious... Grrr what a waste of time ;-) The solution is in the sentence "the logician has then enough information to solve the problem", which I yesterday read like "the problem can now be solved", which is not the same. So the second answer must have been "Yes" otherwise the logician did not have enough information to solve the problem (because two cases still remain). Gee. But it was good Haskell practice ;-) >>("John is a knave ","Bill is a knight","Yes","Yes") >----- Oorspronkelijk bericht ----- >Van: Peter Verswyvelen [mailto:bf3@telenet.be] >Verzonden: donderdag, augustus 9, 2007 11:35 PM >Aan: steve(a)fenestra.com, haskell-cafe(a)haskell.org >Onderwerp: RE: [Haskell-cafe] Problem with question 3 about knights and knaves onw ikipedia > >Indeed, I missed that. This rules out the first answer is "no" > >But I still keep the 3 other solutions then :( > >>("John is a knight","Bill is a knight","Yes","No ") >>("John is a knave ","Bill is a knight","Yes","Yes") >>("John is a knave ","Bill is a knave ","Yes","No ") > >Any more help (or just the solution, I give up) is very welcome to help this >poor man in logic hell ;-) > >Oh well, it seems I'm getting too old for this stuff ;) > >-----Original Message----- >From: haskell-cafe-bounces(a)haskell.org >[mailto:haskell-cafe-bounces@haskell.org] On Behalf Of Steve Schafer >Sent: Thursday, August 09, 2007 8:22 PM >To: haskell-cafe(a)haskell.org >Subject: Re: [Haskell-cafe] Problem with question 3 about knights and knaves >onw ikipedia > >On Thu, 9 Aug 2007 20:07:02 +0200, you wrote: > >>("John is a knight","Bill is a knight","Yes","No ") >>("John is a knave ","Bill is a knight","Yes","Yes") >>("John is a knave ","Bill is a knave ","Yes","No ") >> >>Anyone has an idea what I missed here? > >You're missing a key element of the problem: After John answers the >first question, the Logician doesn't have enough information to solve >the problem. Think about that for a second, and you will see the light. > >Steve Schafer >Fenestra Technologies Corp. >http://www.fenestra.com/ >_______________________________________________ >Haskell-Cafe mailing list >Haskell-Cafe(a)haskell.org >http://www.haskell.org/mailman/listinfo/haskell-cafe > >_______________________________________________ >Haskell-Cafe mailing list >Haskell-Cafe(a)haskell.org >http://www.haskell.org/mailman/listinfo/haskell-cafe > >

1 0

In-place modification
by Andrew Coppin 10 Aug '07

10 Aug '07

I was wittering on about stream fusion and how great it is, and I got a message from Mr C++. (Mr C++ develops commercial games, and is obsessed with performance. For him, the only way to achieve the best performance is to have total control over every minute detail of the implementation. He sees Haskell is a stupid language that can never be fast. It seems he's not alone...) He said two things. The first was "it really perplexes me that Haskell insists that everything must be read-only". Naturally, I have a good answer to that one. (It's like being "perplexed" that relational databases refuse to keep table data in the same order. It's not to be awkward, it is a fundamental and important properly of the underlying theoretical foundation - the relational algebra, et al.) He also said what basically boils down to "being able to swap elements around in O(1) time and O(0) space is the whole thing that makes linked lists useful in the first place; take that away and it's rather pointless". I don't really have an answer to that one. (Lazyness and GC is probably going to kill most of the space cost. There's still a time cost - particularly the extra GC time...) I've asked this before and nobody answered, so I take it that nobody knows the answer... Does GHC *ever* do an in-place update on anything? Does the STG even have a command for that? I always assumed that the compiler tried to find instances where a new structure is created and the old one is no longer referenced, and make that be in-place. But now I'm not so sure...

26 157

Re: [Haskell-cafe] Pure functional GUI (was
by Peter Verswyvelen 10 Aug '07

10 Aug '07

Well, if you want to make it as big as QT, yes. But even just a simple purely functionaly GUI framework that is part of the library would be nice, because right now it gives the impression it cannot be done in Haskell... E.g. Concurrent Clean seems to have a simple UI library. >----- Oorspronkelijk bericht ----- >Van: Duncan Coutts [mailto:duncan.coutts@worc.ox.ac.uk] >Verzonden: woensdag, augustus 8, 2007 09:36 PM >Aan: 'Peter Verswyvelen' >CC: 'Donn Cave', haskell-cafe(a)haskell.org >Onderwerp: re: [Haskell-cafe] Pure functional GUI (was "a regressive view of support for imperativeprogramming in Haskell") > >On Wed, 2007-08-08 at 19:14 +0000, Peter Verswyvelen wrote: > >> So could you please tell me more about the problem with pure >> functional GUIs and why this is not part of the Haskell library? I >> mean a GUI library completely written in Haskell, not wrapping a >> popular library. > >Partly because just getting the drawing and interaction behaviour to be >acceptable would be many person-years of work. > >GUI toolkits are not especially simple things. Even if you could do it >in just 1/10th of the number of lines of code of Gtk+ or Qt it'd be a >massive undertaking. > >Duncan > > >

7 13

Re: [Haskell-cafe] Problem with question 3 about knights and knaves onw ikipedia
by Steve Schafer 10 Aug '07

10 Aug '07

On Thu, 9 Aug 2007 23:06:04 +0200, you wrote: >Is still don't get it completely... Could you give me an extra hint? I'm >getting crazy here, especially because I was really good at this stuff 20 >years ago! :) > >Here's the reasoning > >The first answer could not be "no" because from that I can infer that John >is a knight and Bill is a knave, which would mean the logician knows the >answer. > >This leaves me with 3 possibilities: > >a) Both John and Bill are knights >b) John is a knave and Bill could be anything Correct. But you forgot to recursively apply the hint. ;) The problem states that after John answers the second question, the Logician knows the solution. How can this be? What answer did John give that allows the Logician to solve the problem? Steve Schafer Fenestra Technologies Corp. http://www.fenestra.com/

1 0

how can I get template haskell macro-expanded code from inferStartState? (repeated post, now with subject)
by Thomas Hartman 10 Aug '07

10 Aug '07

(sorry, forgot the subject on my first post) In the following code which uses template haskell, how can I get back the macro-expanded code generated from $(inferStartState ''MyState) I *can* recover the macro-expanded code for $(cnst 1 "x") using a debugging technique bulat describes on his tutorial at http://www.haskell.org/bz/th3.htm You can see what's going on in the function debugTemplates below. I'm trying to do this actually, to better understand how HAppS deals with state. It's a bit opaque now since the example on the tutorial uses TH. I think I would understand it better if I had code that didn't depend on TH. (MyState is from the happs tutorial at http://www.haskell.org/haskellwiki/HAppS_tutorial ) thanks! thomas. {-# OPTIONS -fglasgow-exts -fth #-} module MyState where import HAppS import HAppS.Protocols.SimpleHTTP2 import Data.Monoid import Data.Typeable import Control.Monad.State (get, put) import Language.Haskell.TH import Language.Haskell.TH.Syntax data MyState = MySt { appVal :: Int } deriving (Read, Show, Typeable) instance Serialize MyState where encodeStringM = defaultEncodeStringM decodeStringM = defaultDecodeStringM instance Monoid MyState where mempty = MySt 0 mappend (MySt x) (MySt y) = MySt (x+y) -- in ghci... -fth, :m + -- ghci... :t (inferStartState ''MyState) :: (Quasi m) => m [Dec] $(inferStartState ''MyState) -- boilerplate that will eventually be SYB -- ghci... :t cnst 1 "x" :: (Monad m) => m Exp cnst n s = return (LamE (replicate n WildP) (LitE (StringL s))) dumpSplice splice = runQ splice >>= putStrLn . pprint debugTemplates = do dumpSplice (cnst 1 "x") dumpSplice (inferStartState ''MyState) {- *MyState> debugTemplates \_ -> "x" Template Haskell error: Can't do `reify' in the IO monad *** Exception: user error (Template Haskell failure) -} --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden. _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

2 2

Slow IO or bad code?
by Vimal 10 Aug '07

10 Aug '07

Hi I am practicing writing code in haskell, by solving problems at this site. http://spoj.pl. The problem http://spoj.pl/problems/FASHION , is pretty simple. 1. Given two lists A,B , of N numbers, sort them and take sum of products. i.e. Sum ai * bi I wrote a code, but seems to give "Time limit exceeded"! >> Beginning of CODE loop t function | t == 1 = do function | otherwise = do { function; loop (t - 1) function } prod [] [] = 0 prod (a:as) (b:bs) = a*b + prod as bs to_int :: [String] -> [Integer] to_int [] = [] to_int (x:xs) = (read x) : to_int xs doit = do n <- getLine a <- getLine b <- getLine let la = to_int (words a); lb = to_int (words b); in print (prod la lb) main = do t <- getLine loop (read t) doit << END OF CODE I would love to see if there is any improvement that can be done, to the code ... Thanks! Vimal

6 10

Operator overloading
by rodrigo.bonifacio 10 Aug '07

10 Aug '07

Hi all. I want to overload the operator "^" for working instead of the following "+++" operator: (+++) :: String -> [[String]] -> [[String]] x +++ y = [ x:e | e<-y ] How can I overload the "^" operator? Thanks a lot. Rodrigo.

2 1