- Haskell-Cafe - Haskell.org

Modulo-foo equivalence classes in Haskell?
by Diego Navarro 01 Feb '07

01 Feb '07

Watching the questions go by in #haskell, a still fuzzy but possibly pregnant idea popped up in my mind. Someone needed a nubBy function that returned an unique list modulo an arbitrary function foo. Well, in this case it wasn't arbitrary; he had a list of transposable matrices and wanted an unique list of matrices that couldn't be transposed into each other. I'm thinking there are many cases of fooBy functions that have to be constantly rewritten, and also a lot of ugly code by having to constantly add the modulo clauses (like in modular arithmetic). I'm inexperienced with type classes -- I've only done the simplest types and /some/ fundeps -- so I'm wondering what would be the clearest, most general way of having a Modulo-foo Eq class that could be parameterized with a function. The "transposable matrix" example shows how this could be useful for (some limited form) of data compression, but it could make some other forms of "algebraically modular" (this is not a proper term, it's me trying to get thoughts across) business rules, of which modular arithmetic is a special case. Uh, I've probably not expressed myself well enough; I hope I have a shot at trying to explain myself better if questions come up. -- -- Diego Navarro

2 3

Re: [Haskell-cafe] Channel9 Interview: Software Composability and theFu ture of Languages
by Steve Schafer 01 Feb '07

01 Feb '07

On Fri, 26 Jan 2007 17:13:43 -0000 (GMT), you wrote: >world. It also highlights some of the misconceptions that still exist and >need to be challenged, e.g. the idea that Haskell is too hard or is >impractical for real work. Haskell _is_ hard, although I don't think it's _too_ hard, or I wouldn't be here, obviously. Haskell is hard in the sense that in order to take advantage of its ability to better solve your problems, you have to THINK about your problems a lot more. Most people don't want to do that; they want the quick fix served up on a platter. And even the "intermediate" camp, the ones who are willing to invest some effort to learn a better way, are only willing to go so far. My analogy for this is the Sams PHOTOFACT series (If you're not old enough to already know what these are, visit http://www.samswebsite.com/photofacts.html) With an appropriate Sams PHOTOFACT in hand, and some very basic skills with a voltmeter and maybe an oscilloscope, you can diagnose and repair your TV with virtually no understanding of electronics at all. The audience for programming languages like Haskell is always going to be small, because it appeals to those who want to understand how the TV works, perhaps to the extent of being able to modify an existing TV or even design one from scratch. And those kind of people are much fewer and farther between than those who simply want to localize the problem enough to be able to unplug the malfunctioning part and plug in a new one. It makes sense to publicize Haskell; you can't take advantage of something you've never heard of. But I think evangelical effort is largely wasted. The people who are going to gravitate towards Haskell are the ones who are already searching for something better (they just aren't sure what it is). The rest aren't really interested, and if at some future point they become interested, they'll find the way on their own. Steve Schafer Fenestra Technologies Corp. http:/www.fenestra.com/

30 65

ANNOUNCE: binary: high performance, pure binary serialisation
by dons＠cse.unsw.edu.au 01 Feb '07

01 Feb '07

Binary: high performance, pure binary serialisation for Haskell ---------------------------------------------------------------------- The Binary Strike Team is pleased to announce the release of a new, pure, efficient binary serialisation library for Haskell, now available from Hackage: tarball: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/binary/0.2 darcs: darcs get http://darcs.haskell.org/binary haddocks: http://www.cse.unsw.edu.au/~dons/binary/Data-Binary.html 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). Encoding and decoding are achieved by the functions: encode :: Binary a => a -> ByteString decode :: Binary a => ByteString -> a which mirror the read/show functions. Convenience functions for serialising to disk are also provided: encodeFile :: Binary a => FilePath -> a -> IO () decodeFile :: Binary a => FilePath -> IO a To serialise your Haskell data, all you need do is write an instance of Binary for your type. For example, suppose in an interpreter we had the data type: import Data.Binary import Control.Monad data Exp = IntE Int | OpE String Exp Exp We can serialise this to bytestring form with the following instance: instance Binary Exp where put (IntE i) = putWord8 0 >> put i put (OpE s e1 e2) = putWord8 1 >> put s >> put e1 >> put e2 get = do tag <- getWord8 case tag of 0 -> liftM IntE get 1 -> liftM3 OpE get get get The binary library has been heavily tuned for performance, particularly for writing speed. Throughput of up to 160M/s has been achieved in practice, and in general speed is on par or better than NewBinary, with the advantage of a pure interface. Efforts are underway to improve performance still further. Plans are also taking shape for a parser combinator library on top of binary, for bit parsing and foreign structure parsing (e.g. network protocols). Several projects are using binary already for serialisation: lambdabot : state file serialisation hmp3 : mp3 file database hpaste.org : pastes are stored in memory as compressed bytestrings, and serialised to disk on MACID checkpoints Binary was developed by a team of 8 during the Haskell Hackathon, Hac 07, and received 200+ commits over that period. You can see the commit graph here: http://www.cse.unsw.edu.au/~dons/images/commits/community/binary-commits.png The use of QuickCheck was critical to the rapid, safe development of the library. The API was developed in conjunction with the QuickCheck properties that checked the API for sanity. We were thus able to improve performance while maintaining stability. We feel that QuickCheck should be an integral part of the development strategy for all new Haskell libraries. Don't write code without it! Binary is portable, using the foreign function interface and cpp, and is tested with Hugs and GHC. Happy hacking! The Binary Strike Team, Lennart Kolmodin Duncan Coutts Don Stewart Spencer Janssen David Himmelstrup Bjorn Bringert Ross Paterson Einar Karttunen

19 50

DevRandom
by Yitzchak Gale 01 Feb '07

01 Feb '07

Have I re-invented the wheel yet again? I have a module the following simple functions, that I have been using for some time: -- Read data from the system random device. -- Return Nothing if there is currently not -- enough entropy in the system random device. devRandom :: Storable a => IO (Maybe a) -- Read data from the system random device. -- If necessary, wait until there is -- enough entropy in the system random device. devRandomWait :: Storable a => IO a -- Read data from the system random device. -- If there is currently not enough entropy -- in the system random device, use a lower -- quality source of randomness instead. devURandom :: Storable a => IO a These are currently implemented only for platforms that have a /dev/random and /dev/urandom device, i.e., Unix-like. I know how to implement the third function - devURandom - on Windows, but I don't currently have a Windows box on which I can compile Haskell. I don't know how to implement the other two functions on Windows. This seems like something that is important to be in the standard library, or at least publicly accessible. Is it out there already and I am just missing it? If not, what is the best way to make this available? Is there someone who would like to do the Windows part? -Yitz

2 5

OT: Hugs users mailing list down?
by Fernan Bolando 01 Feb '07

01 Feb '07

Is the hugs mailing list down? Anybody experiencing zero trafic from hugs-users.. regards ,Fernan -- Public PGP/GnuPG key (http://www.fernski.com) pub 1024D/3576CA71 2006-02-02 Fernan Bolando Key fingerprint = FDFE C9A8 FFED C1A5 2F5C EFEB D595 AF1C 3576 CA71

1 0

Is Excel the most used -- and fucntional -- programming lanuage on Earth?
by Alexy Khrabrov 01 Feb '07

01 Feb '07

Heard that statement recently -- that Excel is a functional programming language, and the most used one -- of any programming languages -- on Earth! Is it true? Are there good examples of typical FP style in Excel? Cheers, Alexy

10 11

What is the best way to understand large programs?
by Stefan O'Rear 01 Feb '07

01 Feb '07

Hello. I am trying to fully understand yi as quickly as possible. Yi, like most big programs, consists of a number of modules; e.g. Yi.UI, Yi.Buffer, etc. Since I am not smart enough to understand all the modules at once, I am trying to understand them one at a time (is this itself the problem?); however, since mutual dependencies exist, I can't do it that easily, since understanding module A requires knowledge of the interface of module B requires knowledge of the implentation of module B requires knowledge of the interface of module A requires knowledge of the implementation of module B (and my brain's lazy fix is not very good). Yi has haddock-style comments (despite not being a library), so I tried using ./Setup.lhs haddock for readable side references, however this failed on CPP markup. After asking on #haskell, newsham noted that he had filed a cabal bug (#102), but the bug's page notes: Haddock generates interface documentation. That's only appropriate for libraries, isn't it? So, if haddock isn't what I want, what is? Or am I going at this completely wrong? What is the recommended way to approach a largish program like yi or lambdabot? (and if haddock is the wrong way to handle this, why does yi have haddock comments?) Note: I *have* managed to pretty thourougly understand lambdabot, but it took a while, wasn't particularly easy, and anyway lambdabot's dependency groups are quite small compared to eg lambdabot's. I'm hoping to make things easier for myself. Stefan

