- Haskell-Cafe - Haskell.org

Laziness through boxing
by C Rodrigues 17 Jan '07

17 Jan '07

I had a problem with strictness in the Parsec library, and I'd like to know if there's a good way to solve it. The following illustrates the problem. This raises an error when run: main = parseTest (return undefined >> return 0) "" Whereas this does not: main = parseTest (return (Just undefined) >> return 0) "" I have a parser that does parsing and name resolution at the same time, by passing the completed symbol table in as a part of the parser state. Lookups into the completed symbol table have to be lazy since that symbol table is not ready until parsing is complete. My parser kept producing <<loop>> when it ran, which turned out to be an effect of strictness in Parsec. My solution was to box all the lazy values with Just. The result feels awkward to me. It involves fromJust, and moreover, it's easy to miss a place where boxing is required, and hard to track down the cause of a <<loop>>. Is there a better way to deal with this issue? And why is Parsec strict in return values? -Chris _________________________________________________________________ >From photos to predictions, The MSN Entertainment Guide to Golden Globes has it all. http://tv.msn.com/tv/globes2007/?icid=nctagline1

2 1

Re: Newbie: Project: Missionary and Cannibal
by Paul Johnson 17 Jan '07

17 Jan '07

This is presumably your homework. See http://www.haskell.org/haskellwiki/Homework_help This kind of problem is often solved by using the List monad, so try looking at that first. Failing that, have a list of moves to make a sequence. Then make a list of all possible sequences. Then filter out the ones that break the rules. Whatever is left is the answer you want. Paul.

1 0

Higher kinds (and impredicativity?)
by Jim Apple 16 Jan '07

16 Jan '07

Why is this declaration ill-formed: data Bad t where Bad :: Bad (forall (f :: * -> *) . f) GHC 6.6 says: `f' is not applied to enough type arguments Expected kind `*', but `f' has kind `* -> *' In the type `forall f :: (* -> *). f' In the type `Bad (forall f :: (* -> *). f)' In the data type declaration for `Bad' I suppose this is because the kind inference rule is C, x : k1 |- y : * ----------------------- C |- (\forall x : k1 . y) : * I'd expect C, x : k1 |- y : k2 ----------------------- C |- (\forall x : k1 . y) : k2 Is there a foundational or an implementation reason for this restriction? Jim

2 4

Newbie: Project: Missionary and Cannibal in Haskell
by thapaps＠gmail.com 16 Jan '07

16 Jan '07

I am very new to haskell. my project is to solve Missionary and Cannibal this is what I have been given : 1. 3 Missionary and 3 Cannibal . 2. 1 boat. 3. Max passengers=2. 4. RULE: at any given time number of cannibal cannot exceed number of missionary 5. I need to move all the missionary and cannibal from one bank to the other. I am really confused as to how to proceed to solving this problem. based on 2 passenger I can come of with five different boat loads. this would lead to five different combination at each state. how would i preserve the previous state value and pass it to the next state, What would be the best way to tackle this problem? any direction any help in this will be highly appreciated.

2 1

Redefining superclass default methods in a subclass
by Brian Hulley 16 Jan '07

16 Jan '07

Hi, Looking at some of the ideas in http://www.haskell.org/haskellwiki/The_Other_Prelude , it struck me that the class system at the moment suffers from the problem that as hierarchies get deeper, the programmer is burdened more and more by the need to cut-and-paste method definitions between instances because Haskell doesn't allow a superclass (or ancestor class) method default to be redefined in a subclass. For example, consider this part of a proposal for Functor => Applicative => Monad: -- I've just used 'm' so it's easy to see what parts are relevant to Monad class Functor m where fmap :: (a -> b) -> m a -> m b class Functor m => Applicative m where return :: a -> m a (<*>) :: m (a -> b) -> m a -> m b (>>) :: m a -> m b -> m b ma >> mb = -- left as exercise for a rainy day! class Applicative m => Monad m where (>>=) :: m a -> (a -> m b) -> m b The problem with this is that whereas someone defining a Monad at the moment only needs to define (return) and (>>=), with the above, though it gives obvious advantages in flexibility, generality etc, defining a new Monad involves providing methods (in instance decls) for fmap and (<*>) as well, and the default method for (>>) is ma >> mb = (fmap (const id) ma) <*> mb (from that page above) which I'm sure everyone will agree is a *lot* more complicated than: ma >> mb = ma >>= (\_ -> mb) Not only is the first definition for (>>) more complicated, it obscures the simple fact that for monads it's just a trivial special-use case of >>= where the bound argument is ignored. Therefore I'm wondering if it would be possible to allow default methods for a superclass to be defined, or redefined, in a subclass, so we could write: class Applicative m => Monad m where (>>=) :: m a -> (a -> m b) -> m b mf <*> ma = mf >>= \f -> ma >>= \a -> return (f a) ma >> mb = ma >>= \_ = -> mb fmap f ma = ma >>= \a -> return (f a) (I know the above can be written in a more point-free style but I wrote it like that to make it easy to understand what's happening.) The essential point here (excuse the pun :-) ) is that it is impossible to write the default methods in the class in which the operation is defined, because the implementation depends on methods of the relevant subclass (and will therefore be different for different subclasses though not for each particular instance of a given ancestor class of a particular subclass). As Haskell stands at the moment, we are forced to cut and paste identical methods for each individual instance of each ancestor class of a particular subclass because we can't override an ancestor class method in the *class* decl for a subclass. The type class system at present is based on the idea that you can define related methods together and in terms of each other, at one level of the hierarchy. However as the above example shows, related methods sometimes need to be spread over the hierarchy but we still want to be able to define default implementations of them in terms of each other. Perhaps there is some reason this can't be done? Brian. -- http://www.metamilk.com

6 10

Re: [Haskell-cafe] Higher kinds (and impredicativity?)
by Jim Apple 15 Jan '07

15 Jan '07

On 1/15/07, Doaitse Swierstra <doaitse(a)cs.uu.nl> wrote: > Values that live as elements in data have to be data themselves, and > thus have to be of a type that has kind *. But the example I give doesn't have a "value" of kind * -> * living in data. The constructor is nullary, only the parameter to the type is not of kind *. This is fine in declarations like: data Good (x :: * -> *) where Good :: Good Maybe What I'm asking is why, for declarations like data OK (x :: * -> *) where OK :: OK x type Fine = OK Maybe type Evil = OK (forall (f :: * -> *) . f) Fine is allowed, while Evil is not. This is not the case for data OK' (x :: *) where OK' :: OK' x type Fine' = OK' Maybe type Evil' = OK' (forall (f :: *) . f) When both Fine' and Evil' are accpeted. Jim > On Jan 15, 2007, at 3:39 AM, Jim Apple wrote: > > > Why is this declaration ill-formed: > > > > data Bad t where > > Bad :: Bad (forall (f :: * -> *) . f) > > > > GHC 6.6 says: > > > > `f' is not applied to enough type arguments > > Expected kind `*', but `f' has kind `* -> *' > > In the type `forall f :: (* -> *). f' > > In the type `Bad (forall f :: (* -> *). f)' > > In the data type declaration for `Bad' > > > > I suppose this is because the kind inference rule is > > > > C, x : k1 |- y : * > > ----------------------- > > C |- (\forall x : k1 . y) : * > > > > I'd expect > > > > C, x : k1 |- y : k2 > > ----------------------- > > C |- (\forall x : k1 . y) : k2 > > > > Is there a foundational or an implementation reason for this > > restriction? > > > > Jim

1 1

Pattern matching
by Stefan Aeschbacher 15 Jan '07

15 Jan '07

Hi I sometimes have a function definition similar to this: myFunction x@(Constructor1 _ _ _ _ _ _) = ... myFunction x@(Constructor2 _ _ _ _ _ _ _ _) = ... which in my eyes is not very elegant and easy to type. Is there an easier way to switch on the different constructors of a type (Data.Generics certainly could be used..)? If not, has thought been put in a pattern matching possibility of the form _*. This would allow: myFunction x@(Constructor1 _*) = ... myFunction x@(Constructor2 _*) = ... Also pattern matches of the form: myFunction2 (Constructor1 _* a _*) = ... could be possible as long as the pattern is non-ambiguous (in this case, only one variable with the type of a is present in this constructor). regards Stefan

3 3

Meaning abbreviations stat file GHC
by Ron 14 Jan '07

14 Jan '07

