February 2010 - Haskell-Cafe

Darcs fundraising 2010 - send us to ZuriHac! ($792 more by 15 Feb)
by Eric Kow 08 Feb '10

08 Feb '10

Hi everybody, Only one more week of fundraising to go! We've raised $1208 so far, which gives us another $792 to go in our final push. Can we do it? I sure hope so. Even if we do not, we'll still have raised more than we did last year, so thanks to all! If you're still thinking of helping out, now is the perfect time :-) Otherwise, stay tuned at http://darcs.net/donations.html for our progress. Eric PS. If you send me an email telling me how much you donated, I can update the donations site immediately so that folks can watch our progress bar obsessively :-) Donating by Google Checkout ---------------------------------------------------------------------- Donating via Google Checkout puts more of your donation to work, since Google charges no Checkout fees to 501(c)(3) organizations. Please visit http://darcs.net/donations.html for more details. Donating by check (USA) ---------------------------------------------------------------------- The next best option is to donate by check if you have a US bank account. Checks should be made payable to "Software Freedom Conservancy, Inc.", with "Directed donation: Darcs" in the memo. They can be mailed to Software Freedom Conservancy 1995 BROADWAY FL 17 NEW YORK NY 10023-5882 USA Donating by Paypal ---------------------------------------------------------------------- Please visit http://darcs.net/donations.html for more details. -- Eric Kow <http://www.nltg.brighton.ac.uk/home/Eric.Kow> PGP Key ID: 08AC04F9

1 0

ANN: data-ordlist-0.2
by Leon Smith 07 Feb '10

07 Feb '10

I have released data-ordlist 0.2, with a number of changes: 1. The module name is now Data.List.Ordered, instead of Data.OrdList 2. Three bugfixes: (ack!) insertSet and insertBag assumed reverse-ordered lists, nub failed to remove duplicates. Thanks to Topi Karvonen for reporting the first problem. 3. One semantic change: old_nubBy f == new_nubBy (not . f). The new version is better keeping with the spirit of the rest of the library, and makes the old nub bug much more obvious. Now nubBy is the greedy algorithm that returns a sublist such that for all binary predicates: isSortedBy pred (nubBy pred xs) == True 4. Improved documentation, I hope! Please consider taking a look and letting me know what you think. http://hackage.haskell.org/package/data-ordlist Cheers, Leon

2 2

Re: [Haskell-cafe] a beginner question: decorate-op-undecorate
by John Lato 06 Feb '10

06 Feb '10

> From: Aran Donohue <aran.donohue(a)gmail.com> > > Hi Haskell-Cafe, > > Consider a data type such as > > data Binding = Binding Var (Either Value [Value]) > > representing a variable bound either to a fixed value or that has a list of > possible values. > > I'd like to perform an operation on say, the fixed-value members of a list > of bindings. Data.Either has "partitionEithers"---I'd essentially like to > use partitionEithers, but in a way that it "peeks" into the value field of > the binding. For the sake of argument, let's say I can't or can't modify > Binding to move the Either to the outside. I think that partitionEithers is leading you down the wrong trail. If what you want to do is modify some values inside the binding, I would start with this: > mapVal :: (Either Value [Value] -> Either Value [Value]) -> Binding -> Binding > mapVal f (Binding v e) = Binding v (f e) > > mapLeft :: (a -> b) -> Either a c -> Either b c > mapLeft f = either (Left . f) Right > > -- mapRight is just fmap, but for symmetry > mapRight :: (b -> c) -> Either a b -> Either a c > mapRight = fmap > > modifyFixed :: (Value -> Value) -> Binding -> Binding > modifyFixed f b = mapVal (mapLeft f) b > > modifyList :: ([Value] -> [Value]) -> Binding -> Binding > modifyList f b = mapVal (mapRight f) b > > -- note that modifyFixed and modifyList have very nice point-free representations > -- modifyFixed = mapVal . mapLeft > -- modifyList = mapVal . mapRight Now to apply this to a list: > modifyFixedBindings :: (Value -> Value) -> [Binding] -> [Binding] > modifyFixedBindings f binds = map (modifyFixed f) binds > -- or point-free > modifyFixedBindings' = map . modifyFixed In my opinion, this would be more idiomatic if Binding were polymorphic: > data Binding' k v = Binding' k v > > instance Functor (Binding' k) where > fmap f (Binding' k v) = Binding' k (f v) > > type Binding2 = Binding' Var (Either Value [Value]) now mapVal is just fmap, and these functions are: > modifyFixed2 :: (Val -> Val) -> [Binding2] -> [Binding2] > modifyFixed2 = fmap . fmap . mapLeft > > modifyList2 :: ([Val] -> [Val]) -> [Binding2] -> [Binding2] > modifyList2 = fmap . fmap . mapRight I've typed out all the steps for clarity, but to be honest, I wouldn't bother with the Fixed and List variants, unless you're going to use them frequently. I would do just: > mapVals :: (Either Value [Value] -> Either Value [Value]) -> [Binding] -> [Binding] > mapVals f = map (\(Binding var val) -> Binding var (f val)) and leave it at that, using "mapVals" with the "either" function when necessary. I would consider making Binding polymorphic, though, so you can write the Functor instance. You may also want to look at Data.Traversable. Cheers, John