6 7

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

31 Jan '07

Hi Bruno This looks like the stuff! > Lets also have naturals reflected at the value level: > > > data Nat :: * -> * where > > Zero :: Nat Z > > Succ :: Nat n -> Nat (S n) Good plan. Of course, if you combine this method with Pablo's suggestion, you can make the class RepNat n whose method is repNat :: Nat n and then wrap your explicit versions in implicit versions. Implicit information inferred from type information but passed at run time: it's something we need to get used to. I'm glad we only need three definitions of the natural numbers, none of which is data Nat = Zero | Succ Nat > 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. That's a relief. Of course, in Epigram, you get that n is a successor for free, the moment you look at an element of Fin n. > 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. I thought that might work. Your solution is quite close to the Epigram version of the program, but you haven't covered the Zero (Fs i) (Fs j) case, which is impossible anyway. I suggest the following minor modification, whose significance is purely documentary. > 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) j = undefined {- i stinks -} > thicken (Succ _) (Fs i) Fz = Just Fz > thicken (Succ n) (Fs i) (Fs j) = fmap Fs (thicken n i j) The Epigram version explicitly refutes i in the case where it inhabits Fin Z. I thought of this example because of the other thread about empty cases. > Let me know if that helps. It certainly delivers the necessary explanation. What has happened here? Somehow, we discovered that we had to shift some data from the static language to the dynamic language so that we could give the compiler enough information to see what was ok about the program we started with. There's something subtle here. If the compiler just magically swallowed my earlier program, I think we'd lose type safety, because it allows us to manufacture a non-_|_ inhabitant of (Fin Z) fromJust (thicken (Fs undefined) Fz) = Fz :: Maybe (Fin Z) So you really need a safety check there. Another way to do it, crudely but avoiding the run time numbers, is this > thicken :: Fin (S n) -> Fin (S n) -> Maybe (Fin n) > thicken Fz Fz = Nothing > thicken Fz (Fs j) = Just j > thicken (Fs Fz) Fz = Just Fz > thicken (Fs Fz) (Fs j) = fmap Fs (thicken Fz j) > thicken (Fs (Fs i)) Fz = Just Fz > thicken (Fs (Fs i)) (Fs j) = fmap Fs (thicken (Fs i) j) That's just another way to get the strictness you need. Although it's ugly. Perhaps it's possible to pack up the explanation "every element of a finite set is an element of a nonempty finite set" as some sort of view, although not the sort of view currently being proposed, I guess. Exactly what information is needed in which phase and how totality or its absence affects what's possible are interesting and subtle questions. We live in interesting times. All the best Conor

2 1

(no subject)
by TFP 2007 31 Jan '07

31 Jan '07

Dear Colleagues, Apologies in advance for the "p.m." ommission. This is a kind reminder that the deadline for extended abstract submissions to TFP 2007 is tomorrow, Feb. 1 at 11:59 p.m. EST. We are also pleased to announce that the TFP 2007 invited speaker is John McCarthy, Stanford University. For further details, please visit our website at: http://cs.shu.edu/tfp2007/ . The TFP 2007 program committee looks forward to receiving your submissions! Best wishes, Marco ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0

TFP 2007 Submission Deadline is Tomorrow
by TFP 2007 31 Jan '07

31 Jan '07

Dear Colleagues, This is a kind reminder that the deadline for extended abstract submissions to TFP 2007 is tomorrow, Feb. 1 at 11:59 EST. We are also pleased to announce that the TFP 2007 invited speaker is John McCarthy, Stanford University. For further details, please visit our website at: http://cs.shu.edu/tfp2007/ . The TFP 2007 program committee looks forward to receiving your submissions! Best wishes, Marco ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0

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

Re: [Haskell] [Fwd: Re: Computer Language Shootout]
by dons＠cse.unsw.edu.au 31 Jan '07

31 Jan '07

simonmarhaskell: > Forwarding on behalf of Andrzej Jaworski <himself(a)poczta.nom.pl>: > > -------- Original Message -------- > From: Andrzej Jaworski <himself(a)poczta.nom.pl> > > Dear fellows, > > It is ironic that just after SPJ disclosed Comments from Brent Fulgham on > Haskell and the shootout the situation has radically changed for the worse. > Without knowing that I committed a blunder referring to the damn benchmark > http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=all > together with multicore support arguments when trying to convert a prominent > OCaml programmer to Haskell. Now they know more of us:-) > > What a language it is that jumps 30% up and down on benchmark while other > languages gracefully stay in line? Can any of you explain the reason for > this disgraceful degradation in Computer Language Shootout? The degradation is due to two things: * several entries have been disqualified (some fairly, some unfairly) Fix: fix is to submit more * the shootout haskellers stopped submitting once it was clear we'd need bytestrings to do signifcantly better. Fix: bytestring is now on the shootout machine, so we can resume I don't think there is any fundamental issue exposed, other than that we stopped updating entries, while other languages decided they should try harder. If people want to contribute, improve (or write) ByteString based versions for the slow running String programs, upload them to the wiki, and to the shootout page, http://www.haskell.org/haskellwiki/Shootout For things that have been disqualified, correct the errors, and resubmit. -- Don

7 11

are Monads with slightly stricter types in instances still Monads?
by Julien Oster 31 Jan '07

31 Jan '07

