- Haskell-Cafe - Haskell.org

GADTs: the plot thickens?
by Conor McBride 31 Jan '07

31 Jan '07

Hi folks A puzzle for you (and for me too). I just tried to translate an old Epigram favourite (which predates Epigram by some time) into GADT-speak. It went wrong. I had a feeling it might. I wonder how to fix it: I imagine it's possible to fix it, but that some cunning may be necessary. Here it is: Type-level Nat > data Z = Z > data S x = S x Finite sets: Fin Z is empty, Fin (S n) has one more element than Fin n > data Fin :: * -> * where > Fz :: Fin (S n) > Fs :: Fin n -> Fin (S n) The "thinning" function: thin i is the order-preserving embedding from Fin n to Fin (S n) which never returns i. > thin :: Fin (S n) -> Fin n -> Fin (S n) > thin Fz i = Fs i > thin (Fs i) Fz = Fz > thin (Fs i) (Fs j) = Fs (thin i j) Its partial inverse, "thickening" has the spec thicken i i = Nothing thicken i (thin i j) = Just j > thicken :: Fin (S n) -> Fin (S n) -> Maybe (Fin n) > thicken Fz Fz = Nothing > thicken Fz (Fs j) = Just j > thicken (Fs i) Fz = Just Fz > thicken (Fs i) (Fs j) = fmap Fs (thicken i j) The trouble is that whilst thin compiles, thicken does not. GHC rightly complains Thicken.lhs:18:32: Couldn't match expected type `n' (a rigid variable) against inferred type `S n1' `n' is bound by the type signature for `thicken' at Thicken.lhs:15:19 Expected type: Fin n Inferred type: Fin (S n1) In the first argument of `Just', namely `Fz' In the expression: Just Fz The trouble is that (Fs i) is only known to be of some type Fin (S n), so we need to return the Fz :: Fin n, and there ain't no such beast. The question is how to explain that this program actually does make some sense. One to ponder. Cheers Conor

2 1

Re: [Haskell-cafe] GADTs: the plot thickens?
by Bruno Oliveira 31 Jan '07

31 Jan '07

Hello Conor, The following seems to work: On 31 Jan 2007, at 11:46, Conor McBride wrote: > Hi folks > > A puzzle for you (and for me too). I just tried to translate an old > Epigram favourite (which predates Epigram by some time) into GADT- > speak. It went wrong. I had a feeling it might. I wonder how to fix > it: I imagine it's possible to fix it, but that some cunning may be > necessary. Here it is: > > Type-level Nat > > > data Z = Z > > data S x = S x > Lets also have naturals reflected at the value level: > data Nat :: * -> * where > Zero :: Nat Z > Succ :: Nat n -> Nat (S n) > > Finite sets: Fin Z is empty, Fin (S n) has one more element than Fin n > > > data Fin :: * -> * where > > Fz :: Fin (S n) > > Fs :: Fin n -> Fin (S n) > > The "thinning" function: thin i is the order-preserving embedding > from Fin n to Fin (S n) which never returns i. > Now we modify thin to take an extra Nat n (not needed, but just to show the duality with thickening): > thin :: Nat n -> Fin (S n) -> Fin n -> Fin (S n) > thin n Fz i = Fs i > thin (Succ n) (Fs i) (Fz) = Fz > thin (Succ n) (Fs i) (Fs j) = Fs (thin n i j) The thing to note here is that only: > thin (Succ n) (Fs i) (Fz) = Fz is well typed; if you had the case: > thin Zero (Fs i) (Fz) = Fz you get: Conor.lhs:28:21: Inaccessible case alternative: Can't match types `S n' and `Z' In the pattern: Fz In the definition of `thin': thin Zero (Fs i) (Fz) = Fz Failed, modules loaded: none. > > Its partial inverse, "thickening" has the spec > > thicken i i = Nothing > thicken i (thin i j) = Just j > > Now lets go for the thickening function: > thicken :: Nat n -> Fin (S n) -> Fin (S n) -> Maybe (Fin n) > thicken n Fz Fz = Nothing > thicken n Fz (Fs j) = Just j > thicken Zero (Fs i) Fz = Nothing > thicken (Succ _) (Fs i) Fz = Just Fz > thicken (Succ n) (Fs i) (Fs j) = fmap Fs (thicken n i j) Note that this version of thicken is more precise than the version you had -- your third case splits into two different cases now. The problem is that when you had: > thicken (Fs i) Fz = ... you need to account for two possibilities: the first possibility is (Fz :: Fin (S Zero)), to which you want to return Nothing and (Fz :: Fin (S (S n))) for which you can safely return Just Fz. Let me know if that helps. Cheers, Bruno

