- Haskell-Cafe - Haskell.org

Re: Equirecursive types?
by John Hughes 27 Mar '06

27 Mar '06

>From: Ross Paterson <ross(a)soi.city.ac.uk> > >On Sun, Mar 26, 2006 at 01:22:17PM -0500, Jim Apple wrote: > > >>According to Pierce's book, O'Caml has an optional equirecursive type >>extension that turns off the occurs check. Is there any particular >>reason Haskell doesn't have that available? >> >> > >It's certainly feasible, though turning off the occurs check doesn't >do it: you need to use the unification algorithm for regular trees (see >e.g. section 6.7 of the revised Dragon Book). You also need to decide >what to do about > > type T = T > >I think the arguments against it are: > * many common errors will lead to perfectly legal types. > * it adds convenience, but not expressive power. > * it only works for regular types, where the arguments of uses of the > type constructor on the rhs are the same as (or a permutation of) > the arguments on the lhs, so this is out: > > type T a = Either a (T (a,a)) > > > Indeed, error messages in common cases would be worsened significantly, because as Ross says, common errors (such as forgetting a parameter in a recursive call) would lead to legal definitions that cause a type error when applied. Partly for this reason, OCaml permits recursion only in object types, if I remember rightly, where it's most useful. In other cases the occurs check is still used. John

1 0

(!!) operator usage
by Neil Rutland 27 Mar '06

27 Mar '06

Hi there, I hope i have sent this in the right format - i gather i may have been rude by sending it incorrectly - if this is still wrong give me a shout. Anyway today i am enquiring about how to use the !! operator - i have looked at Zvons Haskell refeernce and it says that it takes a list( like newLine below) and an Integer for the location of the item you wish to return. Basically in this example i would like to return the value 4 type Bob = [(Int, Int)] newLine :: Bob newLine = [(1,4)] i have tried to use the follwing but it returns the error below it. newLine !! 0 - (so that should give it the newLine list and try and return the 1st element of the list) the error reads thus ERROR file:.\VicotriaLine.txt:107 - Type error in final generator *** Term : newLine !! 0 *** Type : (Int,Int) *** Does not match : IO a Could someone please try and tell me what thats all about because i can't see what i am doing wrong based on the examples i have found from the website i detailed about. Cheers everyone Neil

3 3

Building Monads from Monads
by Daniel McAllansmith 26 Mar '06

26 Mar '06

Hi, I've got a few (9) random questions, mainly about monads and building monads from existing monads, partly trying to confirm conclusions I've come to through experimentation. Any, and all, attempts to enlighten me will be much appreciated. Thanks Daniel First, terminology. In StateT s (ReaderT r IO) () Q. 1) StateT is referred to as the outermost monad, and IO as the innermost monad, correct? Using a monadic function, eg MonadReader.ask, in a monadic expression will access the outermost monad of the appropriate class. Q. 2) Does this work for all monad classes in all expressions? How does Control.Monad.Trans.lift work? It seems that a single application of lift will find the next outermost monad of the appropriate class, but if you want to dig deeper into the nest you need to apply lift according to the monads actual depth in the nest. Q. 3) Why the different behaviour? Q. 4) Is it possible to give a type to the lifted function so that the monad of the correct class _and_ type is used? E.g. dig into a String Reader rather than an Int Reader. Defining an instance of MonadTrans for a monad instance seems universally useful. Q. 5) Are there obvious situations where it's not useful or possible? Carrying out IO in a nested monadic expression requires liftIO. Apart from having to type an extra 7-9 characters it seems good to use liftIO even in plain IO monad expressions so they can become nested expressions with no trouble later on. Q. 6) Is it safe to always use liftIO, even in plain IO monad? Q. 7) If it's safe to do, why aren't functions in the IO monad just typed in the MonadIO class instead? It looks to me like types with class constraints are better than types specifying nests of monad instances. So g :: (MonadReader String m, MonadState Int m, Monad m) => m () is better than g :: StateT Int (Reader String) () because you can change the instance of the monadic class at will. Also you can change the nesting order of the monads, though maybe that's not useful in practice. The disadvantage seems to be that you can't use lift to access nested monads. Q. 8) Is it possible to get access to nested monads when using class constraint types? In the following code, the test2 function is not valid because there is no instance for (MonadCounter (ReaderT [Char] (StateT Word IO))), which is a fair enough complaint. Q. 9) What allows ReaderT and StateT to be nested in arbitrary order but not ReaderT and CounterT? Especially given CounterT is actually a StateT. class (Monad m) => MonadCounter m where increment :: m Word decrement :: Word -> m () type Counter = State Word instance MonadCounter Counter where increment = increment_ decrement = decrement_ runCounter :: Counter a -> a runCounter c = evalState c 0 type CounterT m = StateT Word m instance (Monad m) => MonadCounter (CounterT m) where increment = increment_ decrement = decrement_ runCounterT :: (Monad m) => CounterT m a -> m a runCounterT c = evalStateT c 0 increment_ :: (MonadState Word m) => m Word increment_ = do w <- get put (w + 5) return w decrement_ :: (MonadState Word m) => Word -> m () decrement_ w = do curW <- get if w > curW then put 0 else put (curW - w) return () test1 :: IO () test1 = runReaderT (runCounterT bar) "blah" --test2 :: IO () --test2 = runCounterT (runReaderT bar "blah") bar :: (MonadReader String m, MonadCounter m, MonadIO m) => m () bar = do w <- increment s <- ask liftIO $ putStrLn $ (show w) ++ s return ()

2 4

Equirecursive types?
by Jim Apple 26 Mar '06

26 Mar '06

According to Pierce's book, O'Caml has an optional equirecursive type extension that turns off the occurs check. Is there any particular reason Haskell doesn't have that available? Here's what got me thinking about it: http://lambda-the-ultimate.org/node/1360#comment-15656 Jim

2 1

The simple programming language,
by pinturicchio 26 Mar '06

26 Mar '06

if somebody can help me wid this i wil b realy thankful Finally, we come to the program. The simple programming language, which includes loops, conditionals and sequential composition will be expressed a datatype in Haskell. data Prg = Skip | PrintS String | PrintE Exp | Declare Variable | Variable := Exp | Prg :> Prg | IfThenElse Exp (Prg, Prg) | While Exp Prg The program Skip does nothing. The program PrintS ‘prints’ the given string to the output. Similarly, PrintE prints the value of the given expression to the output. Declare declares a variable, assigning its initial value to 0. The := operator performs variable assignment. The :> operator is sequential composition, while IfThenElse and While are conditional and while-loops respectively. The condition in both cases resolves to true if the value of the expression is not zero. A factorial program can be programmed in this small language as follows: counter = "counter" result = "result" factorial n = Declare counter :> Declare result :> result := Val 1 :> counter := Val n :> While (Var counter) ( result := (Var result) :*: (Var counter) :> counter := (Var counter) :-: (Val 1) ) :> PrintS ("Factorial of "++show n++" is:") :> PrintE (Var result) (a) The simulate function takes a Store and a program, and returns an updated store and list of output strings: simulate :: Store -> Prg -> (Store, [String]) Using pattern matching, define simulate for Skip, PrintS and variable declarations. (b) Add the cases for PrintE and variable assignment. (c) Sequential composition can be defined by simulating the two instructions in sequence. Complete the following case: simulate store (p1 :> p2) = let (store’, outs1) = simulate store p1 (store’’,outs2) = simulate store’ p2 in ... (d) Define simulate for conditionals. (e) We can ‘cheat’ by simulating while-loops in terms of conditionals and sequential compositi simulate store (While condition program) = simulate store (IfThenElse condition ( program :> While condition program , Skip ) ) Using this definition, test your program with the factorial program. -- View this message in context: http://www.nabble.com/The-simple-programming-language%2C-t1344638.html#a359… Sent from the Haskell - Haskell-Cafe forum at Nabble.com.

2 1

A Haskell Tutorial
by Jonathan Tang 26 Mar '06

26 Mar '06

Hi all, I've written a Haskell tutorial that walks the reader through the implementation of a Scheme interpreter: http://halogen.note.amherst.edu/~jdtang/scheme_in_48/tutorial/overview.html Instead of focusing on small examples at the Haskell REPL, it tries to show the reader how to construct a real program with Haskell. It introduces monads and IO early, and also includes error checking, state, file I/O, and all the other "hard stuff" that's frequently omitted from beginner tutorials. Am looking for feedback on two main axes: 1.) Experienced Haskell users: is this more-or-less idiomatic Haskell? Did I miss any library or language features that could make the programmer's job easier? It was my first substantial Haskell program, so I worry that I may have missed some common ways of doing things. 2.) Novices: is it clear and easy to understand? I had a tough time figuring out how to do anything practical in Haskell, because most tutorials omit IO, gloss over monads, and don't pay any attention to state or error-checking. Does this rectify those shortcomings? Comments/critiques are appreciated. Regards, Jonathan