Hello, The type of the monadic bind function in the Monad class is Monad m => m a -> (a -> m b) -> m b Now, would it be possible to create a monad with a slightly stricter type, like StrictMonat m => m a -> (a -> m a) -> m a and, accepting that all steps of the computation would be bound to operate on the same type, would this be without any undesirable implications? For the sake of understanding monads better, I tried to write several custom monads which may or may not be useful. Among those were: * The Tracker Monad - tracks every result of every step of the sequential computation in a (normal, stricly typed) list inside of the monad * The Goto Monad - sequential computation that allows restarts of the computation at arbitrarily set labels within it But Haskell doesn't like those. Rightly so, because the bind function would have the stricter type mentioned above. [Otherwise the Tracker monad would have to store values of different types in its list and the Goto monad would encounter restarts at labels that process different types of the value than what has been computed so far. Both doesn't make sense.] I still have to prove wether those two monads follow the monadic laws at all, but that's part of my exercise. But let's say they follow the laws (I'm pretty sure that at least the Tracker monad does), is there anything else that would prevent the stricter typing from being legal or useful? Maybe I'm missing something simple. And would I still be able to use Haskell's "do" syntax? My first guess is yes, because it really just seems to translate into normal syntax. Thanks, Julien

2 1

Re: [Haskell-cafe] How to write elegant Haskell programms?
by John Hughes 30 Jan '07

30 Jan '07

> >I think that whole "program flow" thing is something you get used to. In > > >>true, pure functional programming (i.e. Haskell) "program flow" is a >>meaningless term, basically. Haskell is a declarative language, not an >>imperative one. You have to learn to give up that control and trust the >>runtime to Do The Right Thing. (In this regard it's similar to logic >>programming languages.) >> >> >> > >I think it's important/useful to point out that "program flow" in a pure >functional language is really a matter of data dependency. The compiler is >only free to arbitrarily order computations if there are no data >dependencies. Furthermore, monads are not special in any way (they are after >all just a useful set of combinators; e.g. >http://sigfpe.blogspot.com/2006/08/you-could-have-invented-monads-and.html) >they only wind up sequencing computations because they set up a data >dependency between the two arguments of the bind operator. > >-Jeff > And actually they don't even do that, always. A useful example in practice: then Gen monad in QuickCheck does *not* necessarily set up any data dependencies, so do in the Gen monad does not force sequencing. The fact that it's non-strict is what enables us to generate infinite random data-structures with it. John Hughes

1 0

GHC-Cygwin
by Daniil Elovkov 30 Jan '07

30 Jan '07

Hello Haskellers My desire is simple. I want GHC-Cygiwn. I spent quite a lot of time struggling, trying to build ghc-6.6-Cygwin with ghc-6.4.1-mingw32. After having patched a lot of #ifdefs and the like I finally did it. Threaded RTS doesn't seem to work, but that's ok. And all that only to eventually realise that it crashes compiling non-trivial programs. The message is 3 [main] ghc-6.6 3648 _cygtls::handle_exceptions: Error while dumping state (probably corrupted stack) I will probably fight it again some time, but now while I'm taking a rest, whould anybody be so kind, who has a working GHC-Cygwin, package it and put somewhere so that I can just take it. I suppose that many people will appreciate it. Thank you.

3 4

Simple HTTP lib for Windows?
by Greg Fitzgerald 30 Jan '07

30 Jan '07

I'd like to write a very simple Haskell script that when given a URL, looks up the page, and returns a string of HTML. I don't see an HTTP library in the standard libs, and the one in Hackage requires Windows machines have GHC and MinGW to be installed and in the PATH. Is there a simple way to get the contents of a webpage using Haskell on a Windows box? Thanks, Greg

8 16

How to write elegant Haskell programms? (long posting)
by Michael Roth 30 Jan '07

30 Jan '07

Hello list, I'm new to Haskell and I'm trying to learn how to write elegant code using Haskell. I decided to convert the following small tool, written in ruby: =========================================================== #! /usr/bin/env ruby require 'pathname' BASENAMES = %w{ mail.log thttpd.log } ARCHIVEDIR = Pathname.new '/var/log/archive' LOGDIR = Pathname.new '/var/log' class Pathname def glob glob_pattern Pathname.glob self.join(glob_pattern) end def timestamp stat.mtime.strftime '%Y%m%d' end end for basename in BASENAMES for oldname in LOGDIR.glob "#{basename}.*.gz" newname = ARCHIVEDIR.join "#{basename}.#{oldname.timestamp}.gz" puts "mv #{oldname} #{newname}" File.rename oldname, newname end end =========================================================== My solution in Haskell is: =========================================================== import System.Directory (getDirectoryContents, getModificationTime, renameFile) import System.Locale (defaultTimeLocale) import System.Time (ClockTime, toUTCTime, formatCalendarTime) import Text.Regex (mkRegex, matchRegex) import Maybe import Control.Monad logdir, archivedir :: String logfiles :: [String] logfiles = [ "mail.log", "thttpd.log" ] logdir = "/var/log" archivedir = "/var/log/archive" basename :: String -> String basename filename = head . fromMaybe [""] $ matchRegex rx filename where rx = mkRegex "^(.+)(\\.[0-9]+\\.gz)$" isLogfile :: String -> Bool isLogfile filename = basename filename `elem` logfiles timestamp :: ClockTime -> String timestamp time = formatCalendarTime defaultTimeLocale "%Y%m%d" (toUTCTime time) makeOldname :: String -> String makeOldname fn = logdir ++ '/' : fn makeNewname :: String -> String -> String makeNewname bn ts = archivedir ++ '/' : bn ++ '.' : ts ++ ".gz" move :: String -> String -> IO () move oldname newname = do putStrLn $ "mv " ++ oldname ++ ' ' : newname renameFile oldname newname main :: IO () main = do files <- liftM (filter isLogfile) (getDirectoryContents logdir) let oldnames = map makeOldname files times <- mapM getModificationTime oldnames let newnames = zipWith makeNewname (map basename files) (map timestamp times) zipWithM_ move oldnames newnames =========================================================== Ok, the tool written in Haskell works. But, to me, the source doesn't look very nice and even it is larger than the ruby solution, and more imporant, the programm flow feels (at least to me) not very clear. Are there any libraries available to make writing such tools easier? How can I made the haskell source looking more beautiful? Michael Roth

5 6

RE: [Haskell-cafe] How did you stumble on Haskell?
by Bob Davison 30 Jan '07

30 Jan '07

>From: "Alexy Khrabrov" <deliverable(a)gmail.com> >To: haskell-cafe(a)haskell.org >Subject: [Haskell-cafe] How did you stumble on Haskell? >Date: Sun, 28 Jan 2007 19:01:57 -0800 > >How do people stumble on Haskell? -- snip >What's folks most interesting ways to arrive at FP? > >Cheers, >Alexy I have been programming other stuff for years (APL, C, Assembly, Visual Basic, Java, C#) and a year or two ago I started thinking of going back to study computing a bit more formally. Reading web pages of lecturers on courses that looked interesting I found a few whose favorite language was a functional programming language called Haskell. I didn't know anything about functional programming so I just moved on. More recently I started to work my way through 'Modern compiler implementation in Java' by Andrew Appel and he seemed keen on functional programming and the book covers extending the basic language to a functional programming language. (I have have read the relevant chapter but not got as far as implementing it yet!) Just before Christmas I decided to investigate Haskell. I got hold of a copy of Graham Hutton's new book 'Programming in Haskell', which I am thoroughly enjoying. Haskell is great fun but as I dig deeper I am finding my lack of mathematical sophistication to be a problem. This leads me off thread to ask if anyone could recommend reading for someone who has done mathematics to college level, but nearly 30 years ago when many English schools didn't cover 20th century mathematics. I thought calculus was about differentiation and integration and was very surprised to discover that there were such things as 'predicate calculus', 'propositional calculus', and various flavours of 'lambda calculus'. I also have little or no idea of set theory, group theory, domain theory, combinatory logic, ... (I can just imagine the surprised looks on the faces of the mathematicians reading this. You never know computer programmers could be so ignorant, did you?) I have no idea how much of this stuff I need to know but I would certainly like to be able to learn more of this facinating new world and not just be content with learning how to write a Haskell program. I just don't know where to start. Thanks, Bob Davison _________________________________________________________________ Turn searches into helpful donations. Make your search count. http://click4thecause.live.com/search/charity/default.aspx?source=hmemtagli…

3 2

type and class problems compiling code on GHC 6.6
by José Miguel Vilaça 30 Jan '07

30 Jan '07

Dear Haskellers, I had used some code which worked fine on GHC 6.4 and now it dont compile on GHC 6.6. Can anyone please give me some workarounds and/or explanations about these 2 errors? instance InfoKind a b => InfoKind (Maybe a) b where blank = Nothing check n _ Nothing = ["No info value stored with "++n] check n g (Just a) = check n g a GHC complains that Illegal instance declaration for `InfoKind (Maybe a) b' (the Coverage Condition fails for one of the functional dependencies) In the instance declaration for `InfoKind (Maybe a) b' multiListViewGetTSelections :: MultiListView x () -> IO [x] multiListViewGetTSelections multiListView = do { Just ((model, _) :: (Var [x], x -> String)) <- unsafeObjectGetClientData multiListView ; -- more and more code } GHC complains that A pattern type signature cannot bind scoped type variables `x' unless the pattern has a rigid type context In the pattern: (model, _) :: (Var [x], x -> String) I would really appreciate some help. Best regards Miguel Vilaça

2 1

c2hs failed to process __extension__
by 向井淳 30 Jan '07

30 Jan '07

Hello all, I have a trouble when compiling a program with c2hs. The program can be seen at http://www.city5.org/prog/hstraier/, which is a binding with HyperEstraier (a fulltext search system). When I compile it at FreeBSD 6.2, I encountered the following error: | % runghc Setup.hs build | Preprocessing library hstraier-0.2... | c2hs: Error in C header file. | | /usr/include/machine/endian.h:146: (column 25) [FATAL] | >>> Syntax error! | The symbol `{' does not fit here. From the dumped file Node.i (you can see from http://www.city5.org/ Node.i), the error line is as follows: | return (__extension__ ({ register __uint32_t __X = (_x); __asm ("bswap %0" : "+r" (__X)); __X; })); c2hs fails to process __extension__? From the changelog, c2hs now can understand __extension. Is this an exceptional case? Best Regards, Jun Mukai mukai(a)jmuk.org

2 4

Re: [Haskell-cafe] Simple HTTP lib for Windows?
by brad clawsie 30 Jan '07

30 Jan '07

hi, i have popped in on this thread before to mention my own extension to Network.HTTP (http://www.b7j0c.org/content/haskell-http.html, providing get() and head()). i would like to thank bjorn for his work on Network.HTTP and echo his observation that this package needs some work and active maintainence. i would also suggest that people needing http functionality extend his package instead of writing their own or providing quick and dirty hacks that cover 80% of the problem space, as i think others have discussed. http is a simple protocol, but it is not trivial, and reference implementations need to address the standard as completely as possible. no one is going to take haskell seriously as a practical tool if the libraries don't address the corner cases, and http has some. reading through the Network.HTTP code, it does appear that the original authors and present maintainers are concerned with standards conformance, which means reading the standard. http is becoming as integral to the development environment as file access. haskell needs an authoritative native implementation or a ffi wrapper to libcurl. developers also need to know that there is *one* reference library for http support (like perl's LWP)...likewise i think the lack of a single reference library for sql/db access is also hurting haskell adoption. perl wins here again with DBI. p.s. i would gladly volunteer to maintain the http package if i thought my haskell was "export quality". it isn't. thanks brad

3 3

Error and warning messages with -O
by Marco Túlio Gontijo e Silva 29 Jan '07

29 Jan '07

Hello, I was trying to compile a library I wrote with cabal, but I couldn't because of -O. I tried removing it and it worked ok. Then I noticed that -O was giving some warnings and an error that are not present without it: marcot@quindinho:~/codigo/haskell/haskellgpc/haskellgpc$ /usr/bin/ghc -package-name HaskellGPC-0.0.1 --make -hide-all-packages -i -idist/build/autogen -i. -odir dist/build -hidir dist/build -package base-2.0 -O -Wall -Werror -fffi Algebra.Geometric.Gpc [1 of 1] Compiling Algebra.Geometric.Gpc ( Algebra/Geometric/Gpc.hs, dist/build/Algebra/Geometric/Gpc.o ) /tmp/ghc5871_0/ghc5871_0.hc:5:35: error: Algebra/Geometric/Gpc.h: Arquivo ou diretório não encontrado /tmp/ghc5871_0/ghc5871_0.hc: In function ‘r2Hk_entry’: /tmp/ghc5871_0/ghc5871_0.hc:290:0: warning: implicit declaration of function ‘gpc_polygon_clip’ /tmp/ghc5871_0/ghc5871_0.hc: In function ‘r2Hm_entry’: /tmp/ghc5871_0/ghc5871_0.hc:327:0: warning: implicit declaration of function ‘gpc_free_polygon’ marcot@quindinho:~/codigo/haskell/haskellgpc/haskellgpc$ /usr/bin/ghc -package-name HaskellGPC-0.0.1 --make -hide-all-packages -i -idist/build/autogen -i. -odir dist/build -hidir dist/build -package base-2.0 -Wall -Werror -fffi Algebra.Geometric.Gpc [1 of 1] Compiling Algebra.Geometric.Gpc ( Algebra/Geometric/Gpc.hs, dist/build/Algebra/Geometric/Gpc.o ) marcot@quindinho:~/codigo/haskell/haskellgpc/haskellgpc$ Why can't I use -O? Thanks. -- malebria Marco Túlio Gontijo e Silva Correio (MSN): malebria(a)riseup.net Jabber (GTalk): malebria(a)jabber.org Ekiga: malebria(a)ekiga.net IRC: malebria(a)irc.freenode.net malebria(a)irc.oftc.org Skype: marcotmarcot Telefone: 33346720 Celular: 98116720 Endereço: Rua Paula Cândido, 257/201 Gutierrez 30430-260 Belo Horizonte/MG Brasil

1 1

Happy outputs "parE" - ideas on what to change in my .y file?
by Mark Wassell 29 Jan '07

29 Jan '07

Sometimes happy outputs 'parE' when I run it on my .y file? I believe it is coming from a part of Grammer.lhs which has the comment line "This bit is a real mess, mainly because of the error message support." Are there any suggestions on what to change in my .y file to get over this? Thanks Mark

2 1

Multiparamater class type-inference error
by Alfonso Acosta 29 Jan '07

29 Jan '07

Hi all, Sorry if this is too GHC-specific. I'm getting this strange instantiation error when compiling the following code with GHC 6.6: No instance for (Synchronous s ((a, b) -> a) (a, b) a) arising from use of `mapSY' at SynchronousLib.lhs:342:8-16 Possible fix: add an instance declaration for (Synchronous s ((a, b) -> a) (a, b) a) In the expression: mapSY fst In the definition of `fstSY': fstSY = mapSY fst --- data Signal a = NullS | a :- Signal a deriving (Eq) class Synchronous s f1 a b | f1 -> a , f1 -> b where mapSY :: f1 -> s a -> s b delaySY :: a -> s a -> s a instance Synchronous Signal (a->b) a b where mapSY _ NullS = NullS mapSY f (x:-xs) = f x :- (mapSY f xs) delaySY e es = e:-es fstSY = mapSY fst {-- No instance for (Synchronous s ((a, b) -> a) (a, b) a) arising from use of `mapSY' at SynchronousLib.lhs:342:8-16 Possible fix: add an instance declaration for (Synchronous s ((a, b) -> a) (a, b) a) In the expression: mapSY fst In the definition of `fstSY': fstSY = mapSY fst Failed, modules loaded: AbsentExt, Vector, Queue, Signal. --} -- No error arises if fstSY is declared as fstSY a = mapSY fst a Is it GHC bug or am I supposed to declare it like that to assist type inference? Thanks in advance, Alfonso Acosta

2 2

Re: Extensible static checking of dimensions?
by Björn Buckwalter 29 Jan '07

29 Jan '07

Mike Gunter <m <at> ryangunter.com> wrote: | The very nice Buckwalter and Denney dimensional-numbers packages both | work on a fixed set of base dimensions. This is a significant | restriction for me--I want to avoid adding apples to oranges as well | as avoiding adding meters to grams. Is it possible to have an | extensible set of base dimensions? If so, how usable can such a | system be made? Is it very much worse than a system with a fixed set | of base dimensions? Mike, I apologize for not having replied to your message earlier, I have not been subscribing to the café and only recently noticed your post in the archives. As for you question, please see the literate haskell module below. It allows you to extend the set of SI base dimensions in 'Buckwalter.Dimensional' with an arbitrary number of extra dimensions. My hope is that it lifts the significant restriction you saw previously. As for the usability of such a system, once you have set up the dimensions relevant to your problem domain usage should be identical to (and seamless with) the original base dimensions. You will have to be the judge as to whether it is usable enough for you. I would certainly appreciate comments on usability. In fact I would also be interested to hear how you envision applying the functionality you requested, regardless of this modules usefulness. Also, I can't promise that the module is rock solid -- I haven't done a whole lot of testing. If you don't have the 'Buckwalter.NumTypes' and 'Buckwalter.Dimensional' modules already you can download the latest tarball with all three modules from the project web site at: http://code.google.com/p/dimensional/ Thanks, Björn Buckwalter ~~~~~~~~~~ BEGIN 'Buckwalter/Dimensional/Extensible.lhs' ~~~~~~~~~~ Buckwalter.Dimensional.Extensible -- Extensible physical dimensions Bjorn Buckwalter, bjorn.buckwalter(a)gmail.com License: BSD3 = Summary = On January 3 Mike Gunter asked[1]: | The very nice Buckwalter and Denney dimensional-numbers packages | both work on a fixed set of base dimensions. This is a significant | restriction for me--I want to avoid adding apples to oranges as | well as avoiding adding meters to grams. Is it possible to have | an extensible set of base dimensions? If so, how usable can such | a system be made? Is it very much worse than a system with a fixed | set of base dimensions? In this module we facilitate the addition an arbitrary number of "extra" dimensions to the seven base dimensions defined in 'Buckwalter.Dimensional'. A quantity or unit with one or more extra dimensions will be referred to as an "extended dimensional". = Preliminaries = Similarly with 'Buckwalter.Dimensional' this module requires GHC 6.6 or later. > {-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-} > module Buckwalter.Dimensional.Extensible > where > import Prelude hiding > ((*), (/), (+), (-), (^), sqrt, negate, pi, sin, cos, exp) > import qualified Prelude as P ((*), sin, cos, exp) > import Buckwalter.NumType (NumType, Add, Sub, Halve, Negate, Zero, Pos1) > import Buckwalter.Dimensional hiding (square, cubic, sin, cos, exp) = DExt, Apples and Oranges = We define the datatype 'DExt' which we will use to increase the number of dimensions from the seven SI base dimensions to an arbitrary number of dimensions. We make 'DExt' an instance of 'Dims' allowing us to use the 'Dimensional' type without change. > data (NumType n, Dims d) => DExt n d > instance Dims (DExt n d) Using 'DExt' we can define type synonyms for extended dimensions applicable to our problem domain. For exampel, Mike Gunter could define the 'Apples' and 'Oranges' dimensions and the corresponding quantities. ] type DApples = DExt Pos1 (DExt Zero DOne) ] type DOranges = DExt Zero (DExt Pos1 DOne) ] type Apples = Quantity DApples ] type Oranges = Quantity DOranges And while he was at it he could define corresponding units. ] apple :: Num a => Unit DApples a ] apple = Dimensional 1 ] orange :: Num a => Unit DOranges a ] orange = Dimensional 1 = Arithmetic = We get negation, addition and subtracton for free with extended dimensionals. However, we will need instances of the 'Mul', 'Div' and 'Sqrt' classes for the corresponding operations to work. > instance (Add n n' n'', Mul d d' d'') > => Mul (DExt n d) (DExt n' d') (DExt n'' d'') > instance (Sub n n' n'', Div d d' d'') > => Div (DExt n d) (DExt n' d') (DExt n'' d'') > instance (Halve n n', Sqrt d d') => Sqrt (DExt n d) (DExt n' d') Now, in order to work seamlessly with the quantities and units defined in 'Buckwalter.Dimensional' we must be able to automatically extend their dimensions when multiplying or dividing by an extended dimensional. > instance (Mul d (Dim l m t i th n j) d') => Mul (DExt x d) > (Dim l m t i th n j) > (DExt x d') > instance (Mul (Dim l m t i th n j) d d') => Mul (Dim l m t i th n j) > (DExt x d) > (DExt x d') > instance (Div d (Dim l m t i th n j) d') => Div (DExt x d) > (Dim l m t i th n j) > (DExt x d') > instance (Div (Dim l m t i th n j) d d', Negate x x') > => Div (Dim l m t i th n j) > (DExt x d) > (DExt x' d') The above instances also enable taking integer powers of extended dimensionals. To allow dimensionless quantities to be raised to the power of any other dimensionless quantity (where either or both of the quantities may be an extended dimensional) some new 'Power' instances are required. > instance (Floating a, Power a d (Dimensionless a) DOne) > => Power a (DExt Zero d) (Dimensionless a) DOne > where (Dimensional x) ^ (Dimensional y) = Dimensional (x ** y) > instance (Floating a, Power a DOne (Quantity d a) DOne) > => Power a DOne (Quantity (DExt Zero d) a) DOne > where (Dimensional x) ^ (Dimensional y) = Dimensional (x ** y) > instance (Floating a, Power a d (Quantity d' a) DOne) > => Power a (DExt Zero d) (Quantity (DExt Zero d') a) DOne > where (Dimensional x) ^ (Dimensional y) = Dimensional (x ** y) Note that the extra dimensions are dropped from the result. This is acceptable since they will be added again as necessary when multiplying or dividing by extended dimensionals. = Elementary functions, 'square' and 'cubic' = In 'Buckwalter.Dimensional' the elementary functions where restricted to dimensionals with the physical dimension 'DOne'. The same applies to the 'square' and 'cubic' functions and the 'DLength' dimension respectively. Unfortunately this implementation is inflexible in that it will not accomodate extended dimensionals even if they have no extend into the extra dimensions (i.e. the powers are all 'Zero'). To solve this problem we must provide new, generalized implementations of such functions. We start by defining the class 'BaseDim' which relates extended dimensions to the corresponding base dimension if applicable. An extended dimension has a corresponding base dimension if the powers of all extra dimensions are 'Zero'. Two 'BaseDim' instances are required. > class BaseDim d d' | d -> d' > instance BaseDim (Dim l m t i th n j) (Dim l m t i th n j) > instance (BaseDim d d') => BaseDim (DExt Zero d) d' Using 'BaseDim' in the constraints we can now redefine the elementary functions. As with the 'Power' instances above we drop the extra dimensions from the results. > sin, cos :: (Floating a, BaseDim d DOne) => Quantity d a -> Dimensionless a > sin (Dimensional x) = Dimensional (P.sin x) > cos (Dimensional x) = Dimensional (P.cos x) > exp :: (Floating a, BaseDim d DOne) => Quantity d a -> Dimensionless a > exp (Dimensional x) = Dimensional (P.exp x) Ditto for 'square' and 'cubic'. > square :: (Num a, BaseDim d DLength) => Unit d a -> Unit DArea a > square (Dimensional x) = Dimensional (x P.* x) > cubic :: (Num a, BaseDim d DLength) => Unit d a -> Unit DVolume a > cubic (Dimensional x) = Dimensional (x P.* x P.* x) (As a side note we could probably use 'BaseDim' to clean up the constraints and/or reduce the instances of 'Power' above, and perhaps for 'Mul' and 'Div'.) = References = [1] http://www.haskell.org/pipermail/haskell-cafe/2007-January/021069.html

1 0

Re: Haskell Weekly News: January 02, 2007
by Björn Buckwalter 29 Jan '07

29 Jan '07

Henning Thielemann <lemming <at> henning-thielemann.de> writes: > On Tue, 2 Jan 2007, Donald Bruce Stewart wrote: > > > Dimensional: Statically checked physical dimensions. Björn Buckwalter > > [4]announced version 0.1 of [5]Dimensional, a module for statically > > checked physical dimensions. The module facilitates calculations with > > physical quantities while statically preventing e.g. addition of > > quantities with differing physical dimensions. > > > > 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14691 > > 5. http://code.google.com/p/dimensional/ Henning, First, let me apologize for not answering earlier. I have been reluctant to subscribe to the café due to the volume of messages. Instead I tend to occasionally browse the archives. Needless to say your questions eluded me until now. The same is true for Mike Gunter's message[1] which I will respond to presently. > How is it related to this one: > http://www.haskell.org/haskellwiki/Dimensionalized_numbers > ? I ashamedly admit that I am guilty of inventing my own wheel. I haven't looked too closely at Aaron's code but I believe there are some conceptual similarities. Regarding completeness user my library supports all seven base dimensions while Aaron's library currently supports only length and time (I believe it is meant as a proof of concept (toy example in his own words) rather than a complete library). My ambition is to provide a reasonably complete library. > It should certainly be mentioned on > http://www.haskell.org/haskellwiki/Physical_units > http://www.haskell.org/haskellwiki/Libraries_and_tools/Mathematics#Physical… I have added it to the above pages. Thanks, Björn Buckwalter [1] http://www.haskell.org/pipermail/haskell-cafe/2007-January/021069.html

1 0

Converting Types to Terms
by Klaus Ostermann 29 Jan '07

29 Jan '07

I would like to have a program that can synthesize programs for a given type, composing only functions from a given library. For example, suppose my library has isZero :: Int -> Bool map :: (a -> b) -> [a] -> [b] and :: Bool -> Bool -> Bool fold :: (a -> b -> a) -> a -> [b] -> a True :: Bool (.) :: (b -> c) -> (a -> b) -> a -> c then I want to ask, say, for a program of type [Int] -> Bool and get as answer (fold and True) . (map isZero) I have found two approaches in this direction. The first one is the De-Typechecker http://www.haskell.org/pipermail/haskell/2005-March/015423.html and the other one is Djinn http://permalink.gmane.org/gmane.comp.lang.haskell.general/12747 However, with none of these approaches I managed to do anything with list functions. What else is available (besides Djinn and De-Typechecker)? Are lists a problem? In general, what are the practical and theoretical limits of these program synthesizers? Are there any overview papers for this topic? Regards, Klaus

3 2

Numeric Class Problem
by Dennis Buchmann 29 Jan '07

29 Jan '07

I've got a little problem i don't understand. I need to calculate an index for a list (by use of !!). It should look like this: floor(j * (n / p2n)) where j is an Integer, n is the length of a list, therefore Integer too, and p2n is 2^n. When i use the former line in my Haskell code (pasted at the end of this mail), i get the following error message: qc.lhs:464:16: No instance for (RealFrac Int) arising from use of `floor' at qc.lhs:464:16-36 Possible fix: add an instance declaration for (RealFrac Int) In the expression: floor (j * (n / p2n)) In the definition of `i': i = floor (j * (n / p2n)) In the definition of `genUf'': genUf' f j n | j == p2n = [] | otherwise = [(replicate (j + (y1 - y0)) 0) ++ ([1] ++ (replicate (p2n - ((j + (y1 - y0)) + 1)) 0))] ++ (genUf' f (j + 1) n) where y0 = mod j 2 y1 = xor y0 (f !! i) xor a b = mod (a + b) 2 p2n = (2 ^ n) i = floor (j * (n / p2n)) Failed, modules loaded: none. ------------------------------------------------------------------------ genUf :: [Int] -> QOp genUf f = (QOp(genUf' f 0 (length f))) where p2n = 2 ^ (length f) {- ok -} genUf' f j n | j == p2n = [] {- ok -} | otherwise = [(replicate (j+(y1-y0)) 0) ++ [1] ++ (replicate (p2n-(j+(y1-y0)+1)) 0)] ++ (genUf' f (j+1) n) where y0 = mod j 2 y1 = xor y0 (f!!i) xor a b = mod (a+b) 2 p2n = (2 ^ n) i = floor (j * (n / p2n))

