December 2002 - Haskell-Cafe

Why no findM ? simple Cat revisited
by Ahn Ki-yung 11 Nov '03

11 Nov '03

Simple Cat (revisitied) \begin{code} import IO findM f [] = return Nothing findM f (x:xs) = do { v <- x; if f v then return (Just v) else findM f xs } isLeft (Left _) = True isLeft _ = False main = findM (isLeft) (hCat stdin) where hCat h = try (hGetLine h) : hCat h \end{code} This is my answer for the question of my own, which is posted a couple There are mapM, filterM in the Haskell 98 Standard Library. But why no findM there ? As you can see from simple cat, it seems quite useful. I think fildM should be added to the module Monad. -- Ahn Ki-yung

5 8

splatterhunks
by William Lee Irwin III 22 Apr '03

22 Apr '03

-- This program takes patch filenames as arguments and splits the patch -- files up on a hunk-by-hunk basis. I have found this useful for Linux -- kernel development, and perhaps others might find it useful in -- similar contexts where patches are the primary method of communication. module Main where import System import List main = getArgs >>= mapM_ splatterHunkFile splatterHunkFile file = mapM_ (\(f,ss) -> writeFile f (unlines ss)) . zip (map (((reverse . takeWhile (/= '/') . reverse $ file)++).("-"++).show) [1..]) . splatterHunks =<< readFile file splatterHunks ss = map (map unlines) $ zipWith (\s -> map (s:)) (map head . (splitList "diff") $ lines ss) (map (splitList "@@") . (splitList "diff") $ lines ss) splitList prefix ss = map ($ss) $ zipWith (\m n -> (if n >= 0 then take (n - m) else id) . drop m) (map fst . filter (\(n,s) -> isPrefixOf prefix s) $ zip [0..] ss) (tail (map fst . filter (\(n,s) -> isPrefixOf prefix s) $ zip [0..] ss) ++ [-1])

1 1

comonads, io
by peter＠premise.demon.co.uk 05 Apr '03

05 Apr '03

I came across an interesting paper "Codata and comonads in Haskell" by Richard Kieburtz, and some other work by Alberto Pardo on comonads. Kieburtz proposes an OI comonad, as an alternative to (or something alongside?) the IO monad. Just for reasons of symmetry, it's natural to wonder if they aren't as pervasive in functional programs as monads. Frustratingly, I can't seem to grasp the intuition. I'm aware that the state-monad s->(s,a) has a dual state-in-context comonad (s,s->a). How does the side-effect manifest itself? The (ineffective) hints the authors give revolve around the idea that side-effects "derive" from the context of a program. Any other hints? Are comonads especially appropriate for programming systems that react to changes in their environment? Is an object of OI type something like a program to react to events? I can't make the slightest sense of Kieburtz's OI co-monad, with commands like coGetChar :: OI Handle -> Char. Peter Hancock

4 6

RE: Parsing date and time specifications
by Simon Marlow 03 Jan '03

03 Jan '03