1 0

pls fast help me with this simple question
by iliali16 26 Mar '06

26 Mar '06

type Data = Integer type Variable = String type Store = [(Variable, Data)] Store = [("",0)] emptystore :: Store emptystore = [("",0)] getVal :: Store -> Variable -> Data thats my code i just have to continue and get the value of a variable from the store but i don't know how the task is : Define a function getVal, which takes a Store and a variable name, and returns its value. You may assume that the variable is defined in the Store. getVal :: Store -> Variable -> Data (c) Define a function setVar, which takes a Store, a variable name and a value, and returns an updated Store with the variable value updated. setVal :: Store -> (Variable, Data) -> Store -- View this message in context: http://www.nabble.com/pls-fast-help-me-with-this-simple-question-t1345292.h… Sent from the Haskell - Haskell-Cafe forum at Nabble.com.

2 1

Question about "Arrows and Computation" by Paterson
by Reilly Hayes 24 Mar '06

24 Mar '06

I've been taking a close look at the paper "Arrows and Computation" by Ross Paterson. It's not relevant to my question, but I'm doing this because I think that Arrows may be a useful abstraction for a problem I have (I need to both construct a computational pipeline AND perform a computation over the pipeline itself). The paper is published as Chapter 10 in "The fun of Programming" and is also available here: http://www.soi.city.ac.uk/~ross/papers/fop.html My question originates with the statement at the bottom of page 205 (the 5th page of the paper) regarding the behavior of the function 'first': " ... while 'first' routes the state through f:". My problem is that this statement appears to be erroneous. My reading of the code would indicate that 'first' does not do this at all. The state portion of the Arrow remains unaltered. Nor does it even seem desirable for 'first' to have an impact on the state portion of the Arrow, as I would think that this would preclude using 'first' and 'second' to lift binary operators into the Arrow. So what is it that am I missing? The relevant code is as follows. Paterson used Greek letters where I have used Latin. I represented his product operator with the letter x, requiring surrounding backquotes. If there are other changes to his code I am unaware of them and they are an error on my part. class Arrow a where pure :: (b -> c) -> a b c (>>>) :: a b c -> a c d -> a b d first :: a b c -> a (b,d) (c,d) x :: (a -> a') -> (b -> b') -> (a,b) -> (a',b') (f `x` g) ~(a,b) = (f a, g b) assoc :: ((a,b),c) -> (a,(b,c)) assoc ~(~(a,b),c) = (a,(b,c)) unassoc :: (a,(b,c)) -> ((a,b),c) unassoc ~(a,~(b,c)) = ((a,b),c) newtype State s i o = ST ((s,i) -> (s,o)) instance Arrow (State s) where pure f = ST (id `x` f) (ST f) >>> (ST g) = ST (g . f) first (ST f) = ST (assoc . (f `x` id) . unassoc) -Reilly Hayes

2 2

Reading files efficiently
by Pete Chown 24 Mar '06

24 Mar '06

I've got another n00b question, thanks for all the help you have been giving me! I want to read a text file. As an example, let's use /usr/share/dict/words and try to print out the last line of the file. First of all I came up with this program: import System.IO main = readFile "/usr/share/dict/words" >>= putStrLn.last.lines This program gives the following error, presumably because there is an ISO-8859-1 character in the dictionary: "Program error: <handle>: IO.getContents: protocol error (invalid character encoding)" How can I tell the Haskell system that it is to read ISO-8859-1 text rather than UTF-8? I now used iconv to convert the file to UTF-8 and tried again. This time it worked, but it seems horribly inefficient -- Hugs took 2.8 seconds to read a 96,000 line file. By contrast the equivalent Python program: print open("words", "r").readlines()[-1] took 0.05 seconds. I assume I must be doing something wrong here, and somehow causing Haskell to use a particularly inefficient algorithm. Can anyone give me any clues what I should be doing instead? Thanks again, Pete

3 6

Define combination of type classes?
by Fritz Ruehr 24 Mar '06

24 Mar '06

What is the easiest way to name a combination of type classes, i.e., to abbreviate the fact that a certain type is an instance of several classes simultaneously? I have a vague sense that this is do-able, but that I am messing up by trying to use an empty class body as below. So in the code below, I try to use FooBar to abbreviate the conjunction of Foo and Bar. But while f (which uses a FooBar constraint) has a valid definition, it can't be used. On the other hand, g (which uses the long-winded constraint), is both a valid defined and useable. (In a real example, imagine that FooBar names a conjunction of a half dozen things, so that the g-like form really is onerous, whereas the f-like form would be sweet and tidy :) .) -- Fritz ------------------- class Foo a where foo :: a -> Int class Bar a where bar :: a -> a class (Foo a, Bar a) => FooBar a f :: FooBar a => a -> Int f a = foo (bar a) g :: (Foo a, Bar a) => a -> Int g a = foo (bar a) instance Foo Char where foo = ord instance Bar Char where bar = id

3 2

how would this be done? type classes? existential types?
by Matthias Fischmann 23 Mar '06

23 Mar '06

hi, this is one of those situations that always make scheme and perl hackers laugh at me: i have written a piece of code that is intuitively clear, and now i am trying to turn it into something that compiles. and here it goes. i have a type class that looks something like this: class Resource a where resourceName :: a -> String resourceAdvance :: a -> a resourceStarved :: a -> Bool resourceSpend :: a -> Int -> a resourceEarn :: a -> Int -> a resource types are rice, crude oil, pizza, software code, and so on. they all have a different internal structure and the same abstract interface, that's why i have defined this type class. now i want to create a list of a type similar to [r1, r2, r3] :: (Resource a) => [a] but with r1 being pizza, r2 being crude oil, and so on. my first idea was this: data Rs = forall a . (Resource a) => Rs a unRs (Rs a) = a rsName :: Rs -> String rsName = resourceName . unRs ... and then export Rs as an abstract data type. this would allow for lists of type [Rs], which is exactly what i want. but what is the type of unRs? or better: can i make it type at all? and isn't this solution a little redundant and verbose? should i do it like in the example for existentially quantified types in the ghc manual? http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html but wouldnt't the code become really messy? or should i do the type class and instances, and then do Rs the existentially quantified way, with all class methods arguments to the Rs constructor? or is there a completely different way to do this (besides using scheme or perl :-)? thanks, matthias

6 9

Code Review: Sudoku solver
by David F. Place 23 Mar '06

23 Mar '06

Hi All, I really appreciate all the help I received when I asked you to critique my PrefixMap module a few weeks ago. I think I am making good progress in correcting the "lisp" in my Haskell programming. I'll be very grateful to anyone who can take a glance at the attached short program and say if any unidiomatic usages pop out. It solves sudoku puzzles. (What pleasure do people get by doing these in their heads?!?) Cheers, David -------------------------------- David F. Place mailto:d@vidplace.com

4 4

Wheres this going wrong
by Neil Rutland 22 Mar '06

22 Mar '06

3 2

strange ghc program behaviour
by Koen.Roelandt＠mineco.fgov.be 22 Mar '06

22 Mar '06

Hi, I'm a Haskell newbie using HaXml for the conversion of xml files into html files. I'm using GHC 6.4 to compile the program. When I run the program, it will not convert the whole file: the document tree is incomplete and will stop when the limit of e.g. 8k has been reached. E.g. An xml file of 12.3k will result in a file of 8k and will stop at 8k An xml file of 15.7k will result in a file of 16k An xml file of 36k will result in a file of 24k In an output to the screen (and not to a file), the whole document tree is being generated. Am I missing something obvious here (memory issues)? On compilation, ghc issues warnings about the class FiniteMap and Module IOExts being deprecated. Is this the cause? Any ideas? Cheers, K.

3 3

Returning a list element?
by Neil Rutland 22 Mar '06

22 Mar '06

4 4

Re: Associated types and data constructors (was: the MPTC Dilemma (please solve))
by Manuel M T Chakravarty 22 Mar '06

22 Mar '06

David Menendez: > This is something I've been wondering about for a while. Can you do that > sort of thing with associated types? > > As another example, consider this type class for composible continuation > monads: > > class Monad m => MonadCC p sk m | m -> p sk where > newPrompt :: m (p a) > pushPrompt :: p a -> m a -> m a > withSubCont :: p b -> (sk a b -> m b) -> m a > pushSubCont :: sk a b -> m a -> m b > > You can use instances of this class to create backtracking monads, along > these lines: > > data Tree m a = HZero | HOne a | HChoice a (m (Tree m a)) > newtype SR p m a = SR (forall ans. ReaderT (p (Tree m ans)) m a) > > instance MonadCC p sk m => MonadPlus (SR p m) > > With associated types, the MonadCC class becomes: > > class Monad m => MonadCC m where > type Prompt m a > type SubCont m a b > > newPrompt :: m (Prompt m a) > pushPrompt :: Prompt m a -> m a -> m a > withSubCont :: Prompt m b -> (SubCont m a b -> m b) -> m a > pushSubCont :: SubCont m a b -> m a -> m b > > Since |Prompt m| is determined by |m|, can we eliminate the prompt > parameter from SR? > > newtype SR' m a > = SR' (forall ans. ReaderT (Prompt m (Tree m ans)) m a) > > instance MonadCC m => MonadPlus (SR' m) Yes, that's right. > That would presumably lead to SR' having the type > > SR' :: (MonadCC m) => ReaderT (Prompt m (Tree m ans)) m a -> SR' m a > > That doesn't seem like it should be a problem, since it's impossible to > create a value of type |ReaderT (Prompt m (Tree m ans)) m a| unless m is > an instance of MonadCC, but it also puts a context on a newtype data > constructor, which isn't currently allowed. If you go by the rules in the associated types paper, you need to put that context there. However, whether that context is really needed is the topic of an ongoing discussion. Without that sort of context, you can write programs where type errors are raised a bit later than if you have the context, but type safety doesn't seem to be affected by those contexts. The fact that newtype cannot have a context is an argument in favour of not requiring the context. As your example shows, associated types (in comparison to FDs) not only eliminate type arguments from classes, but also from data type declarations. IMHO this improves the readability of programs. Manuel