3 2

Re: [Haskell-cafe] Glasgow Distributed Haskell
by Paul Johnson 28 Jan '07

28 Jan '07

Joel Reymont <joelr1(a)gmail.com> wrote: > I'm after Erlang in Haskell, if you will, for fault-tolerance and > scalability. I think the way to do Erlang in Haskell is to build a middleware layer on top of the language, not try to make the language into something it is not. In this kind of environment you need to be able to upgrade components while the system is running. The careful Haskell habit of separating stateful operations from pure functions is useful here. I gather that the HAppS project is working along similar lines, and for similar reasons. Take a look at it. http://happs.org/HAppS/README.html Paul.

2 1

Lazy ByteString Problem
by Dominic Steinitz 28 Jan '07

28 Jan '07

I've been playing around with streams as a way of implementing cryptographic functions as they seem to allow you to write code that reads more like the specification. However, I believe (and profiling seems to confirm this) that this builds up a large expression which only gets evaluated at the very end. I naively thought that using lazy bytestrings would solve the problem but the bytestring version just hangs even for small numbers. So two questions: 1. Are lazy bytestrings the answer but I am using them incorrectly? 2. What techniques are there to force evaluation and throw things that are no longer needed away? And can this be done without losing the spirit of the specification? Dominic. module Main(main) where import Data.Word import Data.Bits import Data.Char import System.Environment import qualified Data.ByteString.Lazy as BS -- ByteString version cbcl iv ps = ciphers where ciphers = 0xff `BS.cons` (BS.pack (BS.zipWith (+) feedIns ciphers)) feedIns = BS.pack (BS.zipWith xor (iv `BS.cons` ciphers) ps) -- Made up function to illustrate problem cbc iv ps = ciphers where ciphers = 0xff:(zipWith (+) feedIns ciphers) feedIns = zipWith xor (iv:ciphers) ps testl n = BS.last (cbcl 0x55 ((BS.pack . take n . repeat . fromIntegral . ord) 'a')) test :: Int -> Word8 test n = last (cbc 0x55 ((take n . repeat . fromIntegral . ord) 'a')) main = do progName <- getProgName args <- getArgs if length args /= 1 then putStrLn ("Usage: " ++ progName ++ " <length of string>") else (putStrLn . show . test . read) (args!!0)