3 2

safe-lazy-io on GHC 6.12?
by Tom Tobin 06 Feb '10

06 Feb '10

After convincing myself the hard way that you can't be lazy across strict monadic results (by writing myself a "foldrM" -- yeah, I'm still a beginner), I noticed the recent discussion of safe-lazy-io vs. iteratee with interest. The safe-lazy-io package seems much easier to understand than iteratee, but it doesn't compile on GHC 6.12 (and I haven't had any luck in figuring out how to update it myself). The Hackage build log shows the same build result I'm getting [1]; is there any chance of it getting updated to work on 6.12? [1] http://hackage.haskell.org/packages/archive/safe-lazy-io/0.1/logs/failure/g…

2 1

Re: [Haskell-cafe] safe lazy IO or Iteratee?
by John Lato 06 Feb '10

06 Feb '10

> Subject: Re: [Haskell-cafe] safe lazy IO or Iteratee? > > Downside: iteratees are very hard to understand. I wrote a > decently-sized article about them trying to figure out how to make > them useful, and some comments in one of Oleg's implementations > suggest that the "iteratee" package is subtly wrong. Oleg has written > at least three versions (non-monadic, monadic, monadic CPS) and I've > no idea why or whether their differences are important. Even dons says > he didn't understand them until after writing his own iteratee-based > IO layer. More significant than, and orthogonal to, the differences between non-monadic and monadic are the two primary implementations Oleg has written. They are[1]: Design 1: newtype Iteratee el m a = Iteratee{runIter:: Stream el -> m (IterV el m a)} data IterV el m a = IE_done a (Stream el) | IE_cont (Iteratee el m a) (Maybe ErrMsg) Design 2: newtype Iteratee el m a = Iteratee{runIter:: m (IterV el m a)} data IterV el m a = IE_done a (Stream el) | IE_cont (Stream el -> Iteratee el m a) (Maybe ErrMsg With the first design, it's impossible to get the state of an iteratee without feeding it a chunk. There are other consequences too. The second design seems to require some specialized combinators, that is (>>==) and ($$), which are not required for the first version. Neither situation is ideal. The CPS version appears to remedy both flaws, but at the expense of introducing CPS at a low level (this can be hidden from the end user in many cases). I already think of iteratees as holding continuations, so to me the so-called "CPS version" is to me a double CPS. Both designs appear to offer similar performance in aggregate, although there are differences for particular functions. I haven't yet had a chance to test the performance of the CPS variant, although Oleg has indicated he expects it will be higher. The monadic/non-monadic issue is related. Non-monadic iteratees are iteratees that can't perform monadic effects when they're running (although they can still be fed from a monadic enumerator). Essentially it's the difference between "fold" and "foldM". They are simpler and more efficient because of this, but also much less powerful. Any iteratee design can support both non-monadic and monadic, but *I* don't want to support both. At least, I don't want to have double modules for everything for nearly identical functions, and polymorphic code that can handle non-monadic and monadic iteratees is non-trivial[2]. Much of my recent work has been in the consequences of these various design considerations for the next version of the iteratee library. Currently undecided, although I'm leaning towards CPS. It seems to solve a lot of problems, and the implementation details are generally cleaner too. Cheers, John [1] Both taken from http://okmij.org/ftp/Haskell/Iteratee/IterateeM.hs. Design 1 is commented out on that page. [2] At least for me. Maybe others can provide a better solution.

3 5

Simulation of interconnect network
by Roger King 06 Feb '10

06 Feb '10