1 0

Arrows, wxFruit
by Gerbrand van Dieijen 20 Mar '06

20 Mar '06

Hello, I am working on a thesis project which involves for a large part constructing a gui. In short, I want to create a combinator library that gives (a subset of) functionality, reporting libraries as Crystal reports offer. I read about Yampa and Fruit and wxFruit and both seem a very elegant way to construct a gui.Unfortunately, Fruit uses a rather low-level library which makes it of less use. wxFruit looks very nice, but the library does not seem to be maintained anymore. First, is wxFruit still maintained, or are there any plans to further develop it. Or, can you recommend other libraries/frameworks to construct a gui using combinators, that use higher level libraries such as wxHaskell? (An other possibility would be to use wxHaskell only and construct the combinators entirely myself. This might be the most flexible approach.) Second, I can't get wxFruit to compile on my machine. When I compile I use the following command-line: ghci -fglasgow-exts -package data -package wx -i/users/gjhdieij/dowload/afrp-0.4/src WXFruit.hs The packages than almost loads, but I still get the following errors (GHC 6.4, wxHaskell 0.9.4) . Does anyone know a sollution? /users/gjhdieij/dowload/afrp-0.4/src/AFRPUtilities.hs:169:46: Ambiguous occurrence `>>^' It could refer to either `AFRPUtilities.>>^', defined at /users/gjhdieij/dow load/afrp-0.4/src/AFRPUtilities.hs:106:2 or `Control.Arrow.>>^', imported from AFRP at /users/g jhdieij/dowload/afrp-0.4/src/AFRPUtilities.hs:90:0-10 /users/gjhdieij/dowload/afrp-0.4/src/AFRPUtilities.hs:178:48: Ambiguous occurrence `>>^' It could refer to either `AFRPUtilities.>>^', defined at /users/gjhdieij/dow load/afrp-0.4/src/AFRPUtilities.hs:106:2 or `Control.Arrow.>>^', imported from AFRP at /users/g jhdieij/dowload/afrp-0.4/src/AFRPUtilities.hs:90:0-10 (etc.)

1 0

First Question
by Neil Rutland 20 Mar '06

20 Mar '06

6 5

Looking for an efficient tree in STM
by Einar Karttunen 20 Mar '06

20 Mar '06

Hello Does anyone have an efficient tree implemented in STM that supports concurrent updates in an efficient fashion? This seems suprisingly hard to implement - a normal binary tree with links as TVar is very slow and does not scale very well. - Einar Karttunen

5 5

hs-plugins/ haskelldb/ ELF zlib incompatibility.
by Marc Weber 20 Mar '06

20 Mar '06

I get this error: calhost db=store uid=marc pwd=" DB/Direct: Daan Leijen (c) 1999, HWT (c) 2003-2004, Bjorn Bringert (c) 2005 Connecting to database... DBDirect: user error (loadShared: couldn't load `/usr/lib/libz.so' because /usr/lib/libz.so: invalid ELF header Any idea how to fix it ? (What to watch for?) latest cvs ghc, latest darcs hs-plugins (dons told me to ask the haskelldb how they managed to run it..) I've tried compiling with -lz option. Same result. I'm also posting here because I don't know how frequently the haskelldb mailinglist is read yet.. It doesn't seem to be used by that much people yet. Marc

2 2

RE: [Haskell-cafe] Type classes
by Geest, G. van den 20 Mar '06

20 Mar '06

I suppose you want to define compareEntries like this: > compareEntries (Entry x) (Entry y) = compareEntries x y An option is to just implement it the following way (Haskell98!): > class DatabaseEntry e where > entryLabel :: e -> String > formatEntry :: e -> String > compareEntries :: e -> e -> Ordering > > data Entry a = Entry a > > instance DatabaseEntry a => DatabaseEntry (Entry a) where > entryLabel (Entry e) = entryLabel e > formatEntry (Entry e) = formatEntry e > compareEntries (Entry x) (Entry y) = compareEntries x y Gerrit -----Original Message----- From: haskell-cafe-bounces(a)haskell.org on behalf of Max Vasin Sent: Mon 3/20/2006 3:46 PM To: haskell-cafe(a)haskell.org Subject: [Haskell-cafe] Type classes Hi! I'm currently experimenting with a bibliography generation tool for LaTeX. It will (if it will be finished) use BibTeX databases but bibliography styles will be written in Haskell. I want styles to be able to transform database entries into some style specific data type, so I define > class DatabaseEntry e where > entryLabel :: e -> String > formatEntry :: e -> String > compareEntries :: e -> e -> Ordering Then I define > data Entry = forall a. (DatabaseEntry a) => Entry a > instance DatabaseEntry Entry where > entryLabel (Entry e) = entryLabel e > formatEntry (Entry e) = formatEntry e How can I define compareEntries for this instance? -- WBR, Max Vasin. _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

3 2

Type classes
by Max Vasin 20 Mar '06

20 Mar '06

Hi! I'm currently experimenting with a bibliography generation tool for LaTeX. It will (if it will be finished) use BibTeX databases but bibliography styles will be written in Haskell. I want styles to be able to transform database entries into some style specific data type, so I define > class DatabaseEntry e where > entryLabel :: e -> String > formatEntry :: e -> String > compareEntries :: e -> e -> Ordering Then I define > data Entry = forall a. (DatabaseEntry a) => Entry a > instance DatabaseEntry Entry where > entryLabel (Entry e) = entryLabel e > formatEntry (Entry e) = formatEntry e How can I define compareEntries for this instance? -- WBR, Max Vasin.

3 3

Associated types and data constructors (was: the MPTC Dilemma (please solve))
by David Menendez 19 Mar '06

19 Mar '06