Dear, I made a profile[1] of a test program: Where can I find documentation for the meaning of everything mentioned below? Or alternatively, can anyone explain them? Where can I see the effect of using the -xt option in this profile? Ron [1] /Main +RTS -p -s -xt -hc 1,372,408,024 bytes allocated in the heap 121,255,600 bytes copied during GC (scavenged) 6,584,692 bytes copied during GC (not scavenged) 2,768,896 bytes maximum residency (68 sample(s)) 2649 collections in generation 0 ( 1.11s) 68 collections in generation 1 ( 0.49s) 6 Mb total memory in use INIT time 0.00s ( 0.00s elapsed) MUT time 5.97s ( 6.63s elapsed) GC time 1.60s ( 1.88s elapsed) RP time 0.00s ( 0.00s elapsed) PROF time 0.19s ( 0.20s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 7.76s ( 8.71s elapsed) %GC time 20.6% (21.5% elapsed) Alloc rate 229,946,873 bytes per MUT second Productivity 76.9% of total user, 68.5% of total elapsed Ron

1 0

Are GADTs expressive? Simple proof-carrying code in Haskell98
by oleg＠pobox.com 14 Jan '07

14 Jan '07

Inspired by the recent post by Jim Apple, we demonstrate 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. As in Jim Apple's solution, 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. As in Jim Apple's solution, verification of the submitted proof has to be done at run-time, to make sure the proof is not fake, that is, has no undefined values. Our solution uses neither GADTs nor typeclasses; in fact, it is in Haskell98. Also, the required proof from the user couldn't be simpler. Jim Apple wrote: > To show how expressive GADTs are, the datatype Terminating can hold > any term in the untyped lambda calculus that terminates, and none that > don't. I don't think that an encoding of this is too surprising, but I > thought it might be a good demonstration of the power that GADTs > bring. The shown GADT encoding seems to be of the kind that is convertible to typeclasses in the straightforward way, see for example, http://pobox.com/~oleg/ftp/Haskell/GADT-interpreter.hs Inn this particular example, GADT do not bring any power. Incidentally, the typeclass encoding has an advantage: If the submitted proof is invalid, the error will be reported at compile time. There is not even a possibility of a run-time error. This is because the typeclasses approach does only type-level computations and does not look at values at all (which may as well be undefined). Placing a value into a (rank-1) datatype forces the typechecker to resolve any constraints associated with the value, or report an error if constraints are not satisfiable. However, it seems that the problem at hand admits a far simpler solution -- in Haskell98. The solution is in spirit of lightweight static capabilities. Here it is: > module PCC (Terminates, -- data constructor is not exported > make_terminates, get_term) where > > import YourFavorite.Lambda_calc > > data Terminates = Terminates{get_term::Term} > > make_terminates :: Term -> Integer -> Maybe Terminates > make_terminates term limit = > case reduce_term_nsteps term limit of > Left _ -> Nothing > Right normal_form -> Just (Terminates term) Because the data constructor is not exported, the only way to construct a value `Terminates' from which a term can be extracted is by invoking the function make_terminates. The function accepts a lambda-term, and a proof of its termination. The proof takes the form of the (upper bound of the) number of steps needed to normalize the term. The function make_terminates checks the proof, by trying to reduce the term that many steps. If the normal form is found in the process, the term is normalizable and we create the certificate. Otherwise, we conclude the termination proof does not hold and we return Nothing. This proof checking is clearly decidable. The module PCC constitutes the `trusted kernel' with respect to the Terminates datatype. The function make_terminates must be rigorously verified in order to deserve our trust. But the same should be said for the GADT or any other solution: e.g., one can easily add a new case alternative to the Normal datatype declaring Omega to be in the normal form.

3 2

mapTuple
by Marco Túlio Gontijo e Silva 14 Jan '07

14 Jan '07

Hello, is there a way to defined something as a map to use in tuples? I tried this: mapTuple f (a, b) = (f a, f b) But the type inferred to it is not as generic as I wanted: mapTuple :: (t -> t1) -> (t, t) -> (t1, t1) Then I tried a different, but not much, implementation: mapTuple' f g (a, b) = (f a, g b) mapTuple f = mapTuple' f f But the inferred type was the same. Is there a way to define a function in which I can be able to do something as this? mapTuple show ("string", True) -- malebria Marco Túlio Gontijo e Silva Correio (MSN): malebria(a)riseup.net Jabber (GTalk): malebria(a)jabber.org Telefone: 33346720 Celular: 98116720 Endereço: Rua Paula Cândido, 257/201 Gutierrez 30430-260 Belo Horizonte/MG Brasil

8 11

different performance of equivalent expression
by Alexander Vodomerov 13 Jan '07

13 Jan '07

Hello! I've run into strange effect that I can not explain. I have simple expression that can be written by two equivalent ways. However one way give much performance gain over another. Here is an example: -- apply function many times (tail-recursive) many n f x = if n == 0 then x else many (n-1) f $! (f x) -- first adder function adder1 = let r = many 5000000 sin 1.0 in \x -> x + r -- second adder function adder2 = \x -> x + many 5000000 sin 1.0 main = do putStrLn $ show $ adder1 1 putStrLn $ show $ adder1 2 putStrLn $ show $ adder1 3 putStrLn $ show $ adder1 4 putStrLn $ show $ adder2 1 putStrLn $ show $ adder2 2 putStrLn $ show $ adder2 3 putStrLn $ show $ adder2 4 If you run program it think some seconds performing math, and them prints 4 results immediately. But with adder2 function, it perform calculation in every call, which can be seen visually. It seems that compiler is able to "cache" in some way long computation in first case, but not in second. I always thought that let a = b in x + a is just a syntactic sugar for x + b. Is it wrong? Of course, this is just a toy example. In reality I was writing run-time compilation. Suppose, you have an simple arithmetic expression with variables. data Expr = Var String | Add Expr Expr | Mul Expr Expr | ... type Env = Map.Map String Double compile :: Expr -> (Env -> Double) compile e = case e of Var n -> \env -> env Map.! n Add e1 e2 -> \env -> (compile e1) env + (compile e2) env Mul e1 e2 -> \env -> (compile e1) env * (compile e2) env .... The same thing occur here. Expressions (compile e1) and (compile e2) are re-evaluated every time when compiled expression is run with some environment. So, it is much more an interpretation than compilation. I want that compile function returns expression that are pre-evaluated as much as possible to maximally speed up subsequent evaluation in different environments. How can I force (compile e1) to be evaluated eagerly in case line for Add/Mul? P.S. I'm using GHC 6.6 on Debian Linux (x86 arch). With best regards, Alexander.

3 4

STM and random numbers
by Chad Scherrer 13 Jan '07

13 Jan '07

Hi, I'd like to be able to use randomIO, but I'm working within the context of STM. Is there a way to get these working together happily? For now, I guess I could kludgingly use unsafePerformIO inside STM (it's the other way around that's not allowed, right?), but I would need to be sure it doesn't get inlined. Thanks, Chad

9 10

MissingH: profiler support?
by Chris Eidhof 13 Jan '07

13 Jan '07

Hey all, I'm trying to profile my application, which makes use of MissingH. But when compiling with -prof -auto-all, I get the following error: > Language.hs:8:7: > Could not find module `Data.String': > Perhaps you haven't installed the profiling libraries for > package MissingH-0.18.0? > Use -v to see a list of the files searched for. When compiling without those options, everything works just fine. I built missingh from source, and added -prof -auto-all to GHCPARMS, and did a ./setup configure,make,install and still no result. Does anyone know what could be wrong? I'd really like to keep using MissingH and having profiling support at the same time. Thanks, -chris

6 10

building hare on ghc-6.6
by Yang 12 Jan '07

12 Jan '07

how do i build hare on ghc-6.6? after removing all references to package lang from myghc--make, i get: RefacUtils.hs:54:5: parse error on input `HasModName' this just seems like a normal class being exported. the makefile proceeds past this to build a bunch of other files fine. if i ignore this and try loading the emacs file and entering haskell-refac-mode on a .hs buffer i get: Can't exec program: /home/yang/tmp/pkg/pure/todo/HaRe_20012006/refactorer/pfe

2 1

advice on architecting a library (and haskell software in general)
by Yang 12 Jan '07

12 Jan '07

hi all, i'm looking for advice on how to architect a simple widget library for vty/hscurses, but these beginner-level questions should apply to haskell applications in general. input/requests on any aspect of my design would be greatly appreciated - in return perhaps you'll get something you'd actually want to use! i have studied in detail various haskell curses/vty apps, including yi, hmp3, riot, and hscurses.widgets/contactmanager. my immediate goal is to produce a set of composable widgets and a flexible framework that - as much as possible - reduces the amount of code a user has to write. my eventual goal is to make a functional gui library, along the lines of fruit/wxfruit/fg. to this end i've also read their literature, but i still do not understand enough about arrows/yampa/afrp. i currently have a tree of widgets, some of which can receive focus. this allows them to alter the program's key handling, but in a certain order based on the hierarchy. e.g., in my program, at the top-level, hitting either 'q' or 'f12' quits the program. when we focus on a container, pressing 'tab' will cycle focus among the subwidgets. when we focus on a text box, the key bindings layer, so that 'q' inserts a character into the text box, and 'f12' still exits and 'tab' still cycles focus. here's a simplified synopsis of the types (omits details like layout): class Widget w where output :: Bool {- whether we have focus -} -> w -> Output data Output = Output Image (Maybe CursorPos) KeyHandler type Image = [[(Char,Attr)]] -- Attr is just the text decoration (colors) type CursorPos = (Int,Int) type KeyHandler = ??? i'm guessing the most flexible type for KeyHandler could be Key -> IO (), but is this really the only/best approach? (every time i fall back to IO, i feel i'm missing something/a puppy dies/etc.) currently, this is what i have: type KeyHandler = Key -> AppState -> AppState -- maps to a state updater data AppState = AppState { rootWidget :: Widget, actualAppState :: ..., ... } but this has a number of apparent issues, including: - no decoupling of UI and app - that is, the key handlers that the widgets return have complete knowledge of the application state. so for instance, this particular text box knows that its key handler should be: handler key state = let oldPos = cursorPos $ someTextBox $ rootWidget $ state in case key of Left -> state { rootWidget { someTextBox { cursorPos = oldPos - 1 } } } ... - on key press, can't save to a file or otherwise do anything in IO. - this isn't going to scale - as my AppState grows and grows, we're throwing away and reconstructing a lot of state. and the coding style it demands is pretty clumsy, as demonstrated above. but if we switch to IO (): - still doesn't help decouple the library from the app. the above example key handling code snippet would be the same (i.e. still very clumsy), except that we'd be reading/writing the state from/to an IORef or MVar. - certainly, not all actions need IO. in fact, my current application is just a viewer, and thus needs no IO at all. - requires a global IORef or MVar - i don't know how to address the performance problem without resorting to sprinkling IORefs or MVars everywhere in the state structure, thus strangling the app into IO everywhere other open questions: - how should the "top-most" code work? currently, my app's main has a tiny event loop that feeds keys through a Chan to a State-ful function ([Key] -> State AppState [Image]) and then to the final drawing function ([Image] -> IO ()). however, depending on the resolutions to the above issues, this may radically change. - how should i compose the various key handlers? this, again, will depend. related work: yi/hmp3 also have one large piece of state in a global mvar (allows multiple threads to update it/trigger a redraw, instead of only redrawing in response to key events), with no attempt to decouple the UI and app parts of that state. event handling is done by a lexer that matches regex key patterns to IO () - this doesn't couple key handling with the UI components, and is thus not composable. (i thought the idea of using a lexer as the state automata was good - there may be some way to make this more composable, too, if the regex ever fails.) riot's UI code operates mostly in StateT Riot IO (), where Riot is again a monolithic application state. again, no attempt at decoupling or composability is made. hscurses.widgets operates mostly in IO (), and 'activating' (focusing) on widgets hands over the event loop completely. i hope i explained my design problems clearly. i've used haskell a bunch for various small text-processing scripts, but decided to try to use it for a "real" application that has little to do with parsing or other purported strengths of the language. i believe other new haskellers may relate to some of these issues. thanks! yang

2 1

CTRL+C in ghci.exe
by John Ky 12 Jan '07

12 Jan '07

Hi, Is it possible to use CTRL+C or equivalent to interrupt a computation or I/O and return to the ghci prompt? Thanks -John

4 4

Monad Set via GADT
by Roberto Zunino 12 Jan '07

12 Jan '07

To improve my understanding of GADT, I tried to define a Set datatype, with the usual operations, so that it can be made a member of the standard Monad class. Here I report on my experiments. First, I recap the problem. Data.Set.Set can not be made a Monad because of the Ord constraint on its parameter, while e.g. (return :: a -> m a) allows any type inside the monad m. This problem can be solved using an alternative monad class (restricted monad) so that the Ord context is actually provided for the monad operations. Rather, I aimed for the standard Monad typeclass. To avoid reinventing Data.Set.Set, my datatype is based on that. Basically, when we know of an Ord context, we use a Set. Otherwise, we use a simple list representation. Using a list is just enough to allow the implementation of return (i.e. (:[])) and (>>=) (i.e. map and (++)), so while not being very efficient, it is simple. Other non-monadic operators require an Ord context, so that we can turn lists into Set. My first shot at this was: data SetM a where L :: [a] -> SetM a SM :: Ord a => Set.Set a -> SetM a However, this was not enough to convince the type checker to use the Ord context stored in SM. Specifically, performing union with union (SM m1) (SM m2) = SM (m1 `Set.union` m2) causes GHC to report "No instance for (Ord a)". After some experiments, I found the following, using a type equality witness: data Teq a b where Teq :: Teq a a data SetM a where L :: [a] -> SetM a SM :: Ord w => Teq a w -> Set.Set w -> SetM a Now if I use union (SM p1 m1) (SM p2 m2) = case (p1,p2) of (Teq,Teq) -> SM Teq (m1 `Set.union` m2) it typechecks! This rises some questions I cannot answer: 1) Why the first version did not typececk? 2) Why the second one does? 3) If I replace (Teq a w) with (Teq w a), as in SM :: Ord w => Teq w a -> Set.Set w -> SetM a then union above does not typecheck! Why? I guess the type variable unification deriving from matching Teq is not symmetric as I expect it to be... Below, I attach the working version. Monad and MonadPlus instances are provided for SetM. Conversions from/to Set are also provided, requiring an Ord context. "Efficient" return and mzero are included, forcing the Set representation to be used, and requiring Ord (these could also be derived from fromSet/toSet, however). Comments are very welcome, of course, as well as non-GADT related alternative approaches. Regards, Roberto Zunino. ============================================================ \begin{code} {-# OPTIONS_GHC -Wall -fglasgow-exts #-} module SetMonad ( SetM() , toSet, fromSet , union, unions , return', mzero' ) where import qualified Data.Set as S import Data.List hiding (union) import Control.Monad -- Type equality witness data Teq a b where Teq :: Teq a a -- Either a list or a real Set data SetM a where L :: [a] -> SetM a SM :: Ord w => Teq a w -> S.Set w -> SetM a instance Monad SetM where return = L . (:[]) m >>= f = case m of L l -> unions (map f l) SM Teq s -> unions (map f (S.toList s)) instance MonadPlus SetM where mzero = L [] mplus = union -- Efficient variants for Ord types return' :: Ord a => a -> SetM a return' = SM Teq . S.singleton mzero' :: Ord a => SetM a mzero' = SM Teq S.empty -- Set union: use the best representation union :: SetM a -> SetM a -> SetM a union (L l1) (L l2) = L (l1 ++ l2) union (SM p1 m1) (SM p2 m2) = case (p1,p2) of (Teq,Teq) -> SM Teq (m1 `S.union` m2) union (L l1) (SM p m2) = case p of Teq -> SM Teq (m2 `S.union` S.fromList l1) union s1 s2 = union s2 s1 -- Try to put a SM first before folding, to improve performance unions :: [SetM a] -> SetM a unions = let isSM (SM _ _) = True isSM _ = False in foldl' union (L []) . uncurry (++) . break isSM -- Conversion from/to Set requires Ord toSet :: Ord a => SetM a -> S.Set a toSet (L l) = S.fromList l toSet (SM p m) = case p of Teq -> m fromSet :: Ord a => S.Set a -> SetM a fromSet = SM Teq -- Tests test :: IO () test = do let l = [1..3] :: [Int] s = fromSet (S.fromList l) g x = return' x `mplus` return' (x+100) print $ S.toList $ toSet $ do x <- s y <- s return' (x+y) -- [2,3,4,5,6] print $ S.toList $ toSet $ do x <- s g x -- [1,2,3,101,102,103] print $ S.toList $ toSet $ do x <- s y <- g x return' y -- [1,2,3,101,102,103] print $ S.toList $ toSet $ do x <- s y <- g x g y -- [1,2,3,101,102,103,201,202,203] print $ S.toList $ toSet $ do x <- s y <- return (const x) -- no Ord! return' (y ()) -- [1,2,3] \end{code}

4 6

Re: [Haskell-cafe] State monad strictness - how?
by Yitzchak Gale 12 Jan '07

12 Jan '07

> ...how would one know that State is lazy and StateT is strict? > I don't see that in the Haddock documentation. You're right, it is not in the docs. I don't think anyone would have planned it that way. StateT is strict only because there happens to be a line in a do-expression that looks like: (a, s') <- runStateT m s The tuple pattern-match causes the strictness. That appears accidental, so it seems to be just an honest bug. Regards, Yitz

4 3

readFile problem
by Stefan Aeschbacher 12 Jan '07

12 Jan '07

Hi I am writing a network server in haskell. Lately I seem to have introduced a new bug. On Linux, when a client closes the connection to the server, the server dumps core. On Windows, the error message there is way different from the core dump on Linux. It says: application.exe: config.xml: openFile: does not exist (No such file or directory) I use readFile to read the config file. I tried to print out the config file after it is read to make sure that it is completely read. I only load this config file exactly once during program initialization. The config is used long before the crash. I printed the current working dir in the exception handler and there is something interesting. Instead of the path to the application, it is "\C:\\WINDOWS\\system32". There are many things i do not understand. Why the different behaviour on Linux and Windows? Shouldn't an exception be thrown on Linux instead of a core dump? I don't use any unsafePerformIO or foreign calls. Why the changed path? I never change working directory in my code. Why is a function (-> reading the config file) re-evaluated at a later point in time? How can I debug such a problem? My environement is ghc 6.6 on Ubuntu or Windows XP. thanks for any ideas Stefan

3 5

some way to reverse engineer lambda expressions out of the debugger?
by tphyahoo 12 Jan '07

12 Jan '07

I am a newbie learning haskell. (First forum post.) I am wondering if there is a trick to get debugging information about functions out of the environment (which for me, for now, is ghci). In this example, *UnixTools> :t map (*) [1,2] map (*) [1,2] :: (Num a) => [a -> a] This is very nice, but I would *really* like to see something like *UnixTools> explodeLambda( map (*) [1,2] ) [(\x -> 1*x),(\x -> 2*x)] Yes, maybe I'm dreaming, but I would like haskell to reverse engineer / pretty print lambda expressions for me. (Note that: *UnixTools> map ($ 5 ) [(\x -> 1*x),(\x -> 2*x)] [5,10] *UnixTools> map ($ 5) ( map (*) [1..2] ) [5,10] So these expressions really are the same, only it could be argued that the first expression is in some sense easier to read if you are debugging something complex. ) I would like to have something like "Data::Dumper" from perl, but of course, on steroids. Is something like this possible, or be worked on? Or probably never going to happen? Cheers, thomas. -- View this message in context: http://www.nabble.com/some-way-to-reverse-engineer-lambda-expressions-out-o… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

6 6

restricted existential datatypes
by oleg＠pobox.com 12 Jan '07

12 Jan '07

Misha Aizatulin wrote > I am using existential boxes like > > data Box cxt = forall a . Sat (cxt a) => Box a > here Sat is taken from [1]: > > class Sat a where dict :: a > The result is a box type which can have variable context imposed on > its contents. What I noticed is that sometimes I want to write functions > that operate on the Box and make use of some part of the context without > knowing the context completely. Such a function would look something > like this: > > f :: (Contains cxt ShowCxt) => Box cxt -> String > > f (Box a) = show a It seems what you'd like is an opaque datum that responds to (generally open) set of messages giving a reply dependent on a message. Sounds like an object, doesn't it? Why does it have to be an existential? True, existentials (that is, type abstraction) is one way to implement objects. There are other ways. Let's consider a very simple example: > data Box = forall a . Show a => Box a > f (Box a) = show a Now, the *only* meaningful thing we can do with the value `a' after unboxing is to pass it to the function `show'. Right? One may wonder why not to perform this application to show right upfront: > data Box1 = Box1 String > box a = Box1 (show a) This is _precisely_ equivalent to the above. Thanks to lazy evaluation, the application `show a' won't be evaluated unless we really need its value. The obvious benefit of Box1 is the simplicity of it: no existentials. The value 'Box1' is an object that responds to only one message, `show'. We'd like to have several messages, and we'd like to have the set of messages open. There are two choices: HList or the typeclasses. Both do the same thing, only the heterogeneous set of dictionaries is explicit in the former approach and implicit in the latter. Given below is the example. The box data constructor can be hidden in a module; its details are not important anyway. What is important is the membership in the Boxable class. The code below works with GHC 6.4.1 (no advanced versions required) and even in Hugs. {-# OPTIONS -fglasgow-exts #-} module RestrictedEx where -- Box labeled l responding to a message msg gives the result x class Boxable l msg x | l msg -> x where box_value :: l -> msg -> x -- A few message labels data SHow = SHow data CastToInt = CastToInt data Print = Print -- Create one box data MyBox1 = MyBox1 String -- Define its response to messages instance Boxable MyBox1 SHow String where box_value (MyBox1 s) _ = s instance Boxable MyBox1 Print (IO ()) where box_value (MyBox1 s) _ = putStrLn s -- A function that takes any box that can be shown f1 :: Boxable b SHow String => b -> String f1 b = box_value b SHow

1 0

UDP client/server
by John Ky 12 Jan '07

12 Jan '07

Hello, Does anyone know where I can find a simple UDP client/server written in Haskell? Something along the lines of an echo server would do. Thanks -John

4 6

MapTuple is possible and easy
by oleg＠pobox.com 12 Jan '07

12 Jan '07

Marco Tu'lio Gontijo e Silva wrote: > is there a way to defined something as a map to use in tuples? Yes, it is: and it is quite easy and straightforward. Udo Stenzel > since c would be a variable that ranges over type classes, and that > doesn't exist. Of course it does: please see below (as well as several earlier posts on the Haskell list showing that Haskell classes *are* first-class). Here's the definition of mapTuple > mapTuple l (x,y) = (apply l x, apply l y) and here its inferred type: > *MapTuple> :t mapTuple > mapTuple :: (Apply l b y1, Apply l a y) => l -> (a, b) -> (y, y1) Our mapTuple applies to (in general) heterogeneous tuples and gives (in general) a heterogeneous tuple. Here's the complete code and the tests. {-# OPTIONS -fglasgow-exts #-} module MapTuple where class Apply l x y | l x -> y where apply:: l -> x -> y data SHow = SHow instance Apply SHow String String where apply _ = show instance Apply SHow Int String where apply _ = show instance Apply SHow Bool String where apply _ = show mapTuple l (x,y) = (apply l x, apply l y) -- Here, the result is a homogeneous tuple test1 = mapTuple SHow ("a",(1::Int)) test2 = mapTuple SHow ((1::Int),"b") test3 = mapTuple SHow (True,"b") -- ANother operation: SUcc data SUcc = SUcc instance Apply SUcc String String where apply _ x = x ++ x instance Apply SUcc Int Int where apply _ = succ instance Apply SUcc Bool Bool where apply _ = not -- Here, the result is a heterogeneous tuple (as is the argument) testH1 = mapTuple SUcc ("a",(1::Int)) testH2 = mapTuple SUcc ((1::Int),"b") testH3 = mapTuple SUcc (True,"b")

1 0

an advanced foldification problem
by Seth Gordon 12 Jan '07

12 Jan '07

I have a data type "Group", representing a group of geographic information that is all referring to the same location, and a function "mergeGroups" that tries to merge two groups: mergeGroups :: Group -> Group -> Maybe Group Then I have a function "mergeGroupToList" that tries to merge its first argument with every element of the second argument: mergeGroupToList :: Group -> [Group] -> [Group] mergeGroupToList g [] = [g] mergeGroupToList g1 (g2:gs) = case (mergeGroups g1 g2) of Nothing -> g2 : (mergeGroupToList g1 gs) Just g3 -> mergeGroupToList g3 gs How can I rewrite mergeGroupToList in terms of foldr?

3 2

Re: [Haskell-cafe] State monad strictness - how?
by Yitzchak Gale 12 Jan '07

12 Jan '07

Dean Herington wrote: > I can't seem to figure out how to achieve strictness > in the context of the State monad. Unfortunately, the current situation is that State is only available as a lazy monad, and StateT is only available as a strict monad. It seems to me that this should clearly be considered a serious bug in the library. It has been reported on numerous occasions over the years, but it has still not been fixed. At the very least, the two should be consistent. I would much prefer for them both to be lazy. I have written a lot of code that depends on that; it is the natural assumption in Haskell that everything is lazy by default, except seq, IO, and their friends. The obvious solution would be to have available both a lazy and a strict version of each monad: State, State', StateT, and State'T (or some such), with functions to convert between them. It is trivial to implement that in the current library. If someone can come up with a more elegant solution right away, that would be great. (Iavor - do you have a solution?) Otherwise, I think we have waited long enough. Let's implement the simple fix. This bug is a major inconvenience to users of this library. > (try 1000000) overflows the stack. In the current situation, you can use > where final = runIdentity $ execStateT prog (0::Int) ... > tick :: (Num a, MonadState a m) => m a ... Regards, Yitz

10 18

Using PAPI to measure performance with CPU events
by Alexey Rodriguez Yakushev 12 Jan '07

12 Jan '07

Dear all, I have added a page to the GHC commentary explaining how to use the 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. The page also has some patches to use PAPI on the nofib suite. These patches are eventually going to make it into the HEAD, but I thought someone might find them useful meanwhile. Cheers, Alexey

1 1

[Haskell-cafe] Can't figure out how to "show" for type "Int -> (Int, Int)"
by Tom Titchener 11 Jan '07

11 Jan '07

Typing up and running (via Hugs) the examples in Wadler's excellent "Monads for functional programming" (here: http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/baastad.pdf) I hit the inevitable "show" function error: ERROR - Cannot find "show" function for: *** Expression : eval answer *** Of type : Int -> (Int,Int) I can find lots of nice text about extending data for "show" (including the miraculous "Deriving") but... I'm showing my Haskell newbie roots by utterly failing to understand how to do this of a "higher-order" type (my best guess for the right term for the type Int -> (Int, Int)). It'd be a big help if somebody could tell me either: a) It's obvious, you moron, just <insert Haskell code here> or b) It's impossible, you moron, you're trying to violate the <insert Haskell rule here> Here' my code: data Term = Con Int | Div Term Term type M a = State -> (a, State) -- higher-order type, e.g. function type type State = Int -- type synonym eval :: Term -> M Int eval (Con a) x = (a, x) eval (Div t u) x = let (a, y) = eval t x in let (b, z) = eval u y in (a `div` b, z + 1) answer, error :: Term answer = (Div(Div(Con 1972)(Con 2))(Con 23)) error = (Div(Con 1)(Con 0)) I get the "ERROR" message when I type "eval answer" at the Hugs prompt. Thanks! Tom Titchener

3 2

HaskellForge?
by Imam Tashdid ul Alam 11 Jan '07

11 Jan '07

is it a good idea to have HaskellForge? Ruby, Lua and some other languages have already adopted GForge, and I must say, those sites look *impressive*!!! any Ruby programmer on the list? can anyone provide an estimate of the amount of work involved? cheers, and long live the lambda revolution. __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

13 14

restricted existential datatypes
by Misha Aizatulin 11 Jan '07

11 Jan '07

hi, I am wondering whether it would be possible to use the existing haskell type system to simulate a certain feature. Namely, I am trying to apply ideas from [1] to existential datatypes. First I will describe the problem and later say something about the context in which it arose. I am using existential boxes like > data Box cxt = forall a . Sat (cxt a) => Box a here Sat is taken from [1]: > class Sat a where dict :: a The result is a box type which can have variable context imposed on its contents. What I noticed is that sometimes I want to write functions that operate on the Box and make use of some part of the context without knowing the context completely. Such a function would look something like this: > f :: (Contains cxt ShowCxt) => Box cxt -> String > f (Box a) = show a The type is meant to say that the context of the box must contain Show as one of the classes. I would imagine the Contains class to be something like > class Contains cxt subCxt where > subDict :: cxt a -> subCxt a Now inside f I would like to have the real (Show a) context available. So I'd have an instance > (Sat cxt a, Contains cxt ShowCxt) => Show a where > show = -- <the show function extracted from (subDict dict)> This instance of course does not work in ghc, because cxt is hanging in the air - I get an error whenever it tries to infer (Show a). The question I'd like to ask is whether there is some trickery to circumvent this problem. In the f function I'd like to be able to hint to the compiler that I want Show to be derived from cxt which is attached to the Box, but I see no way of doing that. (This by the way seems connected to http://www.mail-archive.com/haskell@haskell.org/msg19564.html) Now a couple of words about where I stumbled upon this problem. I am writing a program that is supposed to use plugins. The plugins operate among other things on Boxes as above. Now some plugins would like to demand some additional capabilities from the Box that cannot be foreseen at the spot where Box is defined. Parametrizing over context seems a very natural solution to me - leading to the problem above. I would be very thankful for any suggestions! Cheers, Misha Aizatulin 1. John Hughes, "Restricted Data Types in Haskell", September 4, 1999

3 3

Re: [Haskell] Re: state of HaXml?
by Taral 11 Jan '07

11 Jan '07

On 1/10/07, Malcolm Wallace <Malcolm.Wallace(a)cs.york.ac.uk> wrote: > Actually, I'm pretty sure that most Haskell RTS implementations have a > finalizer attached to all file handles. Once the file handle is no > longer reachable from the program graph (even if its data has not been > fully consumed), the GC will close the file (via the finalizer) before > reaping the memory associated with the handle. That's not the point. The GC will only close the file when the heap is under pressure. It does not aggressively close the file, so the file may stay open for longer than the user likes. For a read-only operation, this shouldn't matter, however on some platforms an open file handle can prevent deletion of the file. -- Taral <taralx(a)gmail.com> "You can't prove anything." -- Gödel's Incompetence Theorem

2 1

What happened to Haskell original goals?
by Maurício 10 Jan '07

10 Jan '07

I remember reading "avoid success at all costs" somewhere. I miss the old days when I could read all messages in this list. Today, I can hardly keep up with a few of the most interesting threads. Good programming for all you guys in 2007. Thanks for your support and comments, and for helping me learning this really cool language. Maurício

1 0

State monad strictness - how?
by Dean Herington 10 Jan '07

10 Jan '07

I can't seem to figure out how to achieve strictness in the context of the State monad. Consider: > import Control.Monad.State > try count = print final > where (_,final) = runState prog 0 > prog = sequence_ (replicate count tick) > tick :: State Int Int > tick = do n <- get > put (n+1) > return n (try 1000000) overflows the stack. It doesn't help to use: > put $! (n+1) The only way I've been able to get the necessary strictness is to add use of ($!) in the definition of (>>=): > data SState s a = SState (s -> (a,s)) > instance Monad (SState s) where > return x = SState (\s -> (x,s)) > m >>= f = SState (\s -> let SState m' = m > (x,s1) = m' s > SState f' = f x > (y,s2) = f' $! s1 > in (y,s2)) > runSState (SState m) s = m s > sget = SState (\s -> (s,s)) > sput s' = SState (\s -> ((),s')) > stry count = print final > where (_,final) = runSState prog 0 > prog = sequence_ (replicate count stick) > stick :: SState Int Int > stick = do n <- sget > sput (n+1) > return n Is there no way to get strictness using the standard State monad? Dean

1 0

hacking ghci
by Walter Moreira 10 Jan '07

10 Jan '07

Hi Haskellers. A short while ago I asked about the possibility to have the output of ghci in color. Thanks to Donald Stewart who set up a wiki page to continue the attempt. Other people suggested HsColour and GUI's (thanks too). I'm not so interested in highlighting the snippets of code which ghci displays, but to use different colors for the different types of output: different colors for the prompt, input, warnings, exceptions, normal output, etc. Are any of these ideas viable?: 1. Hack the code of Interactive.hs in the GHC distribution and substitute the calls to 'putStr[Ln]' by some thin wrapper which can write with colors, according to a command line option (--color or --colour, for example), maybe using HsColour. This looks easy enough and I'd be willing to do it, but it's intrusive, and one has to mantain a different version of ghci in parallel with the main ghci. 2. Use GHC as library (from 6.6 on) and write a similar application as ghci, with more emphasis in the 'interactive' part of the name (in the same way as the relation between Python and the IPython extended shell). This is more work and more duplicate efforts, but it may be worthly, perhaps. 3. Write a wrapper which communicates with ghci via pipes. I read some attempts about this somewhere, and people suggested an approach as in #2. I haven't mentioned the GUI applications, since I would like to just have something in the spirit of ghci (command line oriented), but with colors or with configurable output. Which approach do you people think it is best? Sorry for the long message. Cheers, Walter

3 2

Re: question about database interfaces
by Thomas David Baker 10 Jan '07

10 Jan '07

Eric wrote: > So I'm wondering -- in practice, what do people actually use? Is > there a more-or-less generally accepted standard database library for > Haskell? In practice I am using HDBC for a PostgreSQL database and it is very easy to use and works great. http://gopher.quux.org:70/devel/hdbc T

1 0

question about database interfaces
by Eric Sessoms 09 Jan '07

09 Jan '07

Hi All, I've found the list of database libraries at http://www.haskell.org/haskellwiki/Libraries_and_tools/Database_interfaces but I haven't found much guidance in choosing among them. So I'm wondering -- in practice, what do people actually use? Is there a more-or-less generally accepted standard database library for Haskell? Thanks, Eric -- not about to see your light

2 1

question about "How to Write a Haskell Program" tutorial
by Michael Vanier 09 Jan '07

09 Jan '07

First off, I apologize if this has come up before. As far as I can tell, the mailing list archives don't have a search function. I'm running ghc-6.6 and haddock-0.8, both compiled from source. I'm working my way through the "How to Write a Haskell Program" tutorial (which is a great idea, thanks guys!), and everything works fine until I get to the part about creating the haddock documentation. When I run: $ runhaskell Setup.hs haddock I get this: Preprocessing executables for haq-0.0... Running Haddock for haq-0.0... Warning: cannot use package haq-0.0: ghc-pkg failed With verbosity: $ runhaskell Setup.hs haddock -v I get this: Preprocessing executables for haq-0.0... Running Haddock for haq-0.0... /usr/local/packages/haskell-misc/bin/haddock --html --odir=dist/doc/html/haq --title=haq --use-package=haq-0.0 --use-package=base-2.0 dist/build/tmp/Haq.hs Warning: cannot use package haq-0.0: ghc-pkg failed Note that I'm installing into a non-standard location. I have no idea why haddock (called from cabal) is trying to use a package that is in the process of being created. Nevertheless, the documentation does get generated. Is this just something that should be ignored? Is it a Cabal bug? Mike

3 2

Beta Gtk2Hs Getting Started
by Hans van Thiel 09 Jan '07

09 Jan '07

Hello All, The beta of the 'Gtk2Hs:Getting Started' short tutorial for beginners, Haskell GUI for Dummies, if you like :-) can be viewed at http://j-van-thiel.speedlinq.nl/gtk2hs/gtk2hsGetStart.html It tells what Gtk2Hs is, shows how to write and run 'Hello World', introduces the api and explains how to use it, refers to the Glade tutorials, gives an example of widget layout, and ends with some general pointers. It should take no more than 2,3 hours of the user's time. All feedback very welcome. Regards, Hans van Thiel

3 5

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

09 Jan '07

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20070109 Issue 56 - January 09, 2007 --------------------------------------------------------------------------- Welcome to issue 56 of HWN, a weekly newsletter covering developments in the [1]Haskell community. More libraries and applications for the new year, and the Haskell Hackathon gets underway! 1. http://haskell.org/ Announcements Happy: LALR(1) parser generator. Simon Marlow [2]announced version 1.16 of [3]Happy, the parser generator system for Haskell. Changes from version 1.15 to 1.16 include switching to Cabal, a new %error directive, new production forms, and attribute grammar support. Happy version 1.16 is required for building GHC version 6.6 and later. 2. http://article.gmane.org/gmane.comp.lang.haskell.general/14726 3. http://www.haskell.org/happy/ Alex: lexical analyser generator. Simon Marlow [4]announced version 2.1.0 of [5]Alex. Changes in Alex 2.1.0 vs. 2.0.1 include switching to Cabal, and slight changes to the error semantics. 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14728 5. http://www.haskell.org/alex/ rdtsc: reading IA-32 time register. Martin Grabmueller [6]announced version 1.0 of [7]package rdtsc has just been released. This small package contains one module called [8]'Rdtsc.Rdtsc', providing the function 'rdtsc' for accessing the 'rdtsc' machine register on modern IA-32 processors. This is a 64-bit counter which counts the number of processor cycles since the machine has been powered up. Using this instruction, you can make very precise time measurements which are independent of the actual CPU frequency. 6. http://article.gmane.org/gmane.comp.lang.haskell.cafe/18095/ 7. http://uebb.cs.tu-berlin.de/~magr/projects/rdtsc/ 8. http://uebb.cs.tu-berlin.de/~magr/darcs/rdtsc/ monadLib 3.0. Iavor Diatchki [9]announced a new version of [10]monadLib, a collection of standard monad implementations. Some of the changes compared to the previous version: the whole library is in a single module MonadLib.hs (~500 lines); simpler and more symmetric API; removed the (generic) monadic combinators; removed the search transformer; rewrote some transformers in the 'traditional' way (exceptions and output); there is an optional module that defines base monads corresponding to each transformer. 9. http://article.gmane.org/gmane.comp.lang.haskell.general/14714 10. http://www.csee.ogi.edu/~diatchki/monadLib Shellac 0.6. Robert Dockins [11]announced a simultaneously release of the following related packages: Shellac 0.6 Shellac-readline 0.3 and Shellac-vty 0.1. [12]Shellac is a framework for building read-eval-print style shells which uses configurable backend plugins. The major new feature of this release is the new Shellac-vty backend package, which uses the [13]new Vty library terminal I/O directly. It currently has basic line editing keybindings, paging, and a command history. The main package and Shellac-readline updates consist of minor API updates. 11. http://article.gmane.org/gmane.comp.lang.haskell.general/14715 12. http://www.eecs.tufts.edu/~rdocki01/shellac.html 13. http://members.cox.net/stefanor/vty/ IntelliJIDEA for Haskell. Tony Morris [14]announced syntax highlighting support for [15]Haskell in IntellijIDEA, released under a BSD licence. 14. http://article.gmane.org/gmane.comp.lang.haskell.general/14719 15. http://www.workingmouse.com/research/IntelliJIdea%2DHaskell/ Yampa + GADT for GHC 6.6. Joel Reymont [16]announced a cabalized [17]version of Yampa + GADT for GHC 6.6. Joel also sought comments on cabalisation, testing and example for this package. 16. http://article.gmane.org/gmane.comp.lang.haskell.cafe/18215 17. http://wagerlabs.com/yampa HNOP. Ashley Yakeley [18]updated the status of [19]HNOP, the Haskell library for doing nothing. It has recently been split into two Cabal packages: 'nop', a library of no-op services, and 'hnop', a program that uses nop to do nothing. Both packages can be found in darcs. The two packages are intended to be templates for Cabal projects, so I'm interested in making them as canonical and 'best practices' for packaging libraries and executables. 18. http://article.gmane.org/gmane.comp.lang.haskell.general/14720 19. http://semantic.org/hnop/ Haskell' This section covers the [20]Haskell' standardisation process. * [21]Rough draft of informal pattern-guard (qualifiers) explanations 20. http://hackage.haskell.org/trac/haskell-prime 21. http://article.gmane.org/gmane.comp.lang.haskell.prime/1982 Discussion instance Monad Set, using GADTs. Roberto Zunino [22]announced a definition of the Set datatype, with the usual operations, such that it can be made a member of the Monad class. 22. http://article.gmane.org/gmane.comp.lang.haskell.cafe/18118 GADTs are expressive. Jim Apple [23]described a data type which holds only those terms of the untyped lambda calculus that are reducible to normal form, using GADTs 23. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/18210/focus=18210 Hackage interface. Ross Paterson [24]set up (temporarily) a simple first cut at an [25]interface to the Hackage package database. On a related note, there was some [26]discussion for home pages for Hackage projects, and collecting statistics. 24. http://article.gmane.org/gmane.comp.lang.haskell.libraries/6025 25. http://ross-paterson.dyndns.org/~ross/hackage/ 26. http://article.gmane.org/gmane.comp.lang.haskell.libraries/6035 Conference roundup The Haskell Hackathon. Hac 2007 [27]is being held this week, January 10-12th, in Oxford, with around 20 Haskell coders from across the world gathering to hack on libraries and practical tools for Haskell. Work is planned for at least hackage, Cabal, bytestrings, binary IO, http, GHC, YHC, Hoogle, DrHaskell, WinHugs, GHCi debugger, crypto, QuickCheck 2, Haddock and more besides. Notably, some graduates from this year's Google Summer of Code projects will be attending, with plans to integrate their work into the main project branches. Happy hacking everyone! 27. http://haskell.org/haskellwiki/Hac_2007 Blog noise [28]Haskell news from the blogosphere. * [29]Liberating Myself from the von Neumann Style * [30]First impressions of Haskell: Whoa! * [31]Comparing Gzip Code Reduction * [32]Simple demonstration of Haskell FFI * [33]Does Functional Programming Matter? * [34]2006 in review * [35]Haskell script to replace tabs * [36]Functional programming is functional * [37]The shock of the forgotten * [38]Category theory * [39]Does Haskell need macros? * [40]On darcs * [41]Learning things * [42]Folds for imperative programmers * [43]Dammit all! I've been blubbed * [44]Getting started with installing third-party Haskell packages * [45]A Nice Way to Learn FP * [46]Learning Haskell * [47]Haskell and Eclipse * [48]Haskell and Eclipse: building a server executable * [49]What makes a programming language more productive? * [50]Composability and Productivity * [51]Arithmetic coding in Haskell * [52]A quick and dirty theorem prover in Haskell * [53]Haskell is Fun! * [54]2007, the year of software reliability? * [55]Haskell, bondage-and-discipline and separation-of-concerns programming * [56]Type systems as safety belts * [57]It's Haskell! * [58]Two promising Haskell projects: Vital and Pivot * [59]Exceptions and interrupts 28. http://planet.haskell.org/ 29. http://blogs.nubgames.com/code/?p=4 30. http://blogs.nubgames.com/code/?p=15 31. http://blogs.nubgames.com/code/?p=16 32. http://blog.acolyte.co.za/articles/2007/01/01/simple-demonstration-of-haske… 33. http://denkspuren.blogspot.com/2007/01/does-functional-programming-matter.h… 34. http://koweynlg.blogspot.com/2006/12/state-of-thesis-2006-12-31.html 35. http://chill-yo.blogspot.com/2007/01/haskell-code-replace-tabs.html 36. http://gearon.blogspot.com/2006/10/functional-programming-is-functional.html 37. http://www.serpentine.com/blog/2007/01/01/the-shock-of-the-forgotten/ 38. http://comblog.net/hnbeck/archive/2007/01/05/2384.aspx 39. http://neilmitchell.blogspot.com/2007/01/does-haskell-need-macros.html 40. http://simulacra.in/2007/01/darcs/ 41. http://koweynlg.blogspot.com/2007/01/zommmmbieeee.html 42. http://blog.tmorris.net/folds-for-imperative-programmers/ 43. http://withoutane.com/rants/2007/01/damn-you-haskell 44. http://www.serpentine.com/blog/2007/01/05/getting-started-with-installing-t… 45. http://monadnation.blogspot.com/2007/01/nice-way-to-learn-fp.html 46. http://www.timeblog.net/2007/01/06/haskell/ 47. http://cohatoe.blogspot.com/2006/12/simple-example-walkthrough-ii.html 48. http://cohatoe.blogspot.com/2007/01/building-server-executable.html 49. http://kawagner.blogspot.com/2007/01/what-makes-programming-language-more.h… 50. http://cogito.blogthing.com/2007/01/07/composablility-and-productivity/ 51. http://vandreev.wordpress.com/2007/01/07/arithmetic-coding/ 52. http://vandreev.wordpress.com/2006/12/24/quick-and-dirty-theorem-prover/ 53. http://onthebalcony.wordpress.com/2007/01/08/haskell-is-fun/ 54. http://jguk.org/2007/01/2007-year-of-software-reliability.html 55. http://syntaxfree.wordpress.com/2007/01/08/haskell-bondage-and-discipline-a… 56. http://programming.reddit.com/info/xbc7/comments/cxfs0 57. http://e-scribe.com/news/322 58. http://factor-language.blogspot.com/2007/01/two-promising-haskell-projects.… 59. http://www.weaselhat.com/2007/01/08/exceptions-and-interrupts/ Quotes of the Week * Eric: The Haskell [code] contains no redundancy. In fact, in all the [Haskell] code I've written, in both production and play, each idea is expressed once and only once. It is the Zen ideal of perfect code. And thats never happened to me before. * nostrademons: Haskell is in a similar position [to Scala] - a complex language with many sustaining innovations - but it has one major disruptive innovation. Purity. Now, the question is whether that can be leveraged in a way that makes it useful in some market that existing imperative languages can't reach. My bets are on concurrency... * Excedrin: Isn't OO deprecated? * dpiponi: [monochrom] Nevermind monads. Use arrows. Come join the Dart Side! [dpiponi] Never mind arrows. Use comonads. Cojoin the other side. * nilsi: #haskell is better than Google * sigfpe: I think Haskell is a great language for short attention spans. You can get so much done in one line before you get bored. * timthelion: Oh wait, I LOVE foldr!! And I have only been learning Haskell for hours * kowey: All the things with guards are just there to siphon off the weirdos * Eric: [Haskell] astonishes me at every turn with its beauty and elegance. I've never felt such power. Haskell has brought back a joy in programming that I didnt even know I was missing. * Paul Johnson: Mutable state is actually another form of manual memory management: every time you over-write a value you are making a decision that the old value is now garbage, regardless of what other part of the program might have been using it. About the Haskell Weekly News Each week, new editions are posted to [60]the Haskell mailing list as well as to [61]the Haskell Sequence and [62]Planet Haskell. [63]RSS is also available, and headlines appear on [64]haskell.org. Headlines are available as [65]PDF. To help create new editions of this newsletter, please see the [66]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get [67]http://www.cse.unsw.edu.au/~dons/code/hwn 60. http://www.haskell.org/mailman/listinfo/haskell 61. http://sequence.complete.org/ 62. http://planet.haskell.org/ 63. http://sequence.complete.org/node/feed 64. http://haskell.org/ 65. http://www.cse.unsw.edu.au/~dons/code/hwn/archives/20070109.pdf 66. http://haskell.org/haskellwiki/HWN 67. http://www.cse.unsw.edu.au/~dons/code/hwn

1 0

why can't you surround (+) in backticks and have it be infix?
by tpledger＠ihug.co.nz 09 Jan '07

09 Jan '07

David House wrote: : | You can fake this: | | (-!) = ($) | (!-) = flip ($) | | foo -! liftM2 (,) !- bar | | Not perfect, but it's interesting nonetheless. | | And yes, this was a product of some #haskell | brainstorming and algorithm tennis. :) :-) Was anyone in that brainstorm thinking of Chung-chieh Shan's -: and :- (http://www.haskell.org/pipermail/haskell-cafe/2002-July/003215.html) or was the similarity just a really cool coincidence? Regards, Tom

3 2

trivial function application question
by brad clawsie 09 Jan '07

09 Jan '07

greetings to this helpful and informative list i have a small problem that will be certainly trivial for almost everyone reading this, i would appreciate a little help lets say i have a string s = "abcdefg" now i have two lists of strings, one a list of patterns to match, and a list of replacement strings: patterns = ["a","b"] replace = ["Z","Y"] from which my intent is that "a" be replaced by "Z", "b" by "Y" etc now using the replace function from MissingH.Str (which i know is now renamed), i wish to apply replace to s using (pattern[0], replace[0]), (pattern[1], replace[1])...(pattern[N], replace[N]). i am sure there is an elegant way to apply replace to s for all of these argument pairs without composing replace N times myself, but the solution escapes me. thanks in advance for any help you can provide for this trivial issue brad

15 25

why can't you surround (+) in backticks and have it be infix?
by tphyahoo 09 Jan '07

09 Jan '07

"Issues: In Haskell, any function or constructor can be enclosed in backticks and then used as an infix operator. " from http://www-users.cs.york.ac.uk/~mfn/hacle/issues/node2.html But this seems to be contradicted by... from #haskell -- 09:19 < tphyahoo> > let func = (+) in 1 `func` 2 -- 09:19 < lambdabot> 3 -- 09:20 < tphyahoo> but ...... -- 09:20 < tphyahoo> 1 `(+)` 2 -- 09:20 < tphyahoo> > 1 `(+)` 2 -- 09:20 < lambdabot> Parse error (+) is a function, is it not? Where's the rub? thomas. -- View this message in context: http://www.nabble.com/why-can%27t-you-surround-%28%2B%29-in-backticks-and-h… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 2

hsffig build problem
by Jeff Polakow 08 Jan '07

08 Jan '07

Hello, I am trying to install hsffig and I get the following error: bash$ make : : Linking cabal-setup.exe ... Distribution/Simple/Configure.o:fake:(.text+0x74fd): undefined reference to `SHGetFolderPath@20' collect2: ld returned 1 exit status make: *** [cabal-setup] Error 1 I am using ghc6.6 in cygwin on windows XP. Has anyone else encountered and/or overcome this? thanks, Jeff --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

1 0

Re: [Haskell-cafe] no end to the build errors! (wxhaskell, afrp)
by Yang 08 Jan '07

08 Jan '07

thanks, now wxhaskell is installed. (i recommend adding this detail to the docs - i didn't see the message at the end of the make job at all because of the tools i use to automate this process.) now the error i get from wxfruit is: $ ghc --make WXFruit.hs [1 of 1] Compiling WXFruit ( WXFruit.hs, WXFruit.o ) WXFruit.hs:81:31: parse error on input `->' On 1/7/07, Brandon S. Allbery KF8NH allbery-at-ece.cmu.edu |haskell-cafe| <...> wrote: > > On Jan 7, 2007, at 20:54 , Yang wrote: > > > WXFruit.hs:12:17: > > Could not find module `Graphics.UI.WX': > > Hm. Did you install the whole thing? You need to do "make; make > install; make wx; make wx-install" to get all of it --- and > Graphics.UI.WX is in the latter group, IIRC. If you do only the > first part then you only get wxcore, which isn't so useful. > > -- > brandon s. allbery [linux,solaris,freebsd,perl] allbery(a)kf8nh.com > system administrator [openafs,heimdal,too many hats] allbery(a)ece.cmu.edu > electrical and computer engineering, carnegie mellon university KF8NH > > > >

1 0

no end to the build errors! (wxhaskell, afrp)
by Yang 08 Jan '07

08 Jan '07

argh, still more build errors on various fronts. i'm using ghc-6.6 on fedora core 5 unless otherwise noted. thanks in advance for help on any of these. a lot of this is part of my attempt to learn more about and play with a high-level functional gui library (and, of course, for getting a better grasp on what frp and arrows are all about) after realizing that i would never ever be able to get fruit working. i have so far found wxfruit (built on wxhaskell) and FG (built on gtk). i am interested in implementing a similarly 'highly-declarative' ui library built on hscurses.widgets. == wxhaskell-0.9.4 == $ make ... wx/src/Graphics/UI/WX/Types.hs:94:0: Bad interface file: out/wx/imports/Graphics/UI/WXCore/Types.hi Something is amiss; requested module wx:Graphics.UI.WXCore.Types differs from name found in the interface file wxcore:Graphics.UI.WXCore.Types make: *** [out/wx/imports/Graphics/UI/WX/Types.o] Error 1 == afrp-0.4 == after removing all references to packages 'lang' and 'concurrent' and changing all "import IORef" to "import Data.IORef as IORef": ghc -c -fglasgow-exts -O -o AFRPUtilities.o AFRPUtilities.hs AFRPUtilities.hs:169:46: Ambiguous occurrence `>>^' It could refer to either `>>^', defined at AFRPUtilities.hs:106:2 or `>>^', imported from AFRP at AFRPUtilities.hs:90:0-10 AFRPUtilities.hs:178:27: Ambiguous occurrence `>>^' It could refer to either `>>^', defined at AFRPUtilities.hs:106:2 or `>>^', imported from AFRP at AFRPUtilities.hs:90:0-10 AFRPUtilities.hs:184:46: Ambiguous occurrence `>>^' It could refer to either `>>^', defined at AFRPUtilities.hs:106:2 or `>>^', imported from AFRP at AFRPUtilities.hs:90:0-10 AFRPUtilities.hs:246:32: Ambiguous occurrence `^>>' It could refer to either `^>>', defined at AFRPUtilities.hs:103:2 or `^>>', imported from AFRP at AFRPUtilities.hs:90:0-10 AFRPUtilities.hs:247:33: Ambiguous occurrence `^>>' It could refer to either `^>>', defined at AFRPUtilities.hs:103:2 or `^>>', imported from AFRP at AFRPUtilities.hs:90:0-10 AFRPUtilities.hs:304:62: Ambiguous occurrence `>>^' It could refer to either `>>^', defined at AFRPUtilities.hs:106:2 or `>>^', imported from AFRP at AFRPUtilities.hs:90:0-10 == FG == $ ghc --make FG.hs [1 of 1] Compiling FG ( FG.hs, FG.o ) FG.hs:115:31: Module `Graphics.UI.Gtk' does not export `button' FG.hs:115:39: Module `Graphics.UI.Gtk' does not export `visible' when removing those two `hiding` params: [1 of 1] Compiling FG ( FG.hs, FG.o ) FG.hs:562:69: Couldn't match expected type `w' (a rigid variable) against inferred type `Bool' `w' is bound by the polymorphic type `forall w. (ToggleButtonClass w) => w -> IO ()' at FG.hs:562:54-92 Expected type: w -> IO () Inferred type: Bool -> IO () In the first argument of `ToggleButtonP', namely `(toggleButtonSetActive p)' In the expression: ToggleButtonP (toggleButtonSetActive p) FG.hs:587:67: Couldn't match expected type `w' (a rigid variable) against inferred type `Bool' `w' is bound by the polymorphic type `forall w. (CheckButtonClass w) => w -> IO ()' at FG.hs:587:53-90 Expected type: w -> IO () Inferred type: Bool -> IO () In the first argument of `CheckButtonP', namely `(toggleButtonSetActive p)' In the expression: CheckButtonP (toggleButtonSetActive p)

2 2

ANN: Yampa + GADT for ghc 6.6
by Joel Reymont 08 Jan '07

08 Jan '07

Folks, This is a raw version of cabalized Yampa + GADT for ghc 6.6. darcs get http://wagerlabs.com/yampa I would like to change the layout of the directory tree and I think there should be a single Cabal file that builds the source, tests and examples. I'm not sure if this is possible, though, as examples and tests depend on the library itself. Regardless, please send your comments and patches and in the meantime just follow the regular Cabal procedure in src, tests and examples. Thanks, Joel -- http://wagerlabs.com/

1 0

Literate Haskell source files. How do I turn them into something I can read?
by Michael T. Richter 08 Jan '07

08 Jan '07

I'm trying to wrap my mind around the darcs source code as a preliminary to looking into GHC's guts. All of darcs is written as .lhs files which have bizarre mark-up in them which distracts me from the actual Haskell source I'm trying to figure out and get used to. Apparently the GHC compiler can take .lhs files, strip them with "unlit" (a utility which I finally found buried deep in the GHC installation -- off-path) and then compile them normally. The problem I have is that unlit leaves behind instead these huge gaping (and highly distracting) stretches of whitespace while it takes out the markup. Are there any tools which I can use to render .lhs files readable? I'm fine with having them converted into documented source (i.e. source code embedded in documentation) or as pure Haskell source (but without the huge whitespace gaps) -- but I can't figure out how to get either. -- Michael T. Richter Email: ttmrichter(a)gmail.com, mtr1966(a)hotpop.com MSN: ttmrichter(a)hotmail.com, mtr1966(a)hotmail.com; YIM: michael_richter_1966; AIM: YanJiahua1966; ICQ: 241960658; Jabber: mtr1966(a)jabber.cn "I think it is very beautiful for the poor to accept their lot [...]. I think the world is being much helped by the suffering of the poor people." --Mother Theresa

8 11

Why does the wiki search facility not work properly?
by Brian Hulley 08 Jan '07

08 Jan '07

Hi, There is a page on the Haskell Wiki titled "Talk:SantaClausProblem" subtitled "Beautiful concurrency". However typing any of the following into the search box *doesn't* lead to the page: Santa talk:santaclausproblem beautiful beautiful concurrency Talk:Santa In fact to get the page you have to type the *exact* full title in the *exact* case. Luckily I could always refer back to SimonPJ's post to the Haskell mailing list to find the link to the page, but I think this situation is really bad because it means that things on the wiki are more or less just being thrown down a gaping void never to be seen again unless you know which catagories to look in from the main page. Another point is that the word "beautiful" does occur on the page but the page is not included in the list of page text matches. Perhaps the site is not being automatically re-indexed frequently enough? There is also a bunch of check boxes at the bottom of the search results page that doesn't seem to do anything either except cause nothing at all to happen when you click search unless the (Main) box is the only box ticked. Anyway I thought I'd just point this out in case anyone knows how to fix it. Thanks, Brian. -- http://www.metamilk.com

4 4

less than helpful GHC error message
by Nicolas Frisby 08 Jan '07

08 Jan '07

Consider the terminal session at the bottom of this message. The extra "xc" in Test.hs was the result of me missing CTRL during an Emacs command (I'm guessing...). Unfortunately this took 30 minutes to find since I had far more than two modules and the error message doesn't point this out. Sure it's a silly mistake to make, but I'm guessing it's pretty common. I'm running GHC 6.6 on a PPC Mac. I know pragmas are wierd things, but could this error message be improved? Thanks, Nick $ head -n 10000 Main.hs Test.hs ==> Main.hs <== module Main where import Test main = test ==> Test.hs <== xc{-# OPTIONS -fglasgow-exts #-} module Test where test = putStrLn "weee" $ ghc --make Main <no location info>: file name does not match module name `Main'

2 1

build error with happy-1.15 on ghc-6.6
by Yang 07 Jan '07

07 Jan '07

per a previous thread, i addressed the 'package lang not found' issue by changing the following lines to: $ grep -rsn '\blang\b' . | grep Makefile ./happy/src/Makefile:27:SRC_HC_OPTS += #-package lang ./happy/tests/Makefile:62:HC_OPTS += -fglasgow-exts # -package lang however i still get a build error, seemingly from LALR.lhs: /usr/local/bin/ghc -H16m -O -cpp -fglasgow-exts -O -c LALR.lhs -o LALR.o -ohi LALR.hi LALR.lhs:626:34: Not in scope: `bounds' i wasn't able to find 'bounds' defined in any other of the src files. thanks in advance for any help.

2 1

Re: [Haskell-cafe] Seeking advice on a style question
by Steve Schafer 07 Jan '07

07 Jan '07

On Tue, 26 Dec 2006 20:21:45 -0800, you wrote: >How would this example look if you named only multiply-used expressions? >I'd like to see it in a more conventional pointful style with nested >expressions. I'm still wondering whether the awkwardness results from your >writing style or is more inherent. Showing the real variable names may also >help also. This is what it looks like "for real": > process :: Item -> MediaKind -> MediaSize -> Language -> SFO > process item mediaKind mediaSize language = > let pagemaster = loadPagemaster item mediaKind mediaSize; > questions = stripUndisplayedQuestions mediaKind $ > appendEndQuestions item pagemaster $ > coalesceParentedQuestions $ > validateQuestionContent $ > loadQuestions item; > (numberedQuestions,questionCategories) = numberQuestions pagemaster questions; > numberedQuestions' = coalesceNAQuestions numberedQuestions; > (bands,sequenceLayouts) = buildLayout mediaKind language numberedQuestions'; > bands' = resolveCrossReferences bands; > groupedBands = groupBands bands'; > pages = paginate item mediaKind mediaSize pagemaster groupedBands; > pages' = combineRows pages; > sfo = pages' sequenceLayouts; > in sfo These are the function signatures: > loadPagemaster :: Item -> MediaKind -> MediaSize -> Pagemaster > loadQuestions :: Item -> [Question] > validateQuestionContent :: [Question] -> [Question] > coalesceParentedQuestions :: [Question] -> [Question] > appendEndQuestions :: Item -> Pagemaster -> [Question] -> [Question] > stripUndisplayedQuestions :: MediaKind -> [Question] -> [Question] > numberQuestions :: Pagemaster -> [Question] -> ([NumberedQuestion],[QuestionCategory]) > coalesceNAQuestions :: [NumberedQuestion] -> [NumberedQuestion] > buildLayout :: MediaKind -> Language -> [NumberedQuestion] -> ([Band],[SequenceLayout]) > resolveCrossReferences :: [Band] -> [Band] > groupBands :: [Band] -> [[Band]] > paginate :: Item -> MediaKind -> MediaSize -> Pagemaster -> [[Band]] -> [Page] > combineRows :: [Page] -> [Page] > createSFO :: [Page] -> [SequenceLayout] -> SFO MediaKind, MediaSize and Language are simple enumerations; everything else is a complex structure. Steve Schafer Fenestra Technologies Corp. http://www.fenestra.com/

4 7