2 3

Paths to tree
by John Ky 31 Jan '07

31 Jan '07

Hi, I've written some code and was wondering if there was a better way to write it in terms of readability, brevity and/or efficiency. The function concerned is pathsToForest which takes a list of paths (ie. [[String]]) and converts it into a tree structure where the individual nodes are the names in the path. Siblings with the same name are merged. For instance: prettyPrint $ mergeForest $ pathsToForest [["a", "b", "c"], ["c", "b", "a"], ["a", "b", "d"]] gives: a b d c c b a Thanks -John import Data.Tree import Control.Monad data ArcData = ArcData { name :: String } deriving Show type ArcTree = Tree ArcData type ArcForest = Forest ArcData pathsToForest :: [[String]] -> ArcForest pathsToForest paths = mergeForest $ concat $ map pathToTree paths mergeForest :: ArcForest -> ArcForest mergeForest [] = [] mergeForest (x:xs) = merge x (mergeForest xs) where merge :: ArcTree -> ArcForest -> ArcForest merge tree [] = [tree] merge tree (y:ys) = if sameTreeName tree y then merge tree { subForest = mergeForest ((subForest tree) ++ (subForest y)) } ys else (y:merge tree ys) treeName :: ArcTree -> String treeName tree = name $ rootLabel $ tree sameTreeName :: ArcTree -> ArcTree -> Bool sameTreeName treeLeft treeRight = treeName treeLeft == treeName treeRight pathToTree :: [String] -> ArcForest pathToTree [] = [] pathToTree (name:subpath) = [ Node { rootLabel = ArcData { name = name } , subForest = pathToTree subpath } ] prettyPrint' :: ArcForest -> [String] prettyPrint' [] = [] prettyPrint' (x:xs) = [name $ rootLabel $ x] ++ (map (" " ++) (prettyPrint' $ subForest x)) ++ prettyPrint' xs prettyPrint :: ArcForest -> IO () prettyPrint forest = do forM_ (prettyPrint' forest) putStrLn

5 7

Fwd: [Haskell-cafe] GADTs: the plot thickens?
by Pablo Nogueira 31 Jan '07

31 Jan '07

---------- Forwarded message ---------- From: Pablo Nogueira <pirelo(a)googlemail.com> Date: 31-Jan-2007 12:04 Subject: Re: [Haskell-cafe] GADTs: the plot thickens? To: Conor McBride <ctm(a)cs.nott.ac.uk> I haven't tried this yet, but would declaring the class Nat be a starting point? class Nat n instance Nat Z instance Nat n => Nat (S n) data Fin :: * -> * where Fz :: Nat n => Fin (S n) Fs :: Nat n => Fin n -> Fin (S n) thin :: Nat n => Fin (S n) -> Fin n -> Fin (S n) thicken :: Fin (S n) -> Fin (S n) -> Maybe (Fin n) Btw, apparently we have to use GHC HEAD if we want GADTs to compile properly. The error seems very similar to the one you get when trying to write (++) for dependent lists with length encoded as GADTs. To make sure I understand, you are asking if there is a hack that will enable us to tell the Haskell type checker that n = (S n1), right? Regards, P.

1 0

Re: [Haskell] Haskell Weekly News: January 31, 2007
by dons＠cse.unsw.edu.au 31 Jan '07

31 Jan '07

Correct. Link #35. should be http://article.gmane.org/gmane.comp.lang.haskell.libraries/6109 Well spotted. xana: > Hi, > > I think link 35. is not correct... > Can you please point to the correct one? > > Best regards, > Alexandra > > > Donald Bruce Stewart wrote: > > >--------------------------------------------------------------------------- > >Haskell Weekly News > >http://sequence.complete.org/hwn/20070131 > >Issue 57 - January 31, 2007 > >---------------------------------------------------------------------------

1 0

Haskell Weekly News: January 31, 2007
by dons＠cse.unsw.edu.au 31 Jan '07

31 Jan '07

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20070131 Issue 57 - January 31, 2007 --------------------------------------------------------------------------- Welcome to issue 57 of HWN, a weekly newsletter covering developments in the [1]Haskell community. Lots of news to report after a break due to Hac '07 and POPL. 1. http://haskell.org/ Announcements lhs2tex 1.12. Andres Loeh [2]announced lhs2TeX version 1.12, a preprocessor to generate LaTeX code from literate Haskell sources. [3]lhs2TeX includes the following features: highly customized output; liberal parser; generate multiple versions of a program or document from a single source; active documents: call Haskell to generate parts of the document (useful for papers on Haskell); a manual explaining all the important aspects of lhs2TeX. 2. http://article.gmane.org/gmane.comp.lang.haskell.general/14733 3. http://www.iai.uni-bonn.de/~loeh/lhs2tex/ hscom. Krasimir Angelov [4]announced the [5]hscom library. This is a FFI library for Microsoft COM. It is far from complete and it doesn't have automatic IDL to Haskell translator but if you have ever thought to start writing you own COM library for Haskell then please take a look. It is designed to be as close as possible to the standard FFI library for C. 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14743 5. http://darcs.haskell.org/packages/hscom/ DeepArrow 0.0: Arrows for 'deep application'. Conal Elliott [6]announced the birth of [7]DeepArrow, a Haskell library for composable 'editors' of pure values. DeepArrow enables 'deep function application' in two senses: deep application of functions and application of deep functions. These tools generalize beyond values and functions, via the DeepArrow subclass of the Arrow type class. 6. http://article.gmane.org/gmane.comp.lang.haskell.general/14753 7. http://haskell.org/haskellwiki/DeepArrow Phooey 0.1: functional user interface library. Conal Elliott [8]announced version 0.1 of [9]Phooey, an arrow-based functional user interface library. New in version 0.1: documentation, text input, boolean input/output, mtl. Phooey is now used in [10]TV. 8. http://article.gmane.org/gmane.comp.lang.haskell.general/14754 9. http://haskell.org/haskellwiki/phooey 10. http://haskell.org/haskellwiki/TV TV 0.0: Tangible Values. Conal Elliott [11]announced TV, a library for composing tangible values (TVs): values that carry along external interfaces. In particular, TVs can be composed to create new TVs, and they can be directly executed with a friendly GUI, a process that reads and writes character streams, or many other kinds interfaces. Values and interfaces are combined for direct use, and separable for composability. [12]See the project page. 11. http://article.gmane.org/gmane.comp.lang.haskell.general/14755 12. http://haskell.org/haskellwiki/TV polyparse 1.00. Malcolm Wallace [13]announced the release of [14]PolyParse, a collection of parser combinator libraries in Haskell. They were all previously distributed as part of HaXml, but are now split out to make them more widely available. 13. http://article.gmane.org/gmane.comp.lang.haskell.general/14777 14. http://www.cs.york.ac.uk/fp/polyparse Data.Binary: binary serialisation. The Binary Strike Force [15]announced the release of [16]Binary, a high performance, pure binary serialisation library for Haskell. It is available from [17]Hackage and [18]darcs. The 'binary' package provides efficient serialisation of Haskell values to and from lazy ByteStrings. ByteStrings constructed this way may then be written to disk, written to the network, or further processed (e.g. stored in memory directly, or compressed in memory with zlib or bzlib). 15. http://article.gmane.org/gmane.comp.lang.haskell.general/14800 16. http://www.cse.unsw.edu.au/~dons/binary/Data-Binary.html 17. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/binary/0.2 18. http://darcs.haskell.org/binary DrIFT 2.2.1: support for Data.Binary. John Meacham [19]announced that [20]DrIFT 2.2.1 is out and now has support for the Data.Binary module. 19. http://article.gmane.org/gmane.comp.lang.haskell.general/14802 20. http://repetae.net/~john/computer/haskell/DrIFT/ A History of Haskell. Simon Peyton-Jones [21]mentioned that the paper 'A History of Haskell: being lazy with class', authored by Paul Hudak, John Hughes, Phil Wadler and Simon, is finally done. [22]You can get a copy now! 21. http://article.gmane.org/gmane.comp.lang.haskell.general/14793 22. http://research.microsoft.com/~simonpj/papers/history-of-haskell/index.htm piggybackGHC 0.1. Martin Grabmueller [23]announced the release 0.1 of [24]piggybackGHC, a small utility package for using GHC for lexing and parsing Haskell source code. The library uses the GHC library for all the hard stuff, so all supported GHC extensions are available. 23. http://article.gmane.org/gmane.comp.lang.haskell.cafe/18461 24. http://uebb.cs.tu-berlin.de/~magr/projects/piggybackGHC/doc/ regex-tdfa 0.20. Chris Kuklewicz [25]announced regex-tdfa, a 'tagged' DFA regular expression backend in pure Haskell, along with a suite of updates to the existing regex packages. 25. http://article.gmane.org/gmane.comp.lang.haskell.cafe/18553 hpaste.org. Eric Mertens [26]announced 'hpaste', the [27]Haskell Pastebin. Developed over a few days by many of the members of the Haskell irc channel, it provies a reliable paste bot with Haskell-specific capabilities. 26. http://article.gmane.org/gmane.comp.lang.haskell.cafe/18565 27. http://hpaste.org/ Haskell' This section covers the [28]Haskell' standardisation process. * [29]Views in Haskell * [30]Pattern guards * [31]Help from the community * [32]Polymorphic Components 28. http://hackage.haskell.org/trac/haskell-prime 29. http://thread.gmane.org/gmane.comp.lang.haskell.general/14766 30. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1992 31. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2002/focus=2026 32. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2002 Libraries This week's proposals and extensions to the [33]standard libraries. * [34]Splitting up the crypto package * [35]Cofunctors * [36]System.Timeout module for base * [37]Unsafe aspects of ByteString * [38]Add Data.String containing IsString(fromString) to base * [39]Make StateT in mtl lazy 33. http://haskell.org/haskellwiki/Library_submissions 34. http://article.gmane.org/gmane.comp.lang.haskell.libraries/6108 35. http://article.gmane.org/gmane.comp.lang.haskell.libraries/6108 36. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6144 37. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6152 38. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6172 39. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6174 Discussion Beautiful concurrency. Simon Peyton-Jones [40]announced that the revised draft of 'Beautiful concurrency' is now [41]online, and feedback is welcome. 40. http://article.gmane.org/gmane.comp.lang.haskell.general/14739 41. http://haskell.org/haskellwiki/Talk:SantaClausProblemV2 Even higher-order abstract syntax: typeclasses vs GADT. Oleg Kiselyov [42]demonstrated a typeclass implementation of the canonical use case for GADTs: a higher-order abstract-syntax-based embedding of a language in Haskell, with implement static and dynamic semantics of the language. The interpreter of the language is tagless and statically assured: only well-typed terms may be evaluated, and the evaluation of those does not get stuck. 42. http://article.gmane.org/gmane.comp.lang.haskell.general/14764 JHC call for volunteers. John Meacham [43]mentioned that Jhc has recently gotten a ghc back end, making it much closer to mainstream use as an optimizing 'front end' to ghc. In addition to some of jhc's crazy optimizations, it implements several extensions to the language which will likely prove interesting to play with to some. John would like to welcome any volunteers who would like to help develop the ghc back end while I work on improving the grin back end and optimizations in general, to make JHC a viable alternative compiler for Haskell. 43. http://article.gmane.org/gmane.comp.lang.haskell.general/14798 State monad strictness. Yitzchak Gale [44]pondered strictness in State monads. 44. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/18276 Using PAPI to measure performance with CPU events. Alexey Yakushev [45]described how to use the new PAPI library together with GHC to gather performance information from your CPU (cache misses, branch misprediction). At present only cache miss information is supported in a platform independent way (though not tested). Also, this implementation separates the performance information for the garbage collector and the mutator so it is quite useful if you are implementing an optimisation. 45. http://article.gmane.org/gmane.comp.lang.haskell.cafe/18315 Simple proof-carrying code in Haskell 98. Oleg Kiselyov [46]demonstrated a datatype `Terminates' that can hold only an assuredly terminating (strongly normalizable) term in untyped lambda-calculus. Furthermore, the values of the datatype `Terminates' contain all and only those untyped lambda-calculus terms with that property. To create the value `Terminates', the user submits the term in question and the proof of its termination. The proof will be verified -- and if it holds, the Terminates certificate will be created. 46. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/18375 Article review: Category Theory. David House [47]mentioned that he's written a chapter for the Wikibook that attempts to teach some basic Category Theory in a Haskell hacker-friendly fashion. 47. http://en.wikibooks.org/wiki/Haskell/Category_theory IO is not a monad. Yitzchak Gale [48]sparked a long thread on issues of parametricity and polymorphic seq in the IO monad 48. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/18569 Monad laws for fail. Ulf Norrel [49]wondered about what properties 'fail' should satisify 49. http://article.gmane.org/gmane.comp.lang.haskell.libraries/6162 Jobs Postdoctoral Research Fellow at St Andrews. Kevin Hammond [50]announced a vacancy for a postdoctoral research fellow, working with the Hume language developed jointly with [51]Heriot-Watt University. Knowledge of Haskell and other functional programming technologies is a distinct advantage. 50. http://article.gmane.org/gmane.comp.lang.haskell.general/14744 51. http://www.hume-lang.org/ Blog noise [52]Haskell news from the blogosphere. * [53]Haskell: Too Hard, or Just Hard Enough? * [54]One Month with Haskell * [55]foldr and foldl in JavaScript * [56]Haskell Revisited * [57]Haskell, first impressions (with sexy results) * [58]Haskell: bootstrapping into a clue about monads * [59]How To Use Monad Transformers * [60]Error handling in Haskell * [61]Learning Haskell inch by inch * [62]Haskell: the Basics of Type Classes * [63]Clockwork languages * [64]Fun with Haskell * [65]Programming Productivity and Programming Languages * [66]Second order folds * [67]Happy Haskell hacking * [68]Simple STM TCP server * [69]Languages and paradigms and cores, oh my! * [70]Bug Reporting * [71]High performance Haskell * [72]Threads * [73]Literate Haskell * [74]The end of free lunch CPU performance and other papers * [75]The monad behind every zipper * [76]The functional C programmer * [77]Strictly for Lazy Programmers * [78]Haskell introduction for beginners * [79]Haskell Basics * [80]Haskell laziness * [81]A First Step Into Monads * [82]More Monads: Stateful Programming * [83]Why the IO monad? * [84]Haskell epiphanette * [85]More About Language Productivty: Corbato's Law * [86]Laziness and fizzbuzz in Haskell * [87]C# looks scary * [88]Random thoughts 52. http://planet.haskell.org/ 53. http://neilbartlett.name/blog/?p=11 54. http://blogs.nubgames.com/code/?p=17 55. http://satta.org/2007/01/08/foldr-and-foldl-in-javascript/ 56. http://corfield.org/blog/index.cfm/do/blog.entry/entry/Haskell_Revisited 57. http://www.stonecode.org/blog/?p=101 58. http://www.serpentine.com/blog/2007/01/09/haskell-bootstrapping-into-a-clue… 59. http://cale.yi.org/index.php/How_To_Use_Monad_Transformers 60. http://edwinb.wordpress.com/2007/01/15/error-handling-in-haskell/ 61. http://e-scribe.com/news/328 62. http://scienceblogs.com/goodmath/2007/01/haskell_the_basics_of_type_cla_1.p… 63. http://journal.dedasys.com/articles/2007/01/17/clockwork-languages 64. http://braindump.dk/tech/2007/01/19/fun-with-haskell/ 65. http://josefsblog.blogspot.com/2007/01/programming-productivity-and.html 66. http://www.acooke.org/andrew/writing/folds.html 67. http://daniel-yokomizo.livejournal.com/6949.html 68. http://sequence.complete.org/node/258 69. http://nointernalmonologue.blogspot.com/2007/01/languages-and-paradigms-and… 70. http://japple.blogspot.com/2007/01/bug-reporting.html 71. http://www.randomhacks.net/articles/2007/01/22/high-performance-haskell 72. http://radar.oreilly.com/archives/2007/01/threads_conside.html 73. http://emresahin.net/2007/01/21/literate-programming-in-haskell/ 74. http://www.cpu.uttaruk.com/2007/01/25/the-end-of-free-lunch-cpu-performance… 75. http://sigfpe.blogspot.com/2007/01/monads-hidden-behind-every-zipper.html 76. http://jaortega.wordpress.com/2007/01/29/the-functional-c-programmer/ 77. http://floatingpoint.tinou.com/2007/01/strictly_for_la.html 78. http://blog.interlinked.org/tutorials/haskell_introduction.html 79. http://blog.interlinked.org/tutorials/haskell_2.html 80. http://blog.interlinked.org/tutorials/haskell_laziness.html 81. http://scienceblogs.com/goodmath/2007/01/haskell_a_first_step_into_mona_1.p… 82. http://scienceblogs.com/goodmath/2007/01/more_monads_stateful_programmi_1.p… 83. http://kawagner.blogspot.com/2007/01/real-functional-programming-or-why-io.… 84. http://rubynations.blogspot.com/2007/01/haskell-epiphanette.html 85. http://www.neilmix.com/2007/01/25/more-about-language-productivty-corbatos-… 86. http://mult.ifario.us/articles/2007/01/25/laziness-and-fizzbuzz-in-haskell 87. http://garybernhardt.blogspot.com/2007/01/c-30-looks-promising.html 88. http://poundbang.in/2007/01/22/post-barcamp-thoughts-comments/ Quotes of the Week * ndm: [dons] How do we serialise an Int portably? [ndm] Just use the first 29 bits * C.M.Brown: I told them they could all finish the class in 5 minutes if they used Haskell... The look of horror on the student's faces when I mentioned the 'H' word was priceless. However, they were all prepared to spend 50 minutes writing a Java program which would have the same effect. * dons: dons law: if you have a bug, you are missing a QC property * BjarneStroustrup: Within C++, there is a much smaller and cleaner language struggling to get out. * ClaudiusMaximus: Compiling with -O2 reduced the time taken by my program's execution from 28 mins to 17 seconds. * dons: Think of a monad as a spacesuite full of nuclear waste in the ocean next to a container of apples. now, you can't put oranges in the space suite or the nucelar waste falls in the ocean, *but* the apples are carried around anyway, and you just take what you need. * Runar Jordahl: Haskell has quite the following among the alpha geeks * bakert: I know all my programs can be reduced to only one tenth the size if only I can learn all these crazy functions * glguy: [on hpaste.org] you can have your code syntax colored however you like, as long as that color is 'haskell' * huschi: Programing in haskell seems a bit frustrating. i'm missing searching for errors :( * dons: I had a dream about how to write instance Binary Integer last night * bd: If a graph is reduced in a forest, and no one is around to pattern match the resulting WHNF, does it cause a space leak? * bos: [dons] and stricify, specialise and inline as appropriate till the raw bytestring Addr# start appearing [bos] um, is that next to the dilithium crystals? * kolmodin: It's nice to have static types after a bottle of wine * nmessenger: Brain explosion is like a traditional pasttime in #haskell Code Watch Thu Jan 11 05:13:59 PST 2007. Pepe Iborra. [89]Added the new :breakpoint continue option. Previously, when in a breakpoint, :quit was used to continue execution. This is not the right thing to do, so this patch restores :quit to its original meaning whether or not ghci is in an inferior session. The continue behavior is now provided by ':breakpoint continue'. I added a synonim command in :continue because it is much shorter, but this is optional About the Haskell Weekly News Each week, new editions are posted to [90]the Haskell mailing list as well as to [91]the Haskell Sequence and [92]Planet Haskell. [93]RSS is also available, and headlines appear on [94]haskell.org. Headlines are available as [95]PDF. To help create new editions of this newsletter, please see the [96]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get [97]http://www.cse.unsw.edu.au/~dons/code/hwn 89. http://article.gmane.org/gmane.comp.lang.haskell.cvs.ghc/18817 90. http://www.haskell.org/mailman/listinfo/haskell 91. http://sequence.complete.org/ 92. http://planet.haskell.org/ 93. http://sequence.complete.org/node/feed 94. http://haskell.org/ 95. http://www.cse.unsw.edu.au/~dons/code/hwn/archives/20070131.pdf 96. http://haskell.org/haskellwiki/HWN 97. http://www.cse.unsw.edu.au/~dons/code/hwn

1 0

IO in lists
by Magnus Therning 31 Jan '07

31 Jan '07

Not a very descriptive subject, I know, but here's what I'd like to do. I can take getChar and create an infinate list: listChars = getChar : listChars but how do I go about creating a finite list, e.g. a list that ends as soon as 'q' is pressed? I was thinking of something like listChars1 = do c <- lift getChar if c == 'q' then [return c] else [return c] ++ listChars1 However, that triggers an interesting behaviour in ghci: *Main> :t listChars1 <interactive>:1:0: Can't find interface-file declaration for listChars1 Probable cause: bug in .hi-boot file, or inconsistent .hi file Use -ddump-if-trace to get an idea of which file caused the error Compiling it doesn't work either: % ghc -o listio listio.hs listio.o: In function `Main_main_info': (.text+0x1bd): undefined reference to `Main_listChars1_closure' listio.o: In function `Main_main_srt': (.rodata+0x10): undefined reference to `Main_listChars1_closure' collect2: ld returned 1 exit status I was also looking briefly at ListT, bout couldn't quite see how to use basic list operations on it, e.g. ':' '++' etc. listChars2 :: ListT IO Char listChars2 = do c <- lift getChar if c == 'q' then lift $ return c else (lift $ return c) ++ listChars2 /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus(a)therning.org Jabber: magnus.therning(a)gmail.com http://therning.org/magnus Software is not manufactured, it is something you write and publish. Keep Europe free from software patents, we do not want censorship by patent law on written works. Microsoft has a new version out, Windows XP, which according to everybody is the 'most reliable Windows ever.' To me, this is like saying that asparagus is 'the most articulate vegetable ever.' -- Dave Barry

10 28

Replacing [a] with (Set c a) in Monad instance.
by Daniel McAllansmith 31 Jan '07

31 Jan '07

Hello. Given: newtype Dist a = D {unD :: [(a,Int)]} instance Monad Dist where return x = D [(x,1)] d >>= f = D [(y,q*p) | (x,p) <- unD d, (y,q) <- unD (f x)] fail _ = D [] How would one change Dist to wrap an instance of the (Data.Edison.Set c a) typeclass so that the Monad instance could be implemented in terms of e.g. singleton, unionWith, empty, etc? Thanks Daniel

3 3

Re: How did you stumble on Haskell?
by Chad Scherrer 31 Jan '07

31 Jan '07

I started using Python around 1998, and I loved the elegance of it, but I was frustrated with the performance. Around 2001 I was poking around for something that would give me better performance but still allow some nice capabilities for abstraction. I started using OCaml after reading a commentary from one of the Shootout guys that he had been impressed with it. I loved the performance and the parametrized modules, but the lack of overloading was frustrating. Once I was looking for a nice rule of thumb for when to use foldl vs. foldr, and was disappointed to hear "Just use foldl - it's tail recursive." Maybe there's a place for folding right in a strict language, but I haven't seen it. Once I was deep into OCaml, Haskell kept coming up, since so many people using OCaml also like Haskell. Seeing some elegance in "A Gentle Introduction to Haskell" and not immediately understanding it got me hooked right away. And there's a time to fold right! Chad

1 0

proposal: HaBench, a Haskell Benchmark Suite
by Kenneth Hoste 31 Jan '07

31 Jan '07

Hello, Following up and the threads on haskell and haskell-cafe, I'd like to gather ideas, comments and suggestions for a standarized Haskell Benchmark Suite. The idea is to gather a bunch of programs written in Haskell, and which are representative for the Haskell community (i.e. apps, libraries, ...). Following the example of SPEC (besides the fact that the SPEC benchmarks aren't available for free), we would like to build a database containing performance measurements for the various benchmarks in the suite. Users should be able to submit their results. This will hopefully stimulate people to take performance into account when writing a Haskell program/library, and will also serve as a valuable tool for further optimizing both applications written in Haskell and the various Haskell compilers out there (GHC, jhc, nhc, ...). This thread is meant to gather peoples thought on this subject. Which programs should we consider for the first version of the Haskell benchmark suite? How should we standarize them, and make them produce reliable performance measurement? Should we only use hardware performance counters, or also do more thorough analysis such as data locality studies, ... Are there any papers available on this subject (I know about the paper which is being written as we speak ICFP, which uses PAPI as a tool). I have created a HaskellWiki page (http://www.haskell.org/haskellwiki/ HaBench) in order to centralize ideas and suggestions. Feel free to add anything, and if you're willing to contribute to this project (in any way), add your name to the wiki for future reference. greetings, Kenneth (a.k.a. boegel) -- Statistics are like a bikini. What they reveal is suggestive, but what they conceal is vital (Aaron Levenstein) Kenneth Hoste ELIS - Ghent University kenneth.hoste(a)elis.ugent.be http://www.elis.ugent.be/~kehoste

11 18