February 2008 - Haskell-Cafe

Announce: Melbourne Functional Programming Union
by Bernie Pope 12 Feb '08

12 Feb '08

Hello Haskellers, After a few years hiatus, I'm pleased to announce that the Melbourne Functional Programming Union (FPU) is back. What is the FPU? It is a group of people who are interested in all things functional programming. We hold regular informal talks, and have friendly discussions afterwards. We are situated at the University of Melbourne (Australia), but the Union is open to all comers. Obviously it helps if you live near this part of the World. To give you an idea of the kinds of things we talk about, here is a list of our most recent topics: - the GHCi debugger - Arrows for parser combinators - a curious stack overflow in Haskell - a demonstration of Coq - deriving monads from vague ideas in several easy steps (this coming Friday) Here is our old outdated web page for historical reference: http://www.cs.mu.oz.au/fpu/ A new page is under construction. At the moment, talks are held on Fridays, 1-2pm, in the ICT Building at Melbourne Uni. Contact Bernie Pope if you are interested in participating in the FPU.

1 0

example packages that use Storable in Hackage ??
by Galchin Vasili 11 Feb '08

11 Feb '08

Hello, http://hackage.haskell.org/packages/archive/pkg-list.html .. what are some packages that use Storable? Regards, Vasili

3 2

Parsec: Transforming between parsers with different token streams
by Maciej Podgurski 11 Feb '08

11 Feb '08

Hi, I'm writing a simple parser for a line-oriented language using Parsec. A group of lines is parsed by a parser that tokens are of type String. Each token is again parsed by a parser that tokens are of type Char (i.e. this parser has the Parsec type Parser a). Now I wrote a transforming function that converts a char parser to a line parser by running the char parser on the current token of the line parser and accepting the token, if the char parser did not fail: type LineParser = GenParser String () a toLineParser :: Parser a -> LineParser a toLineParser p = tokenPrim showLine nextPos testLine <?> "how to get the inner error message???" where showLine l = "\": " ++ l ++ "\"" nextPos pos t rest = incSourceLine pos 1 testLine l = case parse p "" l of Left msg -> Nothing Right res -> Just res My problem is to extract the possible error message of the inner char parser (msg) and pass it to the outer line parser. Maybe using tokenPrim is no the best approach here. Someone how can help me with that problem? Besh wishes, Maciej

1 0

Create a list without duplicates from a list with duplicates
by news＠lyra.net 11 Feb '08

11 Feb '08

Hallo! Let's suppose I have a list [a,b,c,d,c,d]. I'd like to write a function that returns a new list without duplicates (in the example [a,b,c,d]). How can I do that? What is the most general way? I'd like to use the same function for a list of Int or String or some other user defined data type. Thank for your attention!

8 9

Compulsory relation 1 to many from entity A to entity A
by news＠lyra.net 11 Feb '08

11 Feb '08

Hallo! I'd like to build a database model with winHugs that allows a "recursive relation". For example a single instance of entity "components" is related with at least another row of the entity "components" (1 to many relationship). How can I do that? Thank you for your attention!

2 1

f(g(x), h(y)) - Correct syntax
by news＠lyra.net 11 Feb '08

11 Feb '08

Hallo! I have this code: ---------------------------------------- q1 :: EName -> [ApprenticeInfo] q1 c = [apprenticeInfo n | n <- allApprentices, member ((sq4 c) (firstOf5(n))) == True] sq4 :: ESurname -> [IDB] sq4 c = (sq3 (sq1 (c))) firstOf5 :: (a,b,c,d,e) -> a firstOf5 (n,_,_,_,_) = n member :: [IDB] -> IDB -> Bool member [] y = False member(x:xs) y = (x==y) || member xs y ---------------------------------------- sq4 works correctly and returns [IDB] Unfortunately member ((sq4 c) (firstOf5(n))) gives this error: Type error in application *** Expression : sq4 c (firstOf5 n) *** Term : sq4 *** Type : ESurname -> [IDB] *** Does not match : a -> b -> c As far as I see it I'm not writing the correct syntax for a function of 2 functions. I have g(x): Esurname->[IDB] h(y): (IDB,_,_,_,_) -> IDB f(x,y): ([IDB], IDB) -> Bool I want to obtain f(g(x), h(y)) and I obtain something else. Where am I wrong? Thanks

3 2

Re: [Haskell-cafe] using the writer monad to better understand foldl and foldr, and haskell debugging techniques in general
by Thomas Hartman 11 Feb '08

11 Feb '08

same behavior with myfoldrD (:) [] [1..] -- uses Debug.Trace.trace So, I would say this proves my main point, which was that you could accomplish the same thing using the writer monad that you could do using the more "ad hoc" trace function from Debug.Trace. It's good that you point this out though, because understanding that foldr can take an infinite list and foldl not is a very key point. > 2008/2/10, Felipe Lessa <felipe.lessa(a)gmail.com>: > > On Feb 10, 2008 9:33 PM, Thomas Hartman <tphyahoo(a)gmail.com> wrote: > > > -- using writer monad > > > -- Nothing unsafe here, pure referrentially transparent goodness > > > myfoldrW f z [] = return z > > > myfoldrW f z (x:xs) = do > > > r <- (myfoldrW f z xs) > > > tell ("x,r: " ++ (show (x,r)) ++ "\n" ) > > > return $ x `f` r > > > > *Main> foldr const 0 [1..] > > 1 > > *Main> putStrLn $ snd $ runWriter $ myfoldrW const 0 [1..] > > Interrupted. > > > > One of the good things from foldr is the possibility of > > "short-circuiting", so to speak. However I don't know if it is > > possible to show this using the writer monad, as is would involve > > observing if the function is strict or not in its second argument. > > > > Cheers, > > > > -- > > Felipe. > > >