1 1

Re: getting started with hsc (supercollider)
by Rohan Drape 28 Jan '07

28 Jan '07

Hello Alex, alex <alex(a)slab.org> writes: | Would anyone have some illustrative example code, and perhaps a | couple of tips for how to get things working well in emacs? Noting that Hsc is still experimental and not completely nailed down, though I think now quite close, and assuming that SuperCollider and ghc and emacs and the standard haskell emacs mode [1] are all installed and working, the following should get you started. * get hsc, or update if you have it (important, recent fixes required) darcs get http://slavepianos.org/rd/sw/sw-69 * compile it cd sw-69 runhaskell Setup.hs configure --prefix ~ runhaskell Setup.hs build runhaskell Setup.hs install --user (or there is a Makefile to do these three steps...) * add an appropriately modified variant of the following to ~/.emacs (push "/home/rohan/sw/sw-69/emacs" load-path) (setq hsc-interpreter "ghci") (setq hsc-help-directory "/home/rohan/sw/sw-69/Help/") (require 'hsc) * start the supercollider server scsynth -u 57110 That ought to be the end of premilinaries, this message is a 'literate SuperCollider Haskell file', save it with a .lhs extension, open it in emacs, make sure the Hsc menu comes up and read on. You can start ghci and load Sound.SC3 by typing C-cC-s (Hsc -> Haskell -> Start haskell). If the ghci output window becomes obscured you can see it again by typing C-cC-g (Hsc -> Haskell -> See output). The SuperCollider convention is that ordinary graph nodes are placed in a group with identifier 1, this node is not created when scsynth starts, so initially we will have to make it. The simplest way is to run the following line, and the simplest way to run a line is to put point on the line and type C-cC-c (Hsc -> Expression -> Run line). > withSC3 reset Doing this is so common there is a keybinding for it, C-cC-k (Hsc -> SCSynth -> Reset scsynth). To make a test sound run the following: > audition (sinOsc AR 440 0 * 0.1) This ought to play a quiet sine oscillator at A440. To see the server status type C-cC-w (Hsc -> SCSynth -> Display status). To stop the sound reset the server, ie. type C-cC-k. For expressions that don't fit on one line select the region and type C-cC-e (Hsc -> Expression -> Run region). This writes the region in a do block in a main procedure to a temporary file [2], loads the file and then runs main. > let f = sinOsc AR (xLine KR 1 1000 9 RemoveSynth) 0 * 200 + 800 > audition (sinOsc AR f 0 * 0.1) (To select a region use the mouse or place point at one end, type C-Space and move point to the other end.) To find help on a UGen or on a SuperCollider server command put point over the identifier and type C-cC-h (Hsc -> Help -> Hsc help). This opens the help file, which ought to have working examples in it, the above graph is in the sinOsc help file. To stop ghci type C-cC-x (Hsc -> Haskell -> Quit haskell). It may have been a mistake to just use .lhs as the extension, however it is not a disaster because the Hsc mode is a derivative of the haskell mode. Perhaps it ought to be changed to .hsc. Hope this is clear-ish, please send through any questions, bug reports or patches! Regards, Rohan [1] To get this loaded I have the following in ~/.emacs: (push "~/ext/src/haskell/fptools/fptools/CONTRIB/haskell-modes/emacs" load-path) (load "haskell-site-file.el") (add-hook 'haskell-mode-hook 'turn-on-haskell-doc-mode) (add-hook 'haskell-mode-hook 'turn-on-haskell-indent) (add-hook 'haskell-mode-hook 'turn-on-haskell-ghci))) [2] The file is written to /tmp/hsc.lhs, the preamble imports the following modules, this is enough to run the help file examples. import Sound.OpenSoundControl import Sound.SC3 import Control.Monad import System.Random

