October 2008 - Beginners

Control.Monad.State: State CTOR unneeded to create a State?
by Larry Evans 01 Nov '08

01 Nov '08

Page: http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Mon… suggests, with the content: Constructors State runState :: (s -> (a, s)) that State has a labeled constructor: http://www.haskell.org/onlinereport/exps.html#sect3.15.2 yet the Examples section: http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Mon… shows, AFAICT, no call to the State CTOR: tick :: State Int Int tick = do n <- get put (n+1) return n I assume the n must be an Int (since it's in n+1), but what are the get and put. There is a get and put described here: http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Mon… however, I don't see how they are relevant since they are defined for an already existing MonadState, and AFAICT, tick hasn't been defined yet since it's on the lhs of the =. Please, what am I missing? TIA -regards Larry

5 5

eval command?
by Alex Shearn 29 Oct '08

29 Oct '08

Hey all - I've been trying to write an IRC bot following the guide on the wiki, and we (those of us on the channel) were trying to get it to evaluate commands. So far, we have this for "eval" stuff, but is there anyway to specify a "parse in haskell" sort of thing? [code] -- Dispatch a command eval :: String -> Net () eval "!endbot" = write "QUIT" ":Exiting" >> io (exitWith ExitSuccess) eval x | "!haskbot " `isPrefixOf` x = privmsg (drop 9 x) eval _ = return () -- ignore everything else [/code] is there anyway to do something like: eval "!eval" `isPrefixOf` x = eval blah ? if this isn't beginners' stuff, let me know, i'll repost to the main mailing list. Many thanks, Alex Shearn -- The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336.

6 9

gtk2hs treeViewSetReorderable
by news＠n-mayr.de 28 Oct '08

28 Oct '08

Hello, I am using a TreeView from the TreeList package and a ListStore as its data model. I set treeViewSetReorderable to True and now rows can be drag-n-dropped around. The data in the ListStore gets updated as expected. I want to get notified, when the order of the elements in the list changes (or just, when something is draged around - even if it is dropped on the position it was taken from). In the documentation it says "..., then the user can reorder the model by dragging and dropping rows. The developer can listen to these changes by connecting to the model's signals." After hours of seaching, I still don't find where I have to connect to. Have you any clue? Best wishes, Nikolas Link to documentation: http://www.haskell.org/gtk2hs/docs/current/Graphics-UI-Gtk-TreeList-TreeVie…

1 1

Function composition with more than 1 parameter
by Glurk 25 Oct '08

25 Oct '08

