- Beginners - Haskell.org

haskell platform
by Irvin 05 Apr '10

05 Apr '10

Hi I'm having trouble installing Haskell platform using Ubuntu (Karmic Koala). When I run ./configure I get the message configure: error: The Haskell Platform version 2010.1.0.0 requires ghc-6.12.1 It is recommended that you upgrade to ghc-6.12.1 however if you really want to use this release with an unsupported version of GHC then use ./configure --enable-unsupported-ghc-version In synaptic the latest version of ghc is 6.10.xx; I've tried doing ./configure --enable-unsupported-ghc-version, but make fails to set up Cabal. Any suggestions? Should I just try to set up everything piece-meal? Do I need to remove the currently installed version of ghc using synaptic before I try to use the 6.12.1 installer or build it from source. Thanks. Best, Irvin

4 3

recursively retrieving widgets handlers in wxhaskell
by legajid 05 Apr '10

05 Apr '10

Hi, trying wxHaskell GUI interface, i would like to get a list of all widgets in a frame. My frame is composed of 4 widgets and a panel containing 2 widgets. wlf <- get frame children gives a list of 5 widgets (4 + 1 panel) wlp <- get panel children gives a list of 2 widgets Making wlf ++ wlp gives the whole list of widgets in the frame. But, for a more general use, i want to explore recursively the hierarchy from frame, without having to explicitly know wether the frame contains other containers ... Since the <- syntax to get a list of children, i can't figure out how to write the recursive function to get all children of a frame. I can't write (x <- get widget children) ++ f (rest of list of widgets) , as for usual functions using lists. Thanks for helping. Didier.

3 3

(->) instance for ArrowApply and laziness
by aditya siram 03 Apr '10

03 Apr '10

Hi all, Could someone help me understand how the (->) instance for ArrowApply works? It looks like this: > instance ArrowLoop (->) where > loop f b = let (c,d) = f (b,d) in c This models recursion for arrows and I need help understanding how it does that. I have a strong feeling it has to do with the magic value 'd'. I've read the Patterson tutorial but I still don't grok it. Thanks! -deech

3 4

Question about IO, particularly hGetContents
by Ken Overton 02 Apr '10

02 Apr '10

Hello all, I was playing with some Haskell code that read in text files and processed them and often found myself writing empty result-files. I've pared the problem down to the following small example. -- example program import IO main = do rhdl <- openFile "test.in" ReadMode content <- hGetContents rhdl putStrLn content -- if I cmt out this line, content will be empty hClose rhdl putStrLn "Content: " putStrLn content -- if the first 'putStrLn' call was commented, this will print a blank line -- end example For some reason, if I comment out the 'putStrLn content' between hGetContents and hClose, the data from the hGetContents call is not stored. Can somebody verify this behavior and (if so) explain why it's happening? Thanks, -- kov

3 4

Addable function combinators
by Edgar Klerks 31 Mar '10

31 Mar '10

(I am sorry for the spam, but my browser seems to chopoff the reply-to field. I have changed mailclient so I can manually add it. Hopefully the issue is resolved) Hi Brent, I already solved it myself. I wanted to find an systematic way to produce composition operators which composes functions with different arity together. I stated it a bit vague. For example <*||> is (c -> d) -> (a -> b -> c) -> a -> b -> d I can add this types with the composition operator to create a new operator which combines functions with different arity. In this case a function with arity 1 with a function with arity 4: <*||>.<*||> = <*||||> But I couldn't find an systematic way to level the arity of the function on the left side. I wanted to find an operator what did this, like so: <*|> `op` <*|> = <**|> But I found another way already, which can be found in the followup. So I guess this question is closed. But thanks anyway for your response. I really appreciate the way the people on this list react to new haskellers. Your are really helpful, which sometimes on other lists is quitte the oposite. Greets, Edgar

1 0

Addable function combinators
by Edgar Klerks 31 Mar '10

31 Mar '10

Hi Brent, I already solved it myself. I wanted to find an systematic way to produce composition operators which composes functions with different arity together. I stated it a bit vague. For example <*||> is (c -> d) -> (a -> b -> c) -> a -> b -> d I can add this types with the composition operator to create a new operator which combines functions with different arity. In this case a function with arity 1 with a function with arity 4: <*||>.<*||> = <*||||> But I couldn't find an systematic way to level the arity of the function on the left side. I wanted to find an operator what did this, like so: <*|> `op` <*|> = <**|> But I found another way already, which can be found in the followup. So I guess this question is closed. But thanks anyway for your response. I really appreciate the way the people on this list react to new haskellers. Your are really helpful, which sometimes on other lists is quitte the oposite. Greets, Edgar

1 0

hiding documentation for non-exposed modules
by Ashish Agarwal 31 Mar '10

31 Mar '10

I'm using cabal to build and install a new library I'm writing. In the .cabal file I've exposed only a single module. However, the haddock generated documentation includes even the non-exposed modules, which is not what I want since end-users should not see these. Is there a way to tell cabal to build documentation only for exposed modules?

2 2

What should I use (the equivalent of Windows schtasks) to schedule a task to run?
by Hong Yang 30 Mar '10

30 Mar '10