I am building a simulator for an interconnect network for a multiprocessor computer. I would like to develop it in Haskell as an opportunity to learn Haskell. The network will have a number of routers with input ports and output ports and crossbars between them. I would like to simulate the protocol. This would be an event driven simulator. It would be at a high level, leaving out many details. I would like it to be fast and be able to run it on several processors. I would like to know if you have any advice. Has anyone done this before? Are there any discrete event simulators written in Haskell? R

2 1

a beginner question: decorate-op-undecorate
by Aran Donohue 06 Feb '10

06 Feb '10

Hi Haskell-Cafe, Consider a data type such as data Binding = Binding Var (Either Value [Value]) representing a variable bound either to a fixed value or that has a list of possible values. I'd like to perform an operation on say, the fixed-value members of a list of bindings. Data.Either has "partitionEithers"---I'd essentially like to use partitionEithers, but in a way that it "peeks" into the value field of the binding. For the sake of argument, let's say I can't or can't modify Binding to move the Either to the outside. What would be an idiomatic Haskell way to accomplish this? Currently I've got "liftedPartitionEithers :: [a] -> (a -> Either b c) -> ([a], [a])" which is my own version of partitionEithers that calls a selector first. Another option would be to map each Binding to a new datatype that has the Either on the outside, use partitionEithers, and map back. Thanks, Aran

5 6

Re: [Haskell-cafe] Re: programmatic DB interface?
by Magnus Therning 06 Feb '10

06 Feb '10

On Fri, Feb 5, 2010 at 10:38, Johannes Waldmann <waldmann(a)imn.htwk-leipzig.de> wrote: > >> As I posted earlier, using 'T' to separate date and time is correct >> ISO8601 according to wikipedia[1]. > > So you're saying "2009-12-20 16:55:57.297" > (returned by the psql server) is wrong, > and it should instead send "2009-12-20T16:55:57.297Z" ? Well, it isn't necessarily *wrong* ;-) "2009-12-20 16:55:57.297" is made up of two pieces, one for date and one for time. "2009-12-20T16:55:57.297Z" is made up of one piece, which specifies both date and time. This is why I believe that the function ISO8601DateFormat is correct when it provides a format for a combined date and time. > What would be the query to obtain this format? > > I don't see this mentioned anyplace on > http://www.postgresql.org/docs/8.3/interactive/functions-datetime.html Neither do I, I don't find anything relating to ISO8601 dates (they seem more concerned with ISO DOW and year). > Perhaps we take this back to haskell-cafe (or libraries?) as it might be > of general interest. Sure, why not. It was most likely a mistake on my side to drop haskell-cafe in the first place. /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus＠therning．org Jabber: magnus＠therning．org http://therning.org/magnus identi.ca|twitter: magthe

1 0

Trapping getChar before echo
by Mark Spezzano 05 Feb '10

05 Feb '10

Hi, Is there any way of trapping keystrokes in Haskell, modifying them, and then echoing? Basically I want to give the user a prompt like: > and then have whatever they type appear in UPPERCASE regardless of whether caps lock was on or not. By default Haskell seems to echo characters in whatever case they were typed. I want to sneak in a toUpper in before the Chars get echoed. Thanks Mark Spezzano

7 8

Generating repeatable arbitrary values with QuickCheck 2
by Sean Leather 05 Feb '10

05 Feb '10

I would like to generate an arbitrary (large) value to benchmark the performance of constructing that value with isomorphic types. It seems like QuickCheck might be useful in this regards. Has anyone done something similar? In versions 1.*, there was a generate function: generate :: Int -> StdGen -> Gen a -> a > generate n rnd (Gen m) = m size rnd' > where (size, rnd') = randomR (0, n) rnd > That seems to have disappeared in versions 2.*, and I didn't find a clear replacement. I came up with using the destructor for Gen: unGen :: Gen a -> StdGen -> Int -> a > The function generate seems to have a little something extra, though I'm not sure if it's necessary. Is this true, or should I write an equivalent generate function? As an aside, it would be nice to have a generate function in the library, even if it is only a wrapper for unGen. In the end, I would write something like the following: unGen arbitrary (mkStdGen 11) 5 :: [Int] > This produces, for example, [5,1,-2,-4,2]. I also want to generate the same value for a type isomorphic to [Int]. unGen arbitrary (mkStdGen 11) 5 :: List Int > Unfortunately, this produces Cons 4 (Cons 3 (Cons (-2) (Cons 0 (Cons (-1) Nil)))): same length but different values. The Arbitrary instances are the same. I had similar results with generate from QC 1. Any suggestions on how to do this? With another library perhaps? Thanks, Sean

5 10