1 0

ANN: regex-tdfa 0.56
by Chris Kuklewicz 28 Jan '07

28 Jan '07

Greetings, My new regular expression backend "regex-tdfa" is passing all the tests I have been throwing at it, so it is time to share the good news. First up: Where is it? Version 0.56 is in my "stable" location at > darcs get --partial darcs.haskell.org:/home/darcs/packages/regex-tdfa The version that will get updated and broken more often is "unstable" at > darcs get --partial darcs.haskell.org:/home/darcs/packages/regex-unstable/regex-tdfa It needs a slightly updated regex-base package (version >= 0.80) at > darcs get --partial darcs.haskell.org:/home/darcs/packages/regex-unstable/regex-base It has only been tested (on Max OS X) with GHC 6.6 and depends on base >= 2.0 for Data.ByteString, Data.ByteString.Lazy, and Data.Sequence. ** What does regex-tdfa do? It runs POSIX regular expression searches correctly. No other regular expression backend for Haskell does this correctly. The regular expression can be chosen to be from a String, ByteString, ByteString.Lazy, or (Data.Seq Char). Independent of that choice the searched text can also be any of those types. ** Properties and benefits of regex-tdfa: It follows a known standard: POSIX. (If you find that it disagrees with the standard then I will fix it.) It is written in Haskell, so there is no C library to compile and install. Though it is currently only written for GHC 6.6, it could be ported to any other compiler with only minor changes. (I expect that if you drop the polymorphic MPTC interface of regex-base it could be made Haskell98). It works with Unicode since it can be used on [Char] (and it works if there are '\NUL' characters around). It is lazy in the regular expression: it only builds the DFA if you use it, and only builds the state it needs, which are memoized in a lazy Trie. It is lazy in the searched text, and the pure function that searches the text only evaluates the text until the next match is done and does not hold onto the initial text. Thus you could efficiently search a [Char] up to the size of the Position type, which is an Int for now. It is free, the regex-tdfa library is under a BSD-3 license. ** Does it work? Yes. The regex-posix backend that come with GHC does not run all the searches correctly: it is buggy (example at end of announcement). And the regex-posix backend is also impossibly slow -- the slowest backend by far -- orders of magnitude slower. The regex-tre backend that wraps the TRE library has exposed this very fast library to the harsh gaze of QuickCheck. The lesson from QuickCheck is to never use regex-tre because the TRE library (version 0.7.4) is buggy. For regex-tdfa backend I took/stole ideas from Ville Laurikari's Master thesis which describes the algorithm that TRE uses. And I made a pure Haskell implementation that now passes all the tests at http://www.research.att.com/~gsf/testregex/testregex.html and follows the notes at http://www.research.att.com/~gsf/testregex/re-interpretation.html and passes those tests as well. And it "passes" QuickCheck tests which actually just compare the answers that regex-posix, regex-tre, and regex-tdfa since I do not have a bug free reference implementation to compare against. ** Why the name TDFA? Tagged Deterministic Finite Automata. The Tagged part is from Ville Laurikari's thesis work. ** Speed: If you do not care only about the match as a whole and not about subexpression matching then you can set the captureGroups ExecOption to False: makeMyRegex = makeRegex defaultCompOpt myExecOpt where myExecOpt = defaultExecOpt { captureGroups = False } And redefine (=~) and (=~~) to use makeMyRegex instead of makeRegex: (=~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target) => source1 -> source -> target (=~) s r = let re = makeMyRegex r :: Regex in match re s (=~~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target,Monad m)=> source1 -> source -> m target (=~~) s r = let re = makeMyRegex r :: Regex in match re s The benefit to this is speed, as it then proceeds to run all matches of "b(..?c)?d" against a large test file *faster* than the the TRE C library backend. My compliments to those who worked on ghc and -O2. It even runs nearly as fast as regex-dfa in this mode. Thus regex-dfa is (mostly) obsolete. If you use the default and capture the subgroups then the speed is reduced by a factor of about 4. This is because of the very simple data structures that keep track of the run time state. I intend to improve this aspect of the design now that I have a working algorithm. I have not benchmarked the speed of compiling the regular expression from the String. This compiling is done with very lazy data structures, so the DFA size is really only as big as you actually explore while running the match. ** Examples of bugs in regex-posix and regex-tre: An example for regex-posix: > *Main> "ab" Posix.=~ "((a)|(b)){2,}" :: MatchArray > array (0,3) [(0,(0,2)),(1,(1,1)),(2,(0,1)),(3,(1,1)) The array holds (group #, (match offset, match length)) The 0th group is the whole match "ab". The 2nd group is (a) and it matched the first "a" and the third group is (b) and matched the "b". But the second group is a child of the first group ((a)|(b)) which matched "b". The standard requires that captured groups are nested inside their parents, and here "a" is not not nested inside "b". So the regex-posix C backend that comes with GHC is buggy. The correct answer is, where the second group matched nothing: > *Main> "ab" TDFA.=~ "((a)|(b)){2,}" :: MatchArray > array (0,3) [(0,(0,2)),(1,(1,1)),(2,(-1,0)),(3,(1,1))] An example for regex-tre: "yyyyyy" TRE.=~ "(yyy|(x?)){2,4}" array (0,2) [(0,("yyyyyy",(0,6))),(1,("yyy",(3,3))),(2,("yyy",(3,3)))],"") Here TRE reports that the second group (x?) which should only match "" or "x" somehow matched "yyy". This is even more wrong than the regex-posix bug above. The correct answer, where the second group does not match: array (0,2) [(0,("yyyyyy",(0,6))),(1,("yyy",(3,3))),(2,("",(-1,0)))],"") -- Chris Kuklewicz

1 0

Trouble understanding records and existential types
by John Ky 28 Jan '07

28 Jan '07

Hi, A while back I asked about OO programming in Haskell and discovered existential types. I understood that existential types allowed me to write heterogeneous lists which seemed sufficient at the time. Now trying to combine those ideas with records: data AnyNode = forall a. Node a => AnyNode a class Node -- yadda yadda data Branch = Branch { name :: String, description :: String, children :: [AnyNode] } data Leaf = Leaf { name :: String, value :: String } The problem here is I can't use the same 'name' field for both Branch and Leaf. Ideally I'd like the name field in the Node class, but it doesn't seem that Haskell classes are for that sort of thing. -John

8 12

getting started with hsc (supercollider)
by alex 27 Jan '07

27 Jan '07

Hi all, I'm trying to get started on using Rohan Drape's Hsc library, excited about the prospect of parsing things straight into synthesis graphs, but progress is slow. There is good library documentation with examples, but no overview of how things fit together that I can find. Would anyone have some illustrative example code, and perhaps a couple of tips for how to get things working well in emacs? Once I get up to speed I would hope to contribute a beginner's guide back. Perhaps I should be addressing this email just to Rohan, but thought others might be able to help. alex

1 0

Type infer
by Marco Túlio Gontijo e Silva 27 Jan '07

27 Jan '07

Hello, I'm trying to define a partition__ function that is like Data.Set.partition, but use State Monad: > import Data.Set > import Control.Monad.State > partition__ f = > do > snapshot <- get > let > (firsts, rest) = Set.partition f snapshot > put rest > return firsts When I try to infer it's type in ghci I got: $ ghci ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. Prelude> :load partition.hs [1 of 1] Compiling Main ( partition.hs, interpreted ) Ok, modules loaded: Main. *Main> :type partition__ partition__ :: (MonadState (Set a) t, Ord a) => (a -> Bool) -> t (Set a) Ok, then I add > partition__ :: (MonadState (Set a) t, Ord a) => (a -> Bool) -> t (Set a) to the file and then: *Main> :reload [1 of 1] Compiling Main ( partition.hs, interpreted ) partition.hs:4:0: Non type-variable argument in the constraint: MonadState (Set a) t (Use -fglasgow-exts to permit this) In the type signature for `partition__': partition__ :: (MonadState (Set a) t, Ord a) => (a -> Bool) -> t (Set a) Failed, modules loaded: none. Why do I need glasgow-exts to specify a type infered by GHCi without -fglasgow-exts? Thanks. -- malebria Marco Túlio Gontijo e Silva Correio (MSN): malebria(a)riseup.net Jabber (GTalk): malebria(a)jabber.org Ekiga: malebria(a)ekiga.net IRC: malebria(a)irc.freenode.net malebria(a)irc.oftc.org Skype: marcotmarcot Telefone: 33346720 Celular: 98116720 Endereço: Rua Paula Cândido, 257/201 Gutierrez 30430-260 Belo Horizonte/MG Brasil

4 5

Concurrency in Haskell
by Alexy Khrabrov 27 Jan '07

27 Jan '07

What's the state of concurrency in Haskell? If Erlang's main strength is light-weight parallelism, can something like that be done in Haskell? Are there good examples of useful code employing GHC concurrency features one can play with? Cheers, Alexy

4 5

newbie timing question
by Sean McLaughlin 27 Jan '07

27 Jan '07

Hello, I'm trying to write a simple function to time an application. -- this doesn't work time f x = do n1 <- CPUTime.getCPUTime let res = f x in do n2 <- CPUTime.getCPUTime return (res,n2 - n1) On a function that takes 8 seconds to complete, returns (True,46000000) According to the documentation, this time is in picoseconds, making this 46 microseconds. I also tried -- neither does this time' f x = do n1 <- Time.getClockTime let res = f x in do n2 <- Time.getClockTime return (res,Time.diffClockTimes n2 n1) It returns something on that scale for picoseconds. How can I get a rough wall clock timing of functions? Thanks! Sean

4 3

newTArrayIO
by Chad Scherrer 27 Jan '07

27 Jan '07

This seems like a natural thing to have around, but it's not in GHC 6.6... newTArrayIO :: (Enum i, Ix i) => (i, i) -> a -> IO (TArray i a) newTArrayIO (a,b) = liftM (TArray . listArray (a,b)) . sequence . zipWith ignore [a..b] . repeat . newTVarIO where ignore = flip const I haven't done any testing with this beyond type checking, but it seems like it could be useful for similar cases to newTVarIO. Has anyone else played with anything similar? -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

2 2

Re: [Haskell] FW: A history of Haskell
by Justin Bailey 27 Jan '07

27 Jan '07

On 1/25/07, Simon Peyton-Jones <simonpj(a)microsoft.com> wrote: > Many of you will know that Paul Hudak, John Hughes, Phil Wadler and I have been working on a paper called > > A History of Haskell: being lazy with class > Just wanted to say this paper is excellent, and actually a great tool for learning Haskell. I read it about 2 months after I'd been introduced to Haskell, and it made quite a few things about the language clear to me. It's clearly not a tutorial, but somehow knowing parts of the history made the language clearer. Thanks for your (and all the other authors') effort! Justin

1 0

GHC concurrency runtime "breaks" every 497 (and a bit) days
by Neil Davies 26 Jan '07

26 Jan '07

In investigating ways of getting less jitter in the GHC concurrency runtime I've found the following issue: The GHC concurrency model does all of its time calculations in "ticks" - a tick being fixed at 1/50th of a second. It performs all of these calculations in terms the number of these ticks since the Unix epoch (Jan 1970). Which is stored as an Int - unfortunately this 2^31 bits overflows every 497 (and a bit) days. When it does overflow any threads on the timer queue will either a) run immediately or b) not be run for another 497 days - depending on which way the sign changes. Also any timer calculation that spans the wrapround will not be dealt with correctly. Although this doesn't happen often (the last one was around Sat Sep 30 18:32:51 UTC 2006 and the next one will not be until Sat Feb 9 21:00:44 UTC 2008) I don't think we can leave this sort of issue in the run-time system. Take a look at the definition of getTicksofDay (in base/include/HsBase.h (non-windows) / base/cbits/Win32Utils.c) and getDelay (in base/GHC/Conc.lhs) to understand the details of the issue. I don't mind having a go at the base system to remove this problem - but before I do I would like to canvas some opinions. I'll do that in a separate thread. Neil

3 3

No Derived Read for Unboxed Arrays
by Matthew Bromberg 26 Jan '07

26 Jan '07

I was trying to convert some code from ordinary boxed array to unboxed arrays for performance reasons. Presumably the conversion, according to the GHC documentation should only involve appropriate type signatures (e.g. using UArray instead of Array) and importing Data.Array.Unboxed. However my code ultimately failed because I load a large array saved as a text file using the derived Read, Show mechanism. For some reason there is no Read function for unboxed arrays. Here is a little GHCI session showing the problem: Prelude> :m Data.Array.Unboxed Prelude Data.Array.Unboxed> let e = listArray (0,3) [0 .. 3] :: UArray Int Int Prelude Data.Array.Unboxed> let se = show e Prelude Data.Array.Unboxed> se "array (0,3) [(0,0),(1,1),(2,2),(3,3)]" Prelude Data.Array.Unboxed> let e2 = read se :: UArray Int Int <interactive>:1:9: No instance for (Read (UArray Int Int)) arising from use of `read' at <interactive>:1:9-15 Possible fix: add an instance declaration for (Read (UArray Int Int)) In the expression: read se In the expression: read se :: UArray Int Int In the definition of `e2': e2 = read se :: UArray Int Int However if I try to read it in as boxed arrays, no problem: Prelude Data.Array.Unboxed> let e2 = read se :: Array Int Int Prelude Data.Array.Unboxed> e2 array (0,3) [(0,0),(1,1),(2,2),(3,3)] Is there a reason why this doesn't work? Is it a design choice or does it merely reflect the fact that no one has gotten around to writing a read function for unboxed arrays. I imagine it would be trivial to fix this however.

4 6