I searched "schedul" on hayoo!, but had no clue. It seems that I can use scheduleEventAt from Control.Monad.Event.Classes. But what is type "e"? It seems like an event. How do I define an event? I have not learned Monad yet. Can some one give me a simple example? Suppose I want to run an external program "pg" which in Haskell's language has the type of String -> IO (). Thanks, Hong

2 2

Addable function combinators
by edgar klerks 30 Mar '10

30 Mar '10

He All, I was toying a bit around and found a function, which combines an function of arity 1 with 2. Then I produced a whole sequence of these function, the number of * stands for the arity of the left function and the number of | stands for arity the right function. so <*|||> :: (b -> c -> d) -> (a -> c) -> a -> b -> d: (<*****|>) = flip (<*|||||>) (<****|>) = flip (<*||||>) (<***|>) = flip (<*|||>) (<**|>) = flip (<*||>) (<*|>) = (.) (<*||>) = (<*|>).(<*|>) (<*|||>) =(<*||>).(<*|>) (<*||||>) = (<*||>).(<*||>) (<*|||||>) = (<*||||>).(<*|>) con = (flip.) .(.) (<**||>) = (<*||>).flip (<**|||>) = (<*|>).(<**||>) (<**||||>) = (<*|>).(<**|||>) (<***||>) = (<*||>).(con flip) (<***|||>) = (<*|>).(<***||>) (<****||>) = (<*||>).(con.con $ flip) I found it interesting, but now I am stuck. is it possible to make the stars addable instead of the | or both? Greets, Edgar Edgar

2 2

Rewriting traversal over trees
by Darryn Reid 30 Mar '10

30 Mar '10

Hi, I hope that this is an appropriate place to post this question; I'm an experienced computer scientist and mathematician but am new to Haskell (I love it, I might add, but have much to learn). I've coded a (fairly) general rewriting traversal - I suspect the approach might be generalisable to all tree-like types, but this doesn't concern me much right now. My purpose is for building theorem provers for a number of logics, separating the overall control mechanism from the specific rules for each logic. The beauty of Haskell here is in being able to abstract the traversal away from the specific reduction rules and languages of the different logics. I have paired down the code here to numbers rather than modal formulas for the sake of clarity and simplicity. My question is two-fold: 1. Does my representation of the traversal seem good or would it be better expressed differently? If so, I'd appreciate the thoughts of more experienced Haskell users. 2. I cannot really see how to easily extend this to a queue-based breadth-first traversal. I'm sure others must have a good idea of how to do what I'm doing here except in breadth-first order; I'd appreciate it very much if someone could show me how to make a second breadth-first version. Thanks in advance for any help! Darryn. start of code. ------------------------------------------------------------------------- import Control.Monad import Control.Monad.Identity -- Tableau is a tree containing formulas of type a, in -- Fork (disjunctive) nodes and Single (conjunctive) nodes. -- Paths from root to Nil each represent an interpretation. data Tableau a = Nil -- End of a path | Single a (Tableau a) -- Conjunction | Fork (Tableau a) (Tableau a) -- Disjunction deriving (Eq, Show) -- 'Cut' directs the traversal to move back up the tree rather than into -- the current subtree, while 'Next' directs the traversal to proceed -- into the subtree. data Action = Cut | Next deriving (Eq, Show) -- The type of the rewrite function to perform at each node in -- the traversal of the tree. The Rewriter returns the new -- subtree to replace the existing subtree rooted at the -- traversal node, and a direction controlling the traversal -- to the next node. type Rewriter m a = Tableau a -> m (Tableau a, Action) -- The traversal function, depth-first order. rewrite :: (Monad m) => Rewriter m a -> Tableau a -> m (Tableau a) rewrite rf t = do (t', d) <- rf t rewrite' rf d t' -- Worker function for traversal, really its main body. rewrite' :: (Monad m) => Rewriter m a -> Action -> Tableau a -> m (Tableau a) rewrite' rf Cut t = return t rewrite' rf Next Nil = return Nil rewrite' rf Next (Single x t1) = do t1' <- rewrite rf t1 return (Single x t1') rewrite' rf Next (Fork t1 t2) = do t1' <- rewrite rf t1 t2' <- rewrite rf t2 return (Fork t1' t2') -- Some examples to test the code with: -- ghci> let t0 = (Single 2 (Single 3 Nil)) -- ghci> let t1 = (Single 1 (Fork t0 (Fork (Single 4 Nil) (Single 5 Nil)))) -- ghci> let t2 = (Fork (Single 10 Nil) (Single 11 Nil)) -- ghci> let t3 = (Fork (Single 3 Nil) (Single 3 Nil)) -- Running "test4 t1 t2" produces the expected result; running -- "test4 t1 t3" does not terminate, because this endlessly -- generates new patterns that match the substitution condition: test4 :: (Num t) => Tableau t -> Tableau t -> Tableau t test4 tab tab' = runIdentity (rewrite rf tab) where rf (Single 3 Nil) = return (tab', Next) rf t = return (t, Next) -- Running "test5 t1 t3", however, does terminate because the "Cut" -- prevents the traversal from entering the newly spliced subtrees -- that match the pattern. test5 :: (Num t) => Tableau t -> Tableau t -> Tableau t test5 tab tab' = runIdentity (rewrite rf tab) where rf (Single 3 Nil) = return (tab', Cut) rf t = return (t, Next) ------------------------------------------------------------------------- end of code.

2 1