Hi, Is it possible to use function composition with a function that takes more than 1 parameter ? For example, I have a function that finds all the matches of an element within a list :- matches x xs = [ m | m <- xs, x == m ] So, matches 'e' "qwertyee" will return "eee" I now want a function that will work out how many times the element occurs in the list, easily written as :- howMany x xs = length $ matches x xs So, howMany 5 [1,2,3,4,5,5,5,5,5,6,6,6,7] will return 5 However, I'm thinking I want to try to use function composition to write something like :- howMany = length . matches ...which would be nice and clean :) I thought this would work, as the output of matches is a list, and the input required by length is a list. This doesn't work though, failng with the error :- Type error in application *** Expression : length . matches *** Term : length *** Type : [b] -> Int *** Does not match : ([a] -> [a]) -> Int Which I can't quite make out what it means. Ok, it's telling me lengt has a type [b] -> Int which makes sense, but it says it expected a different type, ([a] -> [a]) -> Int What I can't understand is why it wants something of that type ? Is it possibly something to do with the higher precedence of function application over function composition ? I've tried various things, like putting brackets around (length . matches) and changing my function to take in a tuple of (element, list), instead of 2 parameters (which I thought I had working at some stage ! but which now I can't get to work) Any advice appreciated ! thanks :)

7 12

pattern for tree traversel with a state
by Andreas-Christoph Bernstein 25 Oct '08

25 Oct '08

Hi, Is there a pattern for tree traversal with a state ? I am developing a small scenegraph represented by a tree. To draw a scenegraph one traverses over the graph starting with a global state. Inner Nodes can overwrite the inherited state for their subtree (e.g. Transformations are accumulated). The accumulated state is then either used immediately to draw the geometry in the leaf nodes, or a secondary data structure is build. This secondary data structure (a list or a tree) can then be sorted for optimal drawing performance. So i want to do the second and create a list of all leaves with the accumulated global state. To illustrate my problem i appended some code. The idea similar applies to a scenegraph. So my Question is: Is there allready a pattern for traversal with a state ? > module Main > where produces: Fork (0,"a") (Fork (1,"a") (Leaf (2,"a")) (Leaf (1,"a"))) (Leaf (0,"a")) > newTree :: BTree State > newTree = traverse modState globalState sampleTree produces: [(0,"a"),(1,"a"),(2,"a"),(1,"a"),(0,"a")] > stateList = flattenTree newTree > flattenTree (Leaf x) = [x] > flattenTree (Fork x l r) = [x] ++ flattenTree l ++ flattenTree r > type State = (Int, String) > > globalState :: State > globalState = (0, "a") State modifiers > data StateMod > = ModInt > | ModString > | ModNop > deriving Show > modState :: StateMod -> State -> State > modState ModInt (x,w) = (x+1,w) > modState ModNop s = s > modState ModString (x,w) = (x,'b':w) > data BTree a = Fork a (BTree a) (BTree a) > | Leaf a > deriving Show traverses the tree and executes a function which modifies the current state depending on the statemodifier > traverse :: (a -> b -> b) -> b -> BTree a -> BTree b > traverse f state (Leaf x) = Leaf (f x state) > traverse f state (Fork x l r) = > Fork (f x state) newLeft newRight > where newLeft = traverse f (f x state) l > newRight = traverse f (f x state) r an example tree > sampleTree :: BTree StateMod > sampleTree = Fork ModNop > (Fork ModInt (Leaf ModInt) (Leaf ModNop)) > (Leaf ModNop) creates a list from a tree > flattenTree (Leaf x) = [x] > flattenTree (Fork x l r) = [x] ++ flattenTree l ++ flattenTree r Thanks for any help and ideas Andreas

5 7

Type problems with IOArray
by Xuan Luo 24 Oct '08

24 Oct '08

I am having lots of trouble using polymorphic mutable IOArrays. Here is an example program: import Data.Array.MArray import Data.Array.IO foo x = do a <- newArray (0, 4) x readArray a 2 main = foo 42 >>= print So there is a function "foo" which makes an array of polymorphic type initialized with a value, then returns one of the elements of the array. So here "foo x" essentially does the same as "return x"; but it demonstrates problems I am having. So the above program fails with: testarray.hs:7:7: No instance for (MArray a t IO) arising from a use of `foo' at testarray.hs:7:7-12 Possible fix: add an instance declaration for (MArray a t IO) In the first argument of `(>>=)', namely `foo 42' In the expression: foo 42 >>= print In the definition of `main': main = foo 42 >>= print Okay; so the problem is that "newArray" is a function that creates MArrays in general; but there is no function to specifically create IOArrays in particular, and it doesn't know I want to use IOArrays. In fact, all the other functions that are used to operate on mutable arrays are generic MArray functions too, and there is basically nothing that is specific to IOArrays, so it is not as if the compiler can "figure it out from context". This is bad design. I wish it could just decide to default to IOArrays or something, since IOArrays of any type already are instances of MArray, so it would be natural. Okay so the general way to resolve this is to add signatures to tell it that it is an IOArray. But when I give the type for IOArray I also have to tell it what type its contents are, and I want it to work polymorphically over any type, so the array has to be of a polymorphic type: foo x = do a <- newArray (0, 4) x :: IO (IOArray Int a) readArray a 2 But of course it doesn't know what "a" is, so maybe I am forced to also add a signature for the function "foo" itself, which the compiler should really be able to figure out for me: import Data.Array.MArray import Data.Array.IO foo :: a -> IO a foo x = do a <- newArray (0, 4) x :: IO (IOArray Int a) readArray a 2 main = foo 42 >>= print Okay, now the real problems begin: testarray.hs:5:32: Couldn't match expected type `a1' against inferred type `a' `a1' is a rigid type variable bound by the polymorphic type `forall a1. IO (IOArray Int a1)' at testarray.hs:5:16 `a' is a rigid type variable bound by the type signature for `foo' at testarray.hs:4:7 In the second argument of `newArray', namely `x' In a 'do' expression: a <- newArray (0, 4) x :: IO (IOArray Int a) In the expression: do a <- newArray (0, 4) x :: IO (IOArray Int a) readArray a 2 What the heck is this? I looked through a lot of stuff online and eventually found that this works: {-# LANGUAGE ScopedTypeVariables #-} import Data.Array.MArray import Data.Array.IO foo :: forall a. a -> IO a foo x = do a <- newArray (0, 4) x :: IO (IOArray Int a) readArray a 2 main = foo 42 >>= print So I had to add some weird "forall" stuff to my function signature and enable some language extension flag(?). This seems way too complicated. I just want to be able to make and use a simple polymorphic array in the IO monad with regular Haskell, without changing compiler flags or anything like that. I have been doing well in other stuff involving the IO monad, but these mutable arrays really got me stuck. Thanks,

3 2

A Pascal-like Language Compiler
by Pranesh Srinivasan 23 Oct '08

23 Oct '08

Hi all, I have been learning haskell for the last month or so. I have just started becoming familiar with monads and looking at Parsec. As part of the Language Translators Course this semester, in the university I study, we are to implement a Pascal-like toy language to C translator[1]. The aim is to take a simple subset of Pascal and translate it to an intermediate 3 operand format, before translating it to simple C. The time I have for this project is about a month. I am contemplating doing this in Haskell, since I have read in several places that Haskell (and other functional languages) is very good for writing compilers. In fact, I have started writing code for lexing the basic tokens. I do have doubts about my ability to finish it. The curiosity to do something of a moderate size in Haskell, and the extremely friendly folks on #haskell, tipped me on this decision. I looked around for similar things on the internet, in vain. I have several doubts at this stage some of which include, * how the parser will determine the scope of the variables, i.e, how can a symbol table be implemented (in the state of the parser ?) * how easy or difficult will basic code optimisation (like unused variables, and loops with no side effects) and type checking be? * how would one go about implementing basic error recovery in the parser (make it skip the current line, or block) ? I would love it if I get a few pointers from people who have been there, done that. Or am I being too ambitious too early? :) [1] One of the suggested programming exercises at the end of the "Dragon" Compilers book, by Aho, et al. -- Pranesh S

3 5

how to define a user datatype consisting of instances of String?
by Benjamin L.Russell 23 Oct '08

23 Oct '08

How is it possible to define a user datatype consisting of instances of String? Suppose I am preparing a party for wine connoisseurs, and want to define the following data types: data Wine = Red | White data Red = "Merlot" data White = "Sauvignon Blanc" data Entree = "pork" | "chicken" | "tuna" data SideDish = "garlic bread" | "mozzarella sticks" | "caviar" Then, I want to write a Haskell function that takes two lists; e.g., ["pork", "chicken", "tuna"] and ["garlic bread", "mozzarella sticks", "caviar"] and that constructs a three-tuple of the following type: (Entree, SideDish, Wine) such that which Wine is chosen depends on the particular combination of Entree and SideDish, with respect to the following rules: ("pork", "garlic bread") -> ("pork", "garlic bread", "Merlot") ("pork", "mozzarella sticks") -> ("pork", "mozzarella sticks", "Merlot") ("pork", "caviar") -> ("pork", "Beluga", "Sauvignon Blanc") ("chicken", "garlic bread") -> ("chicken", "garlic bread", "Merlot") ("chicken", "mozzarella sticks") -> ("chicken", "mozzarella sticks", "Sauvignon Blanc") ("chicken", "caviar") -> ("chicken", "caviar", "Merlot") ("tuna", "garlic bread") -> ("tuna", "garlic bread", "Sauvignon Blanc") ("tuna", "mozzarella sticks") -> ("tuna", "mozzarella sticks", "Merlot") ("tuna", "caviar") -> ("tuna", "caviar", "Merlot") So far, I have written the following Haskell code: module Wine where data Wine = Red | White data Red = "Merlot" data White = "Sauvignon Blanc" data Entree = "pork" | "chicken" | "tuna" data SideDish = "garlic bread" | "mozzarella sticks" | "caviar" wine :: [Entree] -> [SideDish] -> [(Entree, SideDish, Wine)] wine entree sidedish | entree == "pork" = | sidedish == "garlic bread" = ("pork", "garlic bread", "Merlot") | sidedish == "mozzarella sticks" = ("pork", "mozzarella sticks", "Merlot") | sidedish == "caviar" = ("pork", "caviar", "Sauvignon Blanc") | entree == "chicken" = | sidedish == "garlic bread" = ("chicken", "garlic bread", "Merlot") | sidedish == "mozzarella sticks" = ("chicken", "mozzarella sticks", "Sauvignon Blanc") | sidedish == "caviar"= ("chicken", "caviar", "Merlot") | entree == "tuna" = | sidedish == "garlic bread" = ("tuna", "garlic bread", "Sauvignon Blanc") | sidedish == "mozzarella sticks" = ("tuna", "mozzarella sticks", "Merlot") | sidedish == "caviar"= ("tuna", "caviar", "Merlot") However, when I load this code into GHCi, I get the following error message: [1 of 1] Compiling Wine ( wine.hs, interpreted ) wine.hs:18:11: parse error on input `"' Failed, modules loaded: none. Prelude> I discovered the following seemingly relevant HaskellWiki page, but am not sure about how to apply the advice in it to this problem, because the advice does not seem sufficiently specific or detailed: List instance - HaskellWiki http://www.haskell.org/haskellwiki/List_instance What would be a good way to overcome this error? -- Benjamin L. Russell

2 11

what type is 'Val 9' when 'Val Int' a ctor for 'Expr e'?
by Larry Evans 23 Oct '08

23 Oct '08

The attachment compiles OK; yet, I don't understand how the compiler knows what type val_9 has. The compile/run is: <---cut here--- Compilation started at Tue Oct 21 13:17:41 make runghc uniplate.try.hs val_9=Val 9 add_8_9=Add (Val 8) (Val 9) children_add_8_9=[Val 8,Val 9] Compilation finished at Tue Oct 21 13:17:42 >---cut here--- I would have expected that I would need to code this: let val_9 = (Val 9)::(Expr Eo) but apparently not. Could somebody explain? TIA. -Larry

4 5

Re: [Haskell-beginners] do not understand Semantics of Case Expressions in report
by John Dorsey 21 Oct '08

21 Oct '08

Michael, (Sorry for duplicates; I sent this from the wrong address initially.) > (m) case v of { K { f1 = p1 , f2 = p2 , ... } -> e ; _ -> e' } > = case e' of { > y -> > case v of { > K { f1 = p1 } -> > case v of { K { f2 = p2 , ... } -> e ; _ -> y }; > _ -> y }} > where f1, f2, ... are fields of constructor K; y is a new variable [...] > I'm totally confused with this identity. Especialy with " = case e'". > Can anyone explain a little what does this rule stand, please? > It is better to see some example. You got me curious, so I looked over this. The table you reference lists identities that should hold for all implementations of case expressions. (m) is about how case matches against constructors with named fields, and it shows that a case expression that matches against multiple fields (f1, f2, etc.) can be broken into nested case expressions which each match a single field (eg. f1). It looks like "case e' of { y -> ..." was introduced solely to give e' a name that can be used in two places, since the nested form may fail to match at each level. It seems to me that without this, you could get code explosion from duplicating the expression e' below; with this you get sharing. Here it is with a interim step added: -- Match v against a constructor with multiple fields case v of { K { f1 = p1 , f2 = p2 , ... } -> e ; _ -> e' } -- Same, but introduce y to represent e' without loss of sharing case e' of { y -> case v of { K { f1 = p1 , f2 = p2 , ... } -> e ; _ -> y }} -- Same, but match first field of K independent of the rest case e' of { y -> case v of { K { f1 = p1 } -> case v of { K { f2 = p2 , ... } -> e ; _ -> y }; _ -> y }} I hope this helps. Regards, John

2 1