> I think it is widely agreed that the time and date structures in the > standard libraries are brok^H^H^H^Hslightly less than useful. > > I suggest you feel free to rewrite it as you see fit, and then lobby > for its inclusion in the hierarchical libraries. > > (My preju^H^Hference would be to store a date-time internally in a > posix-like manner (seconds,microsecond since the epoch).) But a ClockTime *is* implemented as (seconds,picoseconds) since the epoch. CalendarTime is just a human-readable interpretation of the ClockTime, or a way to synthesise a ClockTime from a known date/time. (BTW Peter: the weekday/yearday in a CalendarTime are ignored by the toClockTime in GHC's Time library, so you can set them to anything). I'm still not sure I understand why the Time library is considered to be broken; sure I can see that our implementation of addToClockTime is wrong (adding one minute shouldn't always be the same as adding 60 seconds, for example), but is the design fundamentally wrong? GHC's TimeExts library (package lang) is allegedly a better implementation of addToClockTime/diffClockTime, if anyone is looking for one. Cheers, Simon

5 4

Sets
by Mark T.B. Carroll 02 Jan '03

02 Jan '03

Am I right in thinking that sets of sets don't really work with GHC's Data.Set because "Set a" things aren't instances of Ord? How should I do sets of sets with it? (e.g. Set.mkSet [Set.unitSet 1] gives "No instance for (Ord (Set a))") -- Mark

3 2

Lazy streams and unsafeInterleaveIO
by Jyrinx 02 Jan '03

02 Jan '03

As an experiment for a bigger project, I cooked up a simple program: It asks for integers interactively, and after each input, it spits out the running total. The wrinkle is that the function for calculating the total should be a non-monadic stream function (that is, type [Integer] -> [Integer] so that runningTotals [1,2,3,4,5] == [1,3,6,10,15]). The task is then to write a function to return a stream of integers, grabbing them from IO-land lazily (a la getContents). My first attempts had it not displaying a running total until all input (terminated by an input of 0) had finished, at which point it spit out all the totals (i.e. it wasn't an interactive program anymore). I poked around in the docs and on the Web for a while, and found out about unsafeInterleaveIO, which solved the problem neatly (after I modified runningTotals to be less eager, as it was reading ahead by an extra integer each time). I ended up with the attached code (for GHC 5.04.2). My question is this: Is there a more elegant (i.e. non-"unsafe") way to do this? I vaguely recall from the Hudak book (which I unfortunately don't have convenient at the moment) that he used a channel for something like this (the interactive graphics stuff), but IIRC his system would be overkill for my application (including the bigger project). It doesn't seem like it should need any black magic, and concurrency (which channels need, right?) doesn't appear worth the hassle. Really, my desire comes down to a simple, safe, single-threaded way to write a function to generate a lazy stream. Is there such? Luke Maurer jyrinx_list(a)mindspring.com -- running-total -- Haskell program that takes integers as input, outputting a running total -- after each input -- Demonstrates use of lazy streams module Main where import IO import System.IO.Unsafe import Monad runningTotals :: [Integer] -> [Integer] runningTotals [] = [] runningTotals (x:xs) = rt' 0 (x:xs) where rt' tot (x:xs) = (tot+x) `seq` (tot+x):(rt' (tot+x) xs) rt' _ [] = [] -- Note that runningTotals does what appears to be a stateful calculation when -- numbers are read one at a time; however, lazy streams allow this to be a -- pure function. Haskell is cool. inputNumbers :: IO [Integer] inputNumbers = do x <- putStr "? " >> readLn if x == 0 then return [] else do xs <- (unsafeInterleaveIO inputNumbers) return (x:xs) main = do numbers <- inputNumbers mapM_ (putStrLn . (flip shows) "") (runningTotals numbers)

6 11

call china 6.2¢ www.callez.com
by promotion＠callez.com 31 Dec '02

31 Dec '02

1 0

RE: AW: slide: useful function?
by Mark Carroll 27 Dec '02

27 Dec '02

On Mon, 2 Dec 2002, David Bergman wrote: (snip) > Till then, we "Haskellers" will probably continue expressing our > patterns either directly in Haskell or using highly formal language, > with terms such as "catamorphisms". > > The virtue, and weakness, of traditional design patterns is their > vagueness and informal character, making them (1) comprehensible to the > 90% of the developer community not familiar with category theory but (2) (snip) If there are any good ways in which non-mathematicians can get to grips with these terms from category theory, they would be well worth promoting. For example, despite having a good computer science degree (in which I was at least introduced to FP, proof, etc. and even learned to draw the dual graph of hypercubes) I'm really not equipped to understand catamorphisms in terms of algebras and homomorphisms, and don't currently have time to take the math degree I fear I'd need in order to do so. Last time I was looking at category theory books I think I came to the conclusion that Lawvere and Schanuel cover things kindly but Pierce seemed to get the syllabus right, so the "right" book wasn't quite out there. My understanding of monads is already a matter of record. Does anyone know of a friendly text that might help new Haskellers to understand functors, etc. and what they mean for program design? I'm not averse to the formal language per se if it can be easily acquired; right now, I worry that I'm using Haskell suboptimally because, not only do I not know the terminology well, but I fear that I'm not even cognisant of the concepts that these terms represent. In a nutshell: if these category theory concepts indeed have an important impact in Haskell land, how to introduce them to working Haskell programmers well enough that they can use them in engineering software that's at least half as good as it could be? (I'm making the assumption here that it would be good for Haskell to be much more widely used - it shouldn't solely be for researchers.) -- Mark

3 2

RE: Record of STRefs better than STRef to a Record?
by Simon Marlow 27 Dec '02

27 Dec '02

> If I use an STRef to a record, will a new record be created > each time I want > to update a single field? Or can I expect GHC to optimize it > and have the field of the record updated in place? You'll get a new record for each update. This might not be so bad though, depending on the number of fields in your record. > Right now I'm using a record of STRefs, like: > data E s = E{ > refi :: STRef s Int, > refc :: STRef s Char > } > > but it can get a little messy, since thread s propagates to > every datatype that uses the record type in it's definition. Here's another trick if you use this route: data E s = E{ refi :: !STRef s Int, refc :: !STRef s Char } and compile with -funbox-strict-fields. This will eliminate the boxing of the STRefs. Cheers, Simon

4 4

ABD G��menlik/Green Card 2003 y�l� kay�tlar�m�z ba�lam��t�r...
by G��MENL�K/ABD 26 Dec '02

26 Dec '02

1 0