September 2005 - Haskell-Cafe

RE: [Haskell-cafe] How to debug GHC
by Simon Marlow 19 Sep '05

19 Sep '05

On 10 September 2005 21:15, Frederik Eaton wrote: > On Fri, Sep 02, 2005 at 04:40:05PM +0400, Bulat Ziganshin wrote: >> Hello Nils, >> >> Friday, September 02, 2005, 10:47:05 AM, you wrote: >> >>> Compile your program with -prof -auto-all (make sure you have >>> the >> >>> I tried this out under GHC 6.4/Linux and got a segmentation fault >>> instead of a stack trace. Under GHC 6.2.2 it seemed to work, though. >> >> this error is already fixed in current pre-6.4.1 version > > I'm using a 2005/9/3 version of 6.4.1 and running into situations > where the "stack trace" has function A calling function B, where when > I look at the code, A never calls B. Is this normal? Is it some > side-effect of laziness? It sure makes the traces a lot less useful. It could be a bug - can you reduce the example and report it? GHC's profiler tries to overlay a lexical call graph on to the dynamic execution of the program. It does this more or less in the way you described before: every function gets an extra argument describing the call context. However, there are some tricky areas: notably CAFs. We don't as yet have a principled description of the mechanism, and I know of various cases where odd results are obtained with the current system. Also, the optimiser has to be careful not to change the shape of the call graph, and I suspect there are cases where it goes wrong. Cheers, Simon

3 4

Re: [Haskell-cafe] Newbie syntax question
by Marc Ziegert 19 Sep '05

19 Sep '05

> > map (foo 5) my_list_of_lists_of_doubles > 1. map (flip foo 5) my_list_of_lists_of_doubles > 2. map (`foo` 5) my_list_of_lists_of_doubles > 3. map (\x->foo x 5) my_list_of_lists_of_doubles > 4. [foo x 5 | x <- my_list_of_lists_of_doubles] well, i've followed this discussion a while, but i did not see that solution i used for years. (i like solution 2, never thought of it before.) my solution is a variant of 1, that makes the reading a little bit easier -- at least to me. 5. map (foo `flip` 5) my_list_of_lists_of_doubles the `flip` shows the position behind foo, where to put the parameter. its a pitty that it only works if there is only one parameter behind `flip`. so, with abcd :: a->b->c->d->x abcd a b `flip` d :: c->x works, but abcd a `flip` c d :: b->x does not. experimenting with Data.Arrow, it could look like: (abcd a >>> ($ c) >>> ($ d)) :: b->x or with a flip-arrow combination: (abcd a `flip` c) >>> ($ d) :: b->x so, instead of hacking with arrows on it, i prefer solutions 3 and 4 whenever 5 does not work. - marc

2 1

R: [Haskell-cafe] How to get all the paths of a tree
by Santoemma Enrico 19 Sep '05

19 Sep '05

Yeah! I've been struggling on concatMap for a noon and now here is the solution I've been unable to find. Thank you very much Enrico > -----Messaggio originale----- > Da: J. Garrett Morris [mailto:trevion@gmail.com] > Inviato: lunedì 19 settembre 2005 15.26 > A: Santoemma Enrico > Cc: Haskell-Cafe (E-mail) > Oggetto: Re: [Haskell-cafe] How to get all the paths of a tree > > > In this case, I think all you need is: > > > type Path = [String] > > > allPaths :: Path -> Tree -> [Path] > > allPaths p (Node s []) = [s:p] > > allPaths p (Node s subTrees) = concatMap (allPaths (s:p)) subTrees > > > paths = map reverse . allPaths [] > > In your test case, "root" will be at the beginning of each path > produced, but you can map tail over the list if you don't want it. > > /g >

1 0

Re: [Haskell] Re: [Haskell-cafe] Haskell versus Lisp
by Wolfgang Jeltsch 19 Sep '05

19 Sep '05

Am Freitag, 16. September 2005 18:40 schrieben Sie: > Wolfgang Jeltsch wrote: > > > > > Bearing this in mind, and hoping you can see where I'm coming from, > > > > > I think my question is: shouldn't you guys be using Lisp? > > > > > > > > Lisp is impure, weakly typed and has way too many parentheses. Why > > > > would we use lisp? It seems to be lacking almost all the advantages > > > > of Haskell, and have an ugly, inflexible syntax to boot. > > > > > > The ability to dynamically generate, manipulate and analyse code in a > > > structured manner provides a flexibility which is unmatched by any > > > other language I know of. > > > > > > A good example is Emacs; lisp is entirely the right language for that, > > > IMHO. > > > > Could you explain this a bit more, please? To the moment, I cannot > > imagine cases where you need LISP's way of code analysis and manipulation > > because Haskell's capabilities are not sufficient. > > > > In Haskell, code is data too because code in the sense of imperative > > actions is described by IO values. You cannot analyse them. > > And thus they are not data. They are some kind of opaque data. > > But you can use your do > > expressions etc. to construct action descriptions with a more general > > type like MonadIO m => m a. Then you can instantiate m with a monad > > whose values store part of the action's structure so that this > > information can be used later. Or you use a monad which doesn't keep > > structural information to use it for later processing but which does the > > processing upon construction. > > Yeah, but this is heading in the direction of Greenspun's Tenth Rule > of Programming: > > Any sufficiently complicated C or Fortran program contains an > ad hoc informally-specified bug-ridden slow implementation of > half of Common Lisp." > > You could easily end up doing the same thing in Haskell. I'm not sure. Haskell is much more powerful than C, for instance concerning the type system. The point of the concept I described above is that the general MonadIO-based description of actions is very similar to what you would normally write when using IO directly. I doubt that you can do something similar with C. > [...] > Or, to put it another way: if Haskell is so flexible, why do we need > Template Haskell? I can't imagine a "Template Lisp"; it would just be > Lisp. Haskell alone is not so flexible but Haskell with Template Haskell is. The difference is that the Haskell/Template Haskell combination separates compile-time evaluation/code generation clearly from runtime evaluation which is, in my opinion, a very good thing. Best wishes, Wolfgang

1 0

How to get all the paths of a tree
by Santoemma Enrico 19 Sep '05

19 Sep '05

Hello, I can't find the right recursive function to get a list of all the possible paths of a multi-way tree like this: data Tree= Node String [Tree] root = Node "root" [x, y] x = Node "x" [x1, x2] x1 = Node "x1" [] x2 = Node "x2" [x21, x22] x21 = Node "x21" [] x22 = Node "x22" [] y = Node "y" [] This is the Data.Tree.drawTree output: root | +- x | | | +- x1 | | | `- x2 | | | +- x21 | | | `- x22 | `- y And this is the list I'm trying to obtain: [ [x, x1] ,[x, x2, x21] ,[x, x2, x22] ,[y] ] Well, the actual problem I'm trying to solve is to print a set of lines like these: "leaf: x -> x1 \n" "leaf: x -> x2 -> x21 \n" ... and I thought I first need the list above. I'll be very grateful for any help Enrico

2 1

Haskell versus Lisp
by Mark Carter 19 Sep '05

19 Sep '05

This is not a troll, honest, so please bear with me ... I'm a C/C++/VBA programmer (although the former 2 are several years old for me), with a sprinkling of Python. Needless to say, I was looking to see if there were any better ways of doing things. I've given things like Ruby and Scheme a bit of peck, and failed to get particularly enthusiastic about them. Two very interesting choices, though, appear to be Lisp and Haskell. It struck me that Lisp was, perhaps, the Ultimate Programming Language, the One True Language to rule them all; except that I always kept abandoning it for one reason or another (fiddly installation, lack of libraries, compatability problems, cost, possible license issues, etc.). My current foray in Haskell seems encouraging. wxHaskell installed a breeze, and seems quite usable (even though I'm a raw n00b to the language, and admittedly haven't grokked the semantics, and all this <cid:part1.01000702.09000407@yahoo.co.uk> IO a -> IO () business). On the one hand, it seems kinda academic, but on the other, it looks like it wants to be practical, too. Bearing this in mind, and hoping you can see where I'm coming from, I think my question is: shouldn't you guys be using Lisp? ___________________________________________________________ To help you stay safe and secure online, we've developed the all new Yahoo! Security Centre. http://uk.security.yahoo.com

11 16

Re: [Haskell] Re: [Haskell-cafe] Haskell versus Lisp
by Wolfgang Jeltsch 19 Sep '05

19 Sep '05

Am Freitag, 16. September 2005 16:46 schrieben Sie: > . . . > > > In Haskell, code is data too because code in the sense of imperative > > actions is described by IO values. You cannot analyse them. But you can > > use your do expressions etc. to construct action descriptions with a more > > general type like MonadIO m => m a. Then you can instantiate m with a > > monad whose values store part of the action's structure so that this > > information can be used later. Or you use a monad which doesn't keep > > structural information to use it for later processing but which does the > > processing upon construction. > > But, isn't this like saying that Java or C++ supports first-class > function types because you can define a class with one method, the > function of interest, and then create, pass, and return instances of the > class? Yeah, you can do that, but it's awfully clumsy. But I could imagine that doing what I described in Haskell is not awfully clumsy. In fact, I don't like the idea of dealing with code at run-time, except when it is absolutely necessary. > Also, it seems to me that the heart of Haskell is functional, not > imperative. Can you create function definitions from data and evaluate > them at runtime? Of course! Just define a function which takes an expression as an argument and returns the corresponding function, i.e., some kind of function parser. > [...] > -- Bill Wood > bill.wood(a)acm.org Best wishes, Wolfgang

1 0

How to get all the paths of a tree
by Rene de Visser 19 Sep '05

19 Sep '05

module MyTree where import Data.Tree import Data.Generics -- define my tree type data MyTree = MyTree (Tree Integer) deriving Show data YourTree = YourTree (Tree String) deriving Show -- create the test data structure test1 = MyTree (Node 1 [Node 2 [], Node 3 []]) -- Transform my tree into a tree of strings using show. transform :: MyTree -> Tree String transform (MyTree node) = fmap (show) node trans :: (Show a, Functor f) => f a -> f String trans tree = fmap (show) tree -- The ordering of the operations here, gives the different folds... -- Need to have a look at the paper. -- The first parameter is the tree node, the second parameter is the list -- of return values, where each item is the result from the subtree, -- -- This function can effectively only be used bottom up, because the only input -- parameter to func comes from the call "(map (treeFold func))", i.e. the rest of -- the tree. We can only tell when are are at a leaf ( [b] is empty ). -- Add in the other tree fold here! treeFold :: (a -> [b] -> b) -> Tree a -> b treeFold func (Node header list) = func header (map (treeFold func) list) myToYours payload children = (Node (show payload) children) myToYours2 :: (Num a) => a -> Forest a -> Tree a myToYours2 payload children = (Node (payload + (childSum children)) children) where childSum :: (Num b) => Forest b -> b childSum children = foldr (+) 0 $ map rootLabel children test4 (MyTree tree) = treeFold myToYours2 tree test5 = test4 test1 test2 = transform test1 -- display my tree test3 = putStr $ drawTree test2 -- add 1 to each node add1 (Node x y) = Node (1 + x) y --test4 :: MyTree --test4 = everywhere add1 test1 tree_seed = [4,5,6] -- unfold receives the seed and returns the current node and the seeds for the children? -- unfoldTree :: (b -> (a, [b])) -> b -> Tree a tree_construct :: Tree Integer tree_construct = unfoldTree func (100,tree_seed,0) where func (value, seed, depth) | depth < 100 = (value, map expand seed) | otherwise = (value, []) where expand value = (value + depth, seed, depth + 1) test6 = putStr $ drawTree $ trans $ tree_construct newtype Seq1 = Seq1 [Integer] deriving Show append_path :: Integer -> Seq1 -> Seq1 append_path value (Seq1 path) = Seq1 $ value:path tree_path :: Integer -> [Seq1_List] -> Seq1_List tree_path child [] = [Seq1 [child]] -- Good, returns a seq1 list. tree_path child accum = map (\path :: Seq1 -> append_path child path) (concat accum) type Seq1_List = [Seq1] tree_paths :: Seq1_List tree_paths = treeFold tree_path tree_construct test7 = take 2 $ tree_paths

2 1

RE: [Haskell-cafe] How to debug GHC
by Simon Marlow 19 Sep '05

19 Sep '05

On 19 September 2005 03:57, Frederik Eaton wrote: >>> It could be a bug - can you reduce the example and report it? >>> >>> GHC's profiler tries to overlay a lexical call graph on to the >>> dynamic execution of the program. It does this more or less in the >>> way you described before: every function gets an extra argument >>> describing the call context. However, there are some tricky areas: >>> notably CAFs. We don't as yet have a principled description of the >>> mechanism, and I know of various cases where odd results are >>> obtained with the current system. Also, the optimiser has to be >>> careful not to change the shape of the call graph, and I suspect >>> there are cases where it goes wrong. >> >> I see. Well, I'm afraid I've lost the example, but I'll keep my eyes >> open in case it happens again. It's good to know what the correct >> behavior is supposed to be. > > While I was finishing a project for somebody I ran into this problem > again, as well as some other bugs, and made several copies of the code > so that the problems could be reproduced. > > In addition to the stack trace problems, I found: (1) a problem where > output freezes when it is being piped through 'tee' and the user > presses ^S and then ^Q and (2) an issue where a "trace" statement is > not being printed correctly by ghc (but is being printed correctly by > runghc). The "tee" problem is probably a result of the fact that GHC puts stdin/stdout into non-blocking mode. > However, I don't have time to reduce these to minimal test cases. Do > you want to look at them anyway? Sure, it's always good to have a record of bug reports even if we don't get to them right away. Cheers, Simon

1 0

Newbie syntax question
by André Vargas Abs da Cruz 19 Sep '05

19 Sep '05

Hi, I have been using Haskell for a few weeks now and I can say that I am totally impressed by how easy it is to program with it. I am now doing some small exercises to get used to the language syntax and I have a little (newbie) question: Suppose I declare a function foo like: foo :: [Double] -> Int -> Int foo a b Suppose now that I want to apply this function to a list that contains lists of doubles (something like [[Double]]) using map, but I want to keep the 'b' parameter fixed (with a value of 5 for instance). Is it possible to use map passing the function foo with the 2nd argument only ? In other words, if I wrote this function like: foo :: Int -> [Double] -> Int I could clearly call it with: map (foo 5) my_list_of_lists_of_doubles But how to do that (if possible) when I invert the parameters list ?! Thanks in advance, Andre Abs da Cruz

6 6