2 2

Newbie question: mutually exclusive strict / lazy
by Peter Verswyvelen 11 Feb '08

11 Feb '08

Consider the function cond x y z = if x then y else z I guess we can certainly say cond is strict in x. But what about y and z? If x is true, then cond is strict in y If x is false, then cond is strict in z So we can't really say cond is lazy nor strict in its second or third argument. Of course, this is the case for many more functions, but in the case of the if-then-else primitive, does the strictness analyzer make use of this "mutually exclusive strictness" fact? Cheers, Peter

4 4

using the writer monad to better understand foldl and foldr, and haskell debugging techniques in general
by Thomas Hartman 10 Feb '08

10 Feb '08

The following is a simple introduction to debugging techniques in haskell, illustrated with a canonical use of foldr and foldl. Comments welcome. import Control.Monad.Writer import Debug.Trace -- We use the writer monad to better understand foldl and foldr -- and show a debugging technique in haskell -- you could get similar output using Debug.Trace, but this relies on unsafePerformIO -- ... http://www.haskell.org/ghc/docs/latest/html/libraries/base/src/Debug-Trace.… -- which is Ugly. -- Though ugly, trace isn't really unsafe as far as my understanding goes. But still, I find it nice -- that there's a way to accomplish the exact same thing by using the writer or "debugger" monad -- which is pure as pure can get -- In this particular example, it doesn't matter if you use Debug.Trace or the writer monad. -- However, I am fidding around in another scenario (debugging a series of graphs using Data.Graph.Inductive) -- which seems not to lend itself well to trace. If I can find a nice way to explain what I am doing and why -- I may do a follow-up to this post describing that. -- same as prelude, I think myfoldr f z [] = z myfoldr f z (x:xs) = x `f` r where r = (myfoldr f z xs) myfoldl f z [] = z myfoldl f z (x:xs) = myfoldl f l xs where l = z `f` x -- canonical uses of fold, no debug output tfr = myfoldr (:) [] [1..10] -- copy a list tfl = myfoldl (flip (:)) [] [1..10] -- reverse a list -- debugging output using Debug.Trace (unsafePerfomIO) -- (Not really unsafe, but unsafePerformIO (which is used in the trace function) sounds kind of scary) myfoldrD f z [] = z myfoldrD f z (x:xs) | trace ("x,r: " ++ (show (x,r))) True = x `f` r where r = (myfoldrD f z xs) myfoldlD f z [] = z myfoldlD f z (x:xs) | trace (("z,x") ++ (show (z,x))) True= myfoldlD f l xs where l = z `f` x -- run these to see the functions with debug output from trace tfrD = myfoldrD (:) [] [1..10] -- copy a list tflD = myfoldlD (flip (:)) [] [1..10] -- reverse a list -- using writer monad -- Nothing unsafe here, pure referrentially transparent goodness myfoldrW f z [] = return z myfoldrW f z (x:xs) = do r <- (myfoldrW f z xs) tell ("x,r: " ++ (show (x,r)) ++ "\n" ) return $ x `f` r myfoldlW f z [] = return z myfoldlW f z (x:xs) = do tell ("z,x): " ++ (show (z,x)) ++ "\n") l <- return $ (z `f` x) myfoldlW f l xs -- display the debug output from the writer monad tfrW = putStrLn $ snd $ runWriter $ myfoldrW (:) [] [1..10] tflW = putStrLn $ snd $ runWriter $ myfoldlW (flip (:)) [] [1..10]

2 1

Re: RE: Extensible records: Static duck typing
by Ben Franksen 10 Feb '08

10 Feb '08

[redirecting discussion from @haskell to @cafe] Barney Hilken wrote: >> What about just implementing the cheapest solution that still gets >> us most >> of the way? > >> (3) If it is as cheap (to implement) as advertised then there is no >> great >> risk involved. If it turns out the missing features are a great >> show-stopper for some people (which I don't believe) then let them >> present >> their case afterwards, with good examples at hand. We can still >> decide to >> aim for a higher goal in the long term. > >> If in doubt, chose the solution that is easier to implement. > > Since this paper, there have been several proposals which can be 90% > implemented as libraries, using either functional dependencies or > associated types. These all have much more expressive type systems > than the SPJ paper, yet need very little compiler support. The > question is, which one (if any) should get this small but necessary > support? Which proposals exactly do you refer to? Where can I read about the amount of compiler support these proposals need to make them practically usable? I know about HList/OOHaskell papers+library. This is very interesting stuff but it is not something that comes even close to being usable in day-to-day programming. It is too hard to understand, the (type) error messages are completely uncomprehensible, it is completely unclear how to to make it efficient and how much compiler support would be needed to overcome all these problems. Besides, the question of "functional dependencies or associated types" is still open, right? I think it would be a very bad idea to wait until all those issues have been resolved. So, unless there are other library based proposals on the table that I am not aware of and which don't share these problems, I still think the proposal I was referring to (http://research.microsoft.com/~simonpj/Haskell/records.html) comes closest to what people want and need, while still requiring minimal implementation effort. Cheers Ben

1 0