(I've moved this from haskell' to haskell-cafe, because it's more a question about associated types than about resolving the MPTC dilemma.) Bulat Ziganshin writes: > Hello Manuel, > > MMTC> My statement remains: Why use a relational notation if you can > MMTC> have a functional one? > > how about these examples? > > MMTC> class Monad m => RefMonad m where > MMTC> type Ref m :: * -> * > > can i use `Ref` as type function? for example: > > data StrBuffer m = StrBuffer (Ref m Int) > (Ref m String) > This is something I've been wondering about for a while. Can you do that sort of thing with associated types? As another example, consider this type class for composible continuation monads: class Monad m => MonadCC p sk m | m -> p sk where newPrompt :: m (p a) pushPrompt :: p a -> m a -> m a withSubCont :: p b -> (sk a b -> m b) -> m a pushSubCont :: sk a b -> m a -> m b You can use instances of this class to create backtracking monads, along these lines: data Tree m a = HZero | HOne a | HChoice a (m (Tree m a)) newtype SR p m a = SR (forall ans. ReaderT (p (Tree m ans)) m a) instance MonadCC p sk m => MonadPlus (SR p m) With associated types, the MonadCC class becomes: class Monad m => MonadCC m where type Prompt m a type SubCont m a b newPrompt :: m (Prompt m a) pushPrompt :: Prompt m a -> m a -> m a withSubCont :: Prompt m b -> (SubCont m a b -> m b) -> m a pushSubCont :: SubCont m a b -> m a -> m b Since |Prompt m| is determined by |m|, can we eliminate the prompt parameter from SR? newtype SR' m a = SR' (forall ans. ReaderT (Prompt m (Tree m ans)) m a) instance MonadCC m => MonadPlus (SR' m) That would presumably lead to SR' having the type SR' :: (MonadCC m) => ReaderT (Prompt m (Tree m ans)) m a -> SR' m a That doesn't seem like it should be a problem, since it's impossible to create a value of type |ReaderT (Prompt m (Tree m ans)) m a| unless m is an instance of MonadCC, but it also puts a context on a newtype data constructor, which isn't currently allowed. Sure, it's still possible to do this: instance MonadCC m => MonadPlus (SR (Prompt m) m) but that doesn't feel like a big win. -- David Menendez <zednenem(a)psualum.com> | "In this house, we obey the laws <http://www.eyrie.org/~zednenem> | of thermodynamics!"

1 0

STUArray
by Frederik Eaton 18 Mar '06

18 Mar '06

Hi all, I'm trying to figure out how to use STUArray. Is it possible to let it be polymorphic? Here is an excerpt from my program: class (IArray UArray k, Ord k, Fractional k) => Elt k class (Bounded a, Enum a, Ix a, Eq a, Show a) => IxB a -- |like Array but uses IxB instead of Ix newtype Vector k i = Vector (UArray.UArray i k) deriving (Eq) margin :: (IxB a, IxB b, Elt k, (MArray (STUArray s) k (ST s))) => Vector k a -> (a -> b) -> Vector k b margin (Vector v) f = Vector (runSTUArray (do ax <- newArray (minBound, maxBound) 0 mapM_ (\ (i,x) -> updateArray ax (f i) (+x)) (assocs v) return ax )) where updateArray ax i f = do e <- readArray ax i writeArray ax i (f e) When I try to run it, I get the following error. I think I understand what the error means, but not how to fix the problem: Vector2.hs:166:22: No instance for (MArray (STUArray s) k (ST s)) arising from use of `updateArray' at Vector2.hs:166:22-32 Probable fix: add (MArray (STUArray s) k (ST s)) to the expected type of an expression or add an instance declaration for (MArray (STUArray s) k (ST s)) In a lambda abstraction: \ (i, x) -> updateArray ax (f i) ((+ x)) In the first argument of `mapM_', namely `(\ (i, x) -> updateArray ax (f i) ((+ x)))' In a 'do' expression: mapM_ (\ (i, x) -> updateArray ax (f i) ((+ x))) (assocs v) Thanks in advance, Frederik -- http://ofb.net/~frederik/

5 7

RE: [Haskell-cafe] how would this be done? type classes? existentialtypes?
by Geest, G. van den 18 Mar '06

18 Mar '06

Try using a GADT: data Rs where Rs :: Resource a => a -> Rs class Resource a where resourceName :: a -> String instance Resource String where resourceName x = "String" instance Resource Int where resourceName x = "Int" resName (Rs x) = resourceName x resNames = map resName test = resNames [Rs "Hi", Rs (1::Int) ] The most important observations is that when pattern matching on (Rs x) we cannot make any assumptions about x, except using the class members of Resource. We hope this will help you, Gerrit (and the rest of the ST-lab) -----Original Message----- From: haskell-cafe-bounces(a)haskell.org on behalf of Matthias Fischmann Sent: Thu 3/16/2006 12:57 PM To: haskell-cafe(a)haskell.org Subject: [Haskell-cafe] how would this be done? type classes? existentialtypes? hi, this is one of those situations that always make scheme and perl hackers laugh at me: i have written a piece of code that is intuitively clear, and now i am trying to turn it into something that compiles. and here it goes. i have a type class that looks something like this: class Resource a where resourceName :: a -> String resourceAdvance :: a -> a resourceStarved :: a -> Bool resourceSpend :: a -> Int -> a resourceEarn :: a -> Int -> a resource types are rice, crude oil, pizza, software code, and so on. they all have a different internal structure and the same abstract interface, that's why i have defined this type class. now i want to create a list of a type similar to [r1, r2, r3] :: (Resource a) => [a] but with r1 being pizza, r2 being crude oil, and so on. my first idea was this: data Rs = forall a . (Resource a) => Rs a unRs (Rs a) = a rsName :: Rs -> String rsName = resourceName . unRs ... and then export Rs as an abstract data type. this would allow for lists of type [Rs], which is exactly what i want. but what is the type of unRs? or better: can i make it type at all? and isn't this solution a little redundant and verbose? should i do it like in the example for existentially quantified types in the ghc manual? http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html but wouldnt't the code become really messy? or should i do the type class and instances, and then do Rs the existentially quantified way, with all class methods arguments to the Rs constructor? or is there a completely different way to do this (besides using scheme or perl :-)? thanks, matthias -----Original Message----- From: haskell-cafe-bounces(a)haskell.org on behalf of Matthias Fischmann Sent: Thu 3/16/2006 12:57 PM To: haskell-cafe(a)haskell.org Subject: [Haskell-cafe] how would this be done? type classes? existentialtypes? hi, this is one of those situations that always make scheme and perl hackers laugh at me: i have written a piece of code that is intuitively clear, and now i am trying to turn it into something that compiles. and here it goes. i have a type class that looks something like this: class Resource a where resourceName :: a -> String resourceAdvance :: a -> a resourceStarved :: a -> Bool resourceSpend :: a -> Int -> a resourceEarn :: a -> Int -> a resource types are rice, crude oil, pizza, software code, and so on. they all have a different internal structure and the same abstract interface, that's why i have defined this type class. now i want to create a list of a type similar to [r1, r2, r3] :: (Resource a) => [a] but with r1 being pizza, r2 being crude oil, and so on. my first idea was this: data Rs = forall a . (Resource a) => Rs a unRs (Rs a) = a rsName :: Rs -> String rsName = resourceName . unRs ... and then export Rs as an abstract data type. this would allow for lists of type [Rs], which is exactly what i want. but what is the type of unRs? or better: can i make it type at all? and isn't this solution a little redundant and verbose? should i do it like in the example for existentially quantified types in the ghc manual? http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html but wouldnt't the code become really messy? or should i do the type class and instances, and then do Rs the existentially quantified way, with all class methods arguments to the Rs constructor? or is there a completely different way to do this (besides using scheme or perl :-)? thanks, matthias

3 3

Re: dynamic arrays
by Jared Updike 17 Mar '06

17 Mar '06

(Moved to haskell-cafe) JU> General question to the list: JU> (Q) Are there any data structures in Haskell similar to C++/STL JU> vectors or C# generic Lists (i.e. strongly typed ArrayLists, e.g. JU> List<int>)? These data structures grow automatically as you add JU> elements to them (but in large chunks, not one node at a time). This JU> data structure (if it exists in Haskell) would run inside a monad (ST JU> and/or IO) and it would automaticly resize when needed, but would be JU> more or less like a mutable array except you can add new elements to JU> the end of it without reallocating an entire array of n+1 elements... i tried to implement this today :) but there is one problem: > if i have (l,u) - array bounds of type Ix, and i - offending index of > the same type, how can i compute new bounds of array so that it will > grow in large chunks? there is no such computation operations for > Ix type and that is logical - if this array is really a matrix then > it's hard to use the same rules of extending it as for vectors Hmmm, that is a problem, especially as you said, for enum types that are bounded above. I guess you can't make it grow more than the min and max. For the most part, this dynamic array would only be useful for arrays with indices isomorphic to the natural numbers. > such computation as (u-l)*2+l is great for integral indexes, but not > for general case. now i plan to use this strategy for all enum types > and just "grow to minimal and maximal indexes actually used" for other > index types Perhaps the function to build these DynamicArrays could take a Maybe parameter telling the maximum possible range (for bounded enums) or Nothing if the array is allowed to grow indefinitely. Or an Either parameter where Left (a,a) tells the max range and Right (a,a) -> (a,a) which tells how the range should grow on a resize. Or just the range resize function :: (a,a) -> (a,a) telling how to grow on a resize, i.e. for enums function = id. Something like that. Jared.

4 5

different code in different platforms
by José Miguel Vilaça 17 Mar '06

17 Mar '06

Sorry. In the previous email I forgot the subject. Hi Im having a small problem with the portability of my Haskell code. My code uses wxHaskell and the library for which this one is the Haskell interface (that is called wxWidgets) doesnt work in the same away in Windows and Linux. Now I now which code run in Linux and in Windows but I dont want to have to manually change the file in each platform. I tried a solution using the C pre-processor but I getting in trouble. I use code like: #ifdef __WIN32__ (Windows code) #else (Linux code) #endif I also add the --cpp to the ghc and it works for me in Linux but give me linking errors in Windows. Does someone have any hints on how to have different code in Windows and Linux? I would be thankful in some help. Best regards Miguel Vilaça

5 4

Re: [Haskell-cafe] how would this be done? type classes? existential types?
by Matthias Fischmann 16 Mar '06

16 Mar '06

Alexandra Silva <xana(a)di.uminho.pt> wrote: > http://homepages.cwi.nl/~ralf/HList/ this looks like it might address my problems with Read / Eq instantiation? will read. thanks again to everybody. m.

1 0

Learning from scratch
by Xavier Elizalde 16 Mar '06

16 Mar '06

I'm just starting to learn Haskell from scratch and I've just hit a snag. The book "Haskell: The Craft of Functional Programming, Second Edition" uses some examples that call functions from Prelude.hs. But for some reason, two installations of Haskell that I have on my computer don't have the functions available. I have the OS X version of Hugs (http://www.haskell.org/soe/software.htm) for the book "The Haskell School of Expression" installed, as well as the latest version of the Glasgow Haskell Compiler. Both of them get errors with the functions such as "ord" and "chr" mentioned at the beginning of the first book mentioned. Where can I get Prelude.hs and the other files it needs, and what do I do with them? I'm going to move on to the School of Expression book after the Craft of Functional Programming book, which is why I have the SOE version of hugs installed.

2 1

(no subject)
by José Miguel Vilaça 15 Mar '06

15 Mar '06

Hi Im having a small problem with the portability of my Haskell code. My code uses wxHaskell and the library for which this one is the Haskell interface (that is called wxWidgets) doesnt work in the same away in Windows and Linux. Now I now which code run in Linux and in Windows but I dont want to have to manually change the file in each platform. I tried a solution using the C pre-processor but I getting in trouble. I use code like: #ifdef __WIN32__ (Windows code) #else (Linux code) #endif I also add the --cpp to the ghc and it works for me in Linux but give me linking errors in Windows. Does someone have any hints on how to have different code in Windows and Linux? I would be thankful in some help. Best regards Miguel Vilaça

2 1

request for code review
by Shannon -jj Behrens 15 Mar '06

15 Mar '06

Hi, I'm working on another article like <http://www.linuxjournal.com/article/8850>. This time, I'm taking an exercise out of "Expert C Programming: Deep C Secrets" and translating it into Haskell. The program translates C type declarations into English. I would greatly appreciate some code review. I'd prefer to look like an idiot in front of you guys rather than in front of everyone in the world! ;) Please understand, I am not a Haskell expert! Therefore, please make your suggestions simple enough that I can actually accomplish them! By the way, my code *mostly* follows the code laid out in the book. I don't use a lexer or a parser or greatly improve on his algorithm. I'd like the Haskell and C versions to be similar so that they can be compared. The C version is: <http://www.cs.may.ie/~jpower/Courses/compilers/labs/lab3/parse_decl.c> The Haskell version is below. Thanks! -jj {- Translate C type declarations into English. This exercise was taken from "Expert C Programming: Deep C Secrets", p. 84. Example: echo -n "int *p;" | runhugs cdecl.hs Name: Shannon -jj Behrens <jjinux(a)gmail.com> Date: Fri Feb 17 00:03:38 PST 2006 -} import Char (isSpace, isAlphaNum, isDigit) -- |> is like a UNIX pipe. infixl 9 |> x |> f = f x data TokenType = Identifier | Qualifier | Type | Symbol Char deriving (Show, Eq) data Token = Token { tokenType :: TokenType, tokenValue :: String } deriving Show data ParseContext = ParseContext { input :: String, -- The input that has not been parsed yet. output :: [String], -- A list of strings in the reverse order of that which -- they should be printed (e.g. [" a dog.", "I have"]). currTok :: Token, -- The current token, if defined. stack :: [Token] -- A stack of tokens we haven't dealt with yet. } deriving Show -- For convenience: currTokType :: ParseContext -> TokenType currTokType ctx = ctx |> currTok |> tokenType currTokValue :: ParseContext -> String currTokValue ctx = ctx |> currTok |> tokenValue type ParseContextTransformation = ParseContext -> ParseContext -- Start a new ParseContext given an input string. createParseContext :: String -> ParseContext createParseContext input = ParseContext {input=input, output=[], stack=[]} -- Create the final output string given a ParseContext. consolidateOutput :: ParseContext -> String consolidateOutput ctx = ctx |> output |> reverse |> concat {- "Write" to a ParseContext's output. The API is a bit strange. (writeOutput s) is itself a ParseContextTransformation which you can apply to ParseContexts. Strange but convenient. -} writeOutput :: String -> ParseContextTransformation writeOutput s = \ctx -> let newOutput = s : (output ctx) in ctx {output=newOutput} -- Return the top token on the stack. stackTop :: ParseContext -> Token stackTop ctx = let (x:xs) = stack ctx in x -- Pop the stack. pop :: ParseContextTransformation pop ctx = let (x:xs) = stack ctx in ctx {stack=xs} -- Write the value of the top of the stack and then pop it. popAndWrite :: ParseContextTransformation popAndWrite ctx = ctx |> ((stackTop ctx) |> tokenValue |> writeOutput) |> pop -- Classify a string into a Token. classifyString :: String -> Token classifyString "const" = Token Qualifier "read-only" classifyString "*" = Token (Symbol '*') "pointer to" classifyString s@(c:[]) | not (isAlphaNum c) = Token (Symbol c) s classifyString s = Token (whichType s) s where whichType "volatile" = Qualifier whichType "void" = Type whichType "char" = Type whichType "signed" = Type whichType "unsigned" = Type whichType "short" = Type whichType "int" = Type whichType "long" = Type whichType "float" = Type whichType "double" = Type whichType "struct" = Type whichType "union" = Type whichType "enum" = Type whichType _ = Identifier -- Read the next token into currTok. getToken :: ParseContextTransformation getToken ctx@(ParseContext {input=s}) = let lstrip s = dropWhile isSpace s (token, theRest) = s |> lstrip |> lexString in ctx {currTok=token, input=theRest} -- Read a token. Return it and the left-over portion of the string. lexString :: String -> (Token, String) lexString s@(c:cs) | isAlphaNum c = let (tokString, theRest) = span isAlphaNum s token = classifyString tokString in (token, theRest) lexString ('*':cs) = (classifyString "*", cs) lexString (c:cs) = (classifyString (c:[]), cs) -- Put tokens on the stack until we reach the first identifier. readToFirstIdentifier :: ParseContextTransformation readToFirstIdentifier ctx = let afterIdentifier = ctx |> getToken |> pushUntilIdentifier identifier = afterIdentifier |> currTokValue s = identifier ++ " is " in (afterIdentifier {output=[s]}) |> getToken -- Keep pushing tokens until we hit an identifier. pushUntilIdentifier :: ParseContextTransformation pushUntilIdentifier ctx | currTokType ctx == Identifier = ctx | otherwise = let newStack = (currTok ctx) : (stack ctx) in (ctx {stack=newStack}) |> getToken |> pushUntilIdentifier -- Deal with arrays. dealWithArrays :: ParseContextTransformation dealWithArrays ctx = let writeIfNumber ctx = -- Call writeSize if a number. if ctx |> currTokValue |> (!! 0) |> isDigit then ctx |> writeSize |> getToken else ctx writeSize ctx = -- Output the array size. let num = ctx |> currTokValue |> read |> (+ -1) |> show s = "0.." ++ num ++ " " in ctx |> (writeOutput s) in case currTokType ctx of Symbol '[' -> ctx |> (writeOutput "array ") |> getToken |> writeIfNumber |> getToken |> (writeOutput "of ") |> dealWithArrays _ -> ctx -- Recurse until we get past the ['s. -- Deal with function arguments. dealWithFunctionArgs :: ParseContextTransformation dealWithFunctionArgs ctx = let getUntilParen ctx = -- Read tokens until we hit ). case currTokType ctx of Symbol ')' -> ctx _ -> ctx |> getToken |> getUntilParen in ctx |> getUntilParen |> getToken |> (writeOutput "function returning ") -- Deal with pointers. dealWithPointers :: ParseContextTransformation dealWithPointers ctx = case ctx |> stackTop |> tokenType of Symbol '*' -> ctx |> popAndWrite |> (writeOutput " ") |> dealWithPointers _ -> ctx -- Recurse until we get past the *'s. -- Process tokens that we stacked while reading to identifier. dealWithStack :: ParseContextTransformation dealWithStack ctx = case stack ctx of [] -> ctx (x:xs) -> case tokenType x of Symbol '(' -> ctx |> pop |> getToken |> dealWithDeclarator _ -> ctx |> popAndWrite -- Do all parsing after first identifier. dealWithDeclarator :: ParseContextTransformation dealWithDeclarator ctx = ctx |> (case currTokType ctx of Symbol '[' -> dealWithArrays Symbol '(' -> dealWithFunctionArgs _ -> id) |> dealWithPointers |> dealWithStack -- Translate a C type declaration into English. translate :: String -> String translate s = s |> createParseContext |> readToFirstIdentifier |> dealWithDeclarator |> consolidateOutput -- Change this to "show" to debug. -- Main main :: IO () main = do input <- getContents input |> translate |> putStrLn

12 20

Deepest functor [was: fmap for lists of lists of lists of ...]
by oleg＠pobox.com 15 Mar '06

15 Mar '06

Greg Buchholz wrote: > Is it possible to make a typeclass like Functor, that has a function > (say "f_map"), which would work for the infinite hierarchy of types: > ([],[[]],[[[]]],...)? You do understand that this requires overlapping instances? Because the type [[Bool]] is still a list. In general, an instance that matches on the type [[a]] will also match [[[a]]], etc. That's where the IsFunction-like trick comes in handy. Please note that the overlapping instances are only needed for the implementation of the IsCollection predicate. The typeclass for the deep Funct needs no overlapping instances. The code below is more general that required. It also generic: it works for any Functor and any combination of Functors. It performs fmap over arbitrarily deep `collections': lists of maybes of maps of IOs, etc. -- arbitrarily nested fmappable things. test3 = f_map not (Just [Just True, Nothing]) test4 = f_map not (print "here" >> return (Just (Just [Just [True], Nothing]))) >>= print > {-# OPTIONS -fglasgow-exts #-} > {-# OPTIONS -fallow-undecidable-instances #-} > {-# OPTIONS -fallow-overlapping-instances #-} > > module FMAP where > > data Atom > > -- Check if a type is a collection type. This is the only typeclass that > -- needs overlapping instances > class IsCollection t coll | t -> coll > instance IsCollection (m a) (m ()) > instance TypeCast Atom coll => IsCollection t coll > > -- our common working horse > class TypeCast a b | a -> b, b->a where typeCast :: a -> b > class TypeCast' t a b | t a -> b, t b -> a where typeCast' :: t->a->b > class TypeCast'' t a b | t a -> b, t b -> a where typeCast'' :: t->a->b > instance TypeCast' () a b => TypeCast a b where typeCast x = typeCast' () x > instance TypeCast'' t a b => TypeCast' t a b where typeCast' = typeCast'' > instance TypeCast'' () a a where typeCast'' _ x = x > > -- The desired deep functor. Needs no overlapping instances > class Funct a b c1 c2 | c1 -> a, c1 b -> c2 where > f_map :: (a -> b) -> c1 -> c2 > > instance (IsCollection c1 coll, Funct' coll a b c1 c2) > => Funct a b c1 c2 where > f_map = f_map' (undefined::coll) > > class Funct' coll a b c1 c2 | coll c1 -> a, coll c1 b -> c2 where > f_map' :: coll -> (a -> b) -> c1 -> c2 > > instance Funct' Atom a b a b where > f_map' _ = id > > instance (Functor m, Funct a b c d) => Funct' (m ()) a b (m c) (m d) where > f_map' _ = fmap . f_map > > > test1 = f_map (+1) [[[1::Int,2,3]]] > test2 = f_map not [[True], [False]] > test3 = f_map not (Just [Just True, Nothing]) > test4 = f_map not (print "here" >> > return (Just (Just [Just [True], Nothing]))) > >>= print

3 2

More STUArray questions
by Martin Percossi 15 Mar '06

15 Mar '06

Hello, I am trying to write a haskell-native matrix library (providing a similar set of functionality as gsl's matrix/eigenvector routines). I have had a look at other attempts at matrix libraries, and have found Hal Daume's and Alberto Ruiz's libraries to offer a good amount of functionality. There are two major reasons for wanting to write my own library: 1. Haskell-nativeness: I have had some issues compiling and linking with gsl libraries on 64-bit platforms. Also, it would be quite interesting to gauge haskell's effectiveness as a scientific computing platform, in particular making use unboxed arrays as representation. 2. Use of monads: in the afore-mentioned libraries, monads are either ignored, or are restricted to the IO monad. I am taking a different approach, starting my code from the ST monad, and eventually this will be generalized to work with the IO monad. I think the ST monad is a good monad to be able to perform computations on matrices that update them, allowing efficient, in-place algorithms, but it also provides the benifit of not being a one-way street like the IO monad is. Being a relative newcomer to haskell, I would be interested to hear any thoughts as to whether this is a good/bad idea. Now to my question: I would like to represent a matrix as a wrapper around a block, which in turn is just an unboxed array. Here are the definitions for a matrix in ST and outside of a monad, respectively: type MBlock s = STUArray s Int Double data MMatrix s = MMatrix Int Int (MBlock s) type Block = UArray Int Double data Matrix = Matrix Int Int Block Now, I have started by providing some fairly low-level routines in the ST monad. My problem is depressingly simple: I would like to retrieve a matrix from the ST monad for use outside of it (in particular, to pretty-print it). Now, this is easy for STUArrays (just use runSTUArray), but I'm not sure of how to do it for a type that *encloses* an STUArray. For example, here's a simple test: runMatrix = do _A <- newListMatrix [[2, 0, 0], [0, 2, 0], [0, 0, 2]] _B <- newListMatrix [[1, 2, 1], [0, 1, 1], [0, 0, 1]] _C <- matMul _A _B return $ getBlock _C main = show $ runSTUArray runMatrix Obviously, what I get as a result of runSTUArray is a UArray, which is a pain because I'd then have to box it "by hand" (i.e. again specifying the number of rows and columns), instead of automatically, in order to have a Matrix again. So what I'd like is a runSTMatrix routine, which would possibly have signature: runSTMatrix :: ST s (Matrix s) -> Matrix which would have semantics analogous to runSTUArray. Does anyone have any idea of how I can write runSTMatrix? Many thanks in advance, Martin

5 10

fmap for lists of lists of lists of ...
by Greg Buchholz 15 Mar '06

15 Mar '06

Is it possible to make a typeclass like Functor, that has a function (say "f_map"), which would work for the infinite hierarchy of types: ([],[[]],[[[]]],...)? Does that make sense? This doesn't work... >class Funct f where > f_map :: (a -> b) -> f a -> f b > >instance Funct [] where > f_map = map > >instance Funct a => Funct [a] where > f_map f = map (f_map f) > >main = print $ fmap (+1) [[[1,2,3]]] ...but maybe it gets the idea across? Thanks, Greg Buchholz

1 0

GUI-Woes
by Daniel Fischer 15 Mar '06

15 Mar '06

Hello All, how would I get myself a working (and easy to use) GUI-library? Fudgets looks good, but I couldn't get it to build. I downloaded the snapshot from 2005, how to compile says make ghc-all; make ghc-install, but it doesn't work. First, in several scripts/makefiles, the ghc version 4.06 was hardwired, after some editing make complained about not finding lmlmk, whatever that is. If that's all that I would need to build it successfully, where would I get it? I also tried FranTk, doesn't look bad either, but has ghc -version 4.04 hardwired, imports IOExts, which I think would have to be replaced with GHC.Exts, and Addr, which I have no clue what it should be now, anyway, it seems pre-hierarchical-libraries, which would mean a lot of editing the source-files. So, since Fudgets does work in principle, - which version should I use and where do I get it? - what else would I have to download to get it to build? - in case it isn't straightforward, how to build it? I have a linux machine with ghc-6.4.1 and hugs, no HBC, NHC, JHC,..., no GTk2hs (would I need that?). Thanks, Daniel -- "In My Egotistical Opinion, most people's C programs should be indented six feet downward and covered with dirt." -- Blair P. Houghton

4 7

Re: [Haskell] Trying to get a Composite design pattern to work
by Jared Updike 15 Mar '06

15 Mar '06

(Moved to haskell-cafe) > Actually, I'm trying to avoid library functions, so I can learn the > language and the functional way of thinking. How would one implement > the concatMap function? The Haskell 98 report gives possible implementations of standard functions: http://haskell.org/onlinereport/standard-prelude.html e.g. foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x : map f xs concat :: [[a]] -> [a] concat xss = foldr (++) [] xss concatMap :: (a -> [b]) -> [a] -> [b] concatMap f = concat . map f etc. The book Haskell School of Expression (by Paul Hudak) goes over using recursion as a control structure and then shows you how to replace your simple recursion patterns with library functions once you start to see these general patterns. As you start to understand the functional style of iterating over lists, you should begin to see when to use the library functions, and how it will save you time and be more simple and clear than using recursion directly for every function. If you want a place to start, I would challenge you to expand the concatMap definition above with the definitions of concat and map, and then plug in the definition of foldr and see if you can make your own concatMap function. Maybe that will help you understand things better. Hope that helps, Jared. -- http://www.updike.org/~jared/ reverse ")-:"

4 4

Tree with collections
by Henning Thielemann 13 Mar '06

13 Mar '06

I have a problem with defining an instance. > module CollTree where > import Data.List(intersperse) Say, I want to define a tree structure based on lists. I omit the data attached to the nodes here for simplicity. > data ListTree = ListNode [ListTree] > deriving Show This is simple enough for an automatically derived Show instance. Now I want to generalise that structure from lists to arbitrary types of collections. > data CollTree coll = CollNode (coll (CollTree coll)) This got too complicated for automatic derivation. So I have to define a Show instance for CollTree manually. But how to formulate the instance context? How to avoid undecidable instances? instance ??? => Show (CollTree coll) where show (CollNode xs) = "CollNode " ++ show xs Currently I see only one solution using a new class providing a special 'show' routine, which handles the structure of the collection, but must be assisted by a custom 'show' function for the collection members. > class CollShow coll where > collShow :: (a -> String) -> (coll a -> String) > instance CollShow coll => Show (CollTree coll) where > show (CollNode xs) = "CollNode " ++ collShow show xs Now I have to write 'show' related code for each collection type. This way I probably duplicate a lot of code that is already written for the Show instances of the collections. To be honest, I use a more special tree structure with even more special "collections" so this may be not really a problem. Here an instance for a custom list type: > newtype NewList a = NewList [a] > instance CollShow NewList where > collShow shw (NewList xs) = > "(NewList [" ++ > concat (intersperse ", " (map shw xs)) ++ "])" Is there a more straightforward way, preferrably Haskell98?

2 2

Re: UArray
by Bulat Ziganshin 12 Mar '06

12 Mar '06

Hello Frederik, Sunday, March 12, 2006, 9:39:13 PM, you wrote: FE> Why define separate instances when one could just define one FE> equivalent one: FE> instance (Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e) FE> (==) = eqUArray FE> ??? afaik, this is just not H98-compatible and require to use even more type extensions than currently used in this module FE> The same question applies to the Ord instances in that file. FE> I can give an answer *why not* do this: it makes UArray even more FE> unusable. UArrays which are polymorphic in their element types cannot FE> be compared. Here is another patch, please apply: _I_ don't apply the patches, but you can propose patches by sending them to libs maillist. tomorrow Simon Marlow will read it and decide whether it need to be applied most UArrays users don't need polymorphism, i run into problems with arrays only when i wrote general library which should support every array type -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0

Re: Can't uninstall GHC or prepare SOE installation on OS X
by Xavier Elizalde 11 Mar '06

11 Mar '06

Hi Wolfgang, For some reason, GHCi now keeps launching every time I launch Terminal.app, I can't even get a regular command line prompt now. I had to uninstall all the files for GHCi manually from an X11 Xterm to get a regular prompt. It still gets an error trying to launch GHCi, but then ends up with a regular prompt. I don't know why it started doing that, it wasn't doing that before.

2 2

Re: Can't uninstall GHC or prepare SOE installation on OS X
by Wolfgang Thaller 09 Mar '06

09 Mar '06

Xavier Elizalde wrote: > Hi. I sent this post to the haskell-cafe mailing list but haven't > gotten any replies. Ah well, I watch that list in digest mode only, easy to overlook things. > Basically, I can't get the Uninstall AppleScript for GHC 6.4.1to > run properly because it encounters an error. Oops. I *thought* I had tested that to death. Anyway, for manual removal: /usr/local/lib/ghc-6.4.1 (the big part; if disk space is all you're after, stop here) In /usr/local/bin/: ghc, ghc-6.4.1, ghc-pkg, ghc-pkg-6.4.1, ghci, ghci-6.4.1, ghcprof, hasktags, hp2ps, hsc2hs, runghc, runhaskell, stat2resid in /Libraries/Receipts: Some GHC-*.pkg file, I suspect now that it's called GHC-6.4.1.pkg /Library/Frameworks/GMP.framework (do not delete this unless you do not want to ever run any GHC-compiled program again until you re- install GHC). > I have the Haskell School of Expression book and want to try out > the examples in the book that make use of X11 for graphics, and I > don't know how to use GHC 6.4.1 for the SOE book examples. I > thought it would be easiest to just uninstall it then install the > SOE binaries for OS X. The SOE binaries use hugs, and should therefore be completely independent of GHC, no uninstalling required. > But if GHC 6.4.1 works fine for the SOE book examples and is better > than the SOE install, I'd like to use that, although I don't know > how to get it to work with X11. Do you have any idea on what I > should do? Start your programs from an xterm. If you want to use GHCi, set export DYLD_LIBRARY_PATH=/usr/X11R6/lib/ before starting ghci in the xterm. > > I have The Haskell School of Expression book and the > instructions for setting up and running the SOE software seem to have > a different configuration compared to GHC 6.4.1. Namely, it's meant > to use X11 and locations for files are different. What files? I don't have the book, so all I can tell you is that GHC includes a library module by the name of Graphics.SOE. > Or does the GHC already > have GraphicsLIb as part of it? If so, shouldn't it launch an X11 > Xterm terminal rather than the standard OS X Terminal? Shouldn't it launch...? Are you referring to the AppleScript for launching GHCi? If so, then no, for two reasons: a) X11 is an optional install on Mac OS X, so many people don't have it. b) The standard Terminal is a lot more convenient to use than an xterm, and most people don't need/want to use X11 for their Haskell programs. So good luck with SOE, if there are any more problems, ask me. Cheers, Wolfgang

3 2

Question regarding let clauses
by Martin Percossi 09 Mar '06

09 Mar '06

Hello, the following code doesn't compile <snip> module Matrix where import Control.Monad.ST import Data.Array.ST import Data.Array.Unboxed type Block s = STUArray s Int Double data MMatrix s = MMatrix Int Int (Block s) newMatrix_ :: Int -> Int -> ST s (MMatrix s) newMatrix_ m n = do b <- newArray_ (1, m*n) return (MMatrix m n b) runMatrix = do _A <- newMatrix_ 3 3 _B <- newMatrix_ 3 3 matMul _A _B return "Success" main = show $ runST runMatrix matMul :: MMatrix s -> MMatrix s -> ST s (MMatrix s) --matMul a b = do let foo = 2*5 --return a matMul a b = do { let foo = 2*5; return a } </snip> under ghc 6.4.1, yielding the error message: question.hs:25:41: parse error on input `<-' Failed, modules loaded: none. The offending is line the one containing "let foo = 2*5", which is a little test I've done of let-clauses. Now, suppose instead that for the last function, matMul, I replace the version that's commented out. No errors! Could someone enlighten me as to why? I'm a bit confused, as I thought the two forms are equivalent save for formatting... This is on the back of a email discussion that I was reading about let-clauses, in which someone declared that they where better than where clauses for monadic code. If anyone could comment on this, I'd appreciate it as well. Many thanks in advance, Martin

4 3

Haddock Problems
by Daniel Fischer 09 Mar '06

09 Mar '06

Hi all, I've just installed haddock-0.7, nice, but... > haddock -o h7doc -h -D h7doc/fusi.haddock --use-package=base Verwaltung.hs Teams.hs Stats.hs Match.hs Main.hs Liga.hs Item.hs Helpers.hs Datum.hs Warning: Helpers: could not find link destinations for: GHC.Base.Int GHC.Base.String GHC.Show.Show Data.Maybe.Maybe GHC.Base.Eq GHC.Base.Bool and so on. Same problem, if I use "-i/usr/.../base.haddock" instead of --use-package=base. This doesn't happen with haddock-0.6, all are properly linked to Prelude.html then. Now what can I do about that? BTW, in the ghc-docs (created with haddock-0.6), in most html-pages, Int &c are linked to GHC.Base, GHC.Num... which don't exist, how would I manage to have those linked to Prelude.html? And when I tried to re-make install-docs (for ghc-6.2.2, not to put the 6.4.1-docs into peril), I got /bin/sh: line 1: t: command not found make[2]: [html/haddock.css] Fehler 127 (ignoriert) /usr/bin/install -c -m 644 html/* /usr/local/share/ghc-6.2.2/html/libraries/base /usr/bin/install: Aufruf von stat für »html/*« nicht möglich: Datei oder Verzeichnis nicht gefunden make[2]: *** [install-docs] Fehler 1 make[1]: *** [install-docs] Fehler 1 make[1]: Leaving directory `/usr/local/lib/ghc-6.2.2/libraries' make: *** [install-docs] Fehler 1 linux:/usr/local/lib/ghc-6.2.2 # Apparently had a problem with SRC_HADDOCK_OPTS += -t "Haskell Hierarchical Libraries..." How can I fix all that? Thanks, Daniel -- "In My Egotistical Opinion, most people's C programs should be indented six feet downward and covered with dirt." -- Blair P. Houghton

2 5

Lists of Lists
by zell_ffhut 09 Mar '06

09 Mar '06

Just wondering if anyone can help me with a Haskell problem im having. How would I get the value of, lets say, the 9th object in ["4179355"," 567412"] ? (in this case, that should return 6) Any help/adivce would be great :) -- View this message in context: http://www.nabble.com/Lists-of-Lists-t1245394.html#a3297506 Sent from the Haskell - Haskell-Cafe forum at Nabble.com.

10 19

A syntax proposal: data replacements
by ihope 09 Mar '06

09 Mar '06

I'd like to propose more syntactic sugar more Haskell. (A spoonful of syntactic sugar makes the medicine go down...) Put simply, this would provide a smallish bit of pattern matching, and hopefully clarify some things. A simple example should pretty much define the whole thing: fromJust = {Just ->- id; Nothing ->- error "Nothing"} This function takes a single value. If the constructor used to construct it is Just, then the Just is replaced with id. Likewise, if it's given Nothing, it will return (error "Nothing"). Another example: consPair = {(,) ->- (:)} This takes a pair (x,y) and replaces the constructor (,) with (:), yielding (x:y). Now, a final clarification: foldr cons nil = {(:) ->- cons; [] ->- nil} This will *not* work: only the top bit of list will be replaced this way, as data replacements are not recursive. One last example: the function {Left ->- id; Right ->- error} takes an Either a String and either pulls out the a and returns that or uses the String as an error message.

3 2

Re: [Haskell-cafe] |> vs. $ (was: request for code review)
by Shannon -jj Behrens 09 Mar '06

09 Mar '06

By the way, thanks for everyone's comments so far! They're very helpful! > Also, most haskell programs use $ instead of |> > > > -- For convenience: > > currTokType :: ParseContext -> TokenType > > currTokType ctx = ctx |> currTok |> tokenType > > this could be written as: > tokenType $ currTok $ ctx Concerning: -- |> is like a UNIX pipe. infixl 9 |> x |> f = f x I find "ctx |> currTok |> tokenType" to be more readable than "tokenType $ currTok $ ctx" because you're not reading the code in reverse. That's my primary complaint with "." and "$". That's especially the case when I'm spreading the code over multiple lines: -- Translate a C type declaration into English. translate :: String -> String translate s = s |> createParseContext |> readToFirstIdentifier |> dealWithDeclarator |> consolidateOutput I prefer |> for readability, but I understand that it can be bad to spring new constructs on programmers in the middle of a program, and I'm totally in favor of following standard Haskell idioms. Does anyone else have strong opinions one way or the other? It seems like most of my program is centered around pipes of "|>", so it's an important issue. Thanks! -jj

7 14

Re: Library survey results
by John Hughes 09 Mar '06

09 Mar '06

>> 29% Parsec >> 19% wxHaskell >> 16% QuickCheck >> 16% haddock >> 12% Monadic Parser Combinators >> 11% Gtk2Hs >> 9% hs-plugins >> 8% HaXml >> 7% Data.* >> 7% Monad foundation classes >> 6% Arrows >> 6% HOpenGL >> >> The list includes all libraries named by more than 5% of respondents. >> Sure enough, wxHaskell and Gtk2Hs are more popular, but 6% naming >> HOpenGL as among the "most important" libraries is quite respectable. > > Well, I've never said that it is among the "most important" libraries, but > OTOH I really much doubt that the way the survey was done delivers > anything > near reliable results. It heavily biases early entries, and I dare to > speculate that the people taking part in the survey were probably not even > near to a representative group, but a bunch of highly motivated, > experienced > non-Joe-Programmer kind of people who are actively participating on the > mailing lists etc. It wasn't as bad as you think--over 580 replies, with less than a quarter of those from academics (there were actually more replies from people working in industry than from academics!). So I'd dispute that the survey tells us mostly about what the research community in particular wants. I'd guess the survey was pretty representative of KEEN Haskell users. It's a bit unclear who we mean by "Joe Haskell-programmer" anyway--I bet that, apart from students of course, the number of Haskell programmers who are using the language "just because their boss tells them to" can be counted on the fingers of one hand! I'd claim Joe Haskell programmer probably IS keen, highly motivated, experienced and active. In fact, the one group that is obviously underrepresented badly in my survey is just students--I got replies from just under 300, while another survey of teachers shows that at least 5-10,000 were taught Haskell last year. But maybe tools like hoogle SHOULD be aimed at the most active users? You're right that libraries mentioned earlier in the survey received more "votes" as a result, but since I have a record of all responses *in time order* I can see the difference, for each library, between pre- and post- "first mention" behaviour. HOpenGL was mentioned in the 7th response, wxHaskell in the first, and Gtk2Hs in the 17th, so they were in the "previously mentioned" category for almost the entire survey, and the effect you're talking about was not significant for a comparison between those three. Data.*, on the other hand, was first mentioned about half way through the survey, which indicates that around 12% of respondents selected it as among the "most important" libraries, when prompted to do so by seeing its name. However, the proportion who name Data.* spontaneously is below 2%--and that conclusion is statistically significant at the 99% level. 580 replies is enough to say statistically significant things (about the population the survey sampled, anyway). I feel quite inspired--when I have a spare moment, I'll analyse the results more carefully and see what one actually CAN say with a degree of certainty, taking into account when each library was first mentioned. > Furthermore, some of the percentages above are extremely > strange, e.g. how can people use huge GUI toolkits with 30% while staying > largely away from something as fundamental as Data.*? I don't find it so strange, really. Data.* implements lots of useful standard datatypes, but you can import some of them in other ways (import Maybe for example), and in many cases it's not too hard to roll your own. OK, maybe with a worse result, but you're not *forced* to use Data.* -- so if you're used to using something else, there's no 100% compelling reason to change. Rolling your own wxHaskell or Gtk2Hs is prohibitively hard. So I'm not at all surprised that GUI toolkits rated much higher--people's natural conservatism gives them a big advantage, and even Haskell users can be conservative sometimes! Perhaps the most surprising thing here is that only 30% of keen Haskellers think a GUI is important! John

2 1

MUA written in Haskell (was: Getting GHC to print "Done" when it's finished linking?)
by Nils Anders Danielsson 09 Mar '06

09 Mar '06

On Tue, 07 Mar 2006, "Brian Hulley" <brianh(a)metamilk.com> wrote: (Moved from ghc-users.) > Brian Hulley wrote: > (time for a proper email client to be written in Haskell! ;-) ) I had the same thought yesterday, after an Emacs-Lisp session in which I was trying to get Gnus to do exactly what I wanted it to... Out of curiosity, how much work would it take to write an easily configurable, decent MUA in Haskell? I don't know too much about MUAs, but I have a feeling that we already have quite a few libraries that are needed for the job: UIs (including HTML rendering...), plugins, various protocols, encryption... -- /NAD

6 6

haskell-prime traffic
by Ross Paterson 09 Mar '06

09 Mar '06

Just for fun, I've put up some statistics on haskell-prime traffic at http://www.soi.city.ac.uk/~ross/haskell-prime-stats/ I'm not claiming it shows anything, except what a narrow base we have.

2 1

Dropping trailing nulls from a list of list
by Jeff.Harper＠handheld.com 09 Mar '06

09 Mar '06

Today, I reviewed a function I wrote a few months ago. The function, dropTrailNulls, takes a list of lists and drops trailing null lists. For instance: *Main> dropTrailNulls [[1],[2,3],[],[]] [[1],[2,3]] My original implementation was terrible. It was recursive, overly bulky, and difficult to understand. It embarrasses me. I won't post it here. Today, it occurred to me this would do the trick: dropTrailNulls list = reverse (dropWhile null (reverse list)) The problem is 20 years of experience writing efficient imperative programs says to me, "You don't drop things off the end of a structure by reversing the structure, dropping stuff from the beginning, then reversing again." I suspect this imperative bias prevented me from coming up with the simple solution when I first wrote my function. On the other hand, it is conceivable to me that my new implementation may actually be relatively efficient since Haskell uses lazy evaluation, and Haskell lists are constructed from the tail to the beginning. I'm sure there are many problems that are encountered in Haskell where it is necessary to operate on the end of a list. So, I'm wondering if the idiom, reverse, operate, then reverse is something I should add to my toolbox. Or, is there a more efficient idiom for addressing these problems?

7 6

RE: [Haskell-cafe] library sort
by Simon Peyton-Jones 08 Mar '06

08 Mar '06

Strangely, Hoogle isn't easy to find at haskell.org. I'm not sure where the best place to add a link would be: perhaps near the top of the libraries-and-tools page? It's all wikified now, so would someone like to add it somewhere appropriate? Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | Radu Grigore | Sent: 17 February 2006 14:11 | To: Haskell Cafe | Subject: Re: [Haskell-cafe] library sort | | On 2/16/06, Jared Updike <jupdike(a)gmail.com> wrote: | > If you need an easier way to search the Haskell APIs, use Hoogle: | | Hoogle is very nice. Thanks to everyone who answered my question about | finding a sort library function. | | -- | regards, | radu | http://rgrig.blogspot.com/

4 8