- Haskell-Cafe - Haskell.org

Haskell-style proof tools?
by Robin Green 21 Sep '05

21 Sep '05

Does anyone know of a prover / proof assistant / proof verifier which uses a vaguely Haskell-like syntax? That is to say, it allows you to express theorems in Haskell-style syntax, print proof steps in Haskell-style syntax, etc. -- Robin

3 2

Basic type classing question.
by Karl Grapone 21 Sep '05

21 Sep '05

Hi, I've just started learning Haskell, and I must admit I'm finding it a bit hard to get my head around the typing system... If I wanted to represent Employees and Departments in a Haskell program I could use data declarations like so: data Employee = Emp ... data Department = Dept ... This seems limited in (at least) two ways: I can't dynamically add fields to an employee or department, and once I pull a field out of an instance I lose type information. What I want to be able to do is add and remove fields while the system is running, I suppose via hs-plugins, and I should be prevented from, for example, accidentally taking an employees first name and using it as a departments address. My first attempt was the following, which isn't even valid and doesn't appear to buy me much anyway. class DataContainer c class DataContainer c => DataField f c a where extract :: f -> a apply :: (a -> a -> a) -> f -> f -> f data DataContainer c => Field c a = Fld c a instance DataField Field c a where extract (Fld _ a) = a apply f (Fld c a1) (Fld _ a2) = Fld c (f a1 a2) data Employee = Emp instance DataContainer Employee data Department = Dept instance DataContainer Department type EmployeeName = Field Employee String type EmployeeAddress = Field Employee String type EmployeeIdentifier = Field Employee Integer type DepartmentAddress = Field Department String type DepartmentIdentifier = Field Department Integer ... The 'DataField instance Field' declaration gives kind errors regarding how many type arguments Field is applied to. I don't claim to understand kinds at this point. Even if it did work, apply doesn't appear to force the arguments to be of the same type, and the declared type synonyms aren't enough to prevent me getting employee names and addresses confused. Is there a correct way to express what I'm trying to do? Or is it a bad idea to start with? Thanks Karl

4 3

Re: [Haskell-cafe] Trapped by the Monads
by Mark Carter 21 Sep '05

21 Sep '05

Greg Buchholz wrote: > Have you read... > > http://haskell.org/hawiki/ThatAnnoyingIoType > > > Thanks. I'll take a look at it. I also need to take a look at the basic Haskell syntax. An interesting-looking web page which discusses monads is: http://www.nomaware.com/monads/html/analogy.html What struck me was this bit of code: assemblyLine w = (return w) >>= makeChopsticks >>= polishChopsticks >>= wrapChopsticks Interestingly, this looks like Forth (!), where you put a value on the stack, and successive operations fiddle with the stack as a series of transformations. Not that I know Forth, you understand. Hmm, so Haskell can be a concatenative language if you want it to be. ___________________________________________________________ Yahoo! Messenger - NEW crystal clear PC to PC calling worldwide with voicemail http://uk.messenger.yahoo.com

7 13

haskell emacs mode
by Chris Wright 21 Sep '05

21 Sep '05

Hi, When I download and install "Latest" haskell-mode from http://www.iro.umontreal.ca/~monnier/elisp/ it seems as if (though the dir is named haskell-mode-2.0) that version 1.43 is loaded doing $ grep version haskell-mode.el gives: ;; the Free Software Foundation; either version 2, or (at your option) ;; any later version. ;; In some versions of (X)Emacs it may only support Latin-1, not Unicode. ;; thorn(a)irisa.fr quoting the version of the mode you are using, the ;; version of Emacs you are using, and a small example of the problem (defconst haskell-version "1.43" "`haskell-mode' version number.") (defun haskell-version () "Echo the current version of `haskell-mode' in the minibuffer." (message "Using haskell-mode version %s" haskell-version)) Use `haskell-version' to find out what version this is. So, I'd be grateful for any help to get version 2.0 d/l and installed. 1.43 seems to have a bug in its handling of strings. If a string has the world "of" in it, the next line doesn't indent properly (I think the mode is expecting a case statement syntax). thanks Chris _________________________________________________________________ SEEK: Over 80,000 jobs across all industries at Australia's #1 job site. http://ninemsn.seek.com.au?hotmail

2 1

Constructor constraints
by Rich Neswold 20 Sep '05

20 Sep '05

Hello, I've looked through the two tutorials and the Report, but couldn't find help on this topic. My question is whether you can place constraints on new data types. For instance, I want to make a new type that is a 4 element tuple where each element is greater than or equal to the previous entry. Is this possible? i.e. data Category = Membership a a a a I'd like to be able to prevent invalid Category data from being created. Any information would be appreciated. -- Rich AIM : rnezzy ICQ : 174908475

3 3

case of (was: [Haskell] Mixing monadic and non-monadic functions)
by Andrew Pimlott 20 Sep '05

20 Sep '05

On Sat, Sep 17, 2005 at 06:56:36PM +0100, Ben Rudiak-Gould wrote: > * The new syntax is really nice as a replacement for the annoyingly > common "x <- foo ; case x of..." idiom that I've always disliked. I might wish for "case of" to mean "\x -> case x of": foo >>= case of ... Useful outside of monads, eg to write anonymous functions for map. Andrew

6 6

Trapped by the Monads
by Mark Carter 20 Sep '05

20 Sep '05

I'm puzzling out how to get a Bool from am IO Bool. I know I'm not supposed to, but I don't see any way around my predicament. The basic setup is: I have an edit box, and a panel. If you click the LMB on the panel when the edit box is checked, this means you want to move a graphical object around the panel. If it is unchecked, then clicking the LMB means you want to add a graphical object. The relevant bits I've managed to put together so far are: mainFrame = do -- main application frame streams <- varCreate [] ... cbEdit <- checkBox p1 [text := "Edit Mode", on command ::= onCbEdit textlog] -- p1 is the panel, ignore textlog let isEditing = get cbEdit checked -- returns type IO Bool windowOnMouse p False {- no motion events -} (onMouse p streams isEditing) ... where onMouse w streams isEditChecked mouse = case mouse of MouseLeftDown pt mods -> if isEditChecked then findStream w streams pt else addStream w streams pt other -> skipCurrentEvent -- unprocessed event: send up the window chain where -- define findStream and addStream The problem is that isEditChecked is of type IO Bool, not Bool. I presume that I should actually be taking a different (non-imperative) approach, and I'm wondering if anyone could suggest what that approach should be? Many apologies for being a clueless n00b. ___________________________________________________________ Yahoo! Messenger - NEW crystal clear PC to PC calling worldwide with voicemail http://uk.messenger.yahoo.com

4 3

How to locate a <<loop>>?
by Jørgen Hermanrud Fjeld 20 Sep '05

20 Sep '05

Hi. I have a generated Haskell program that emits a "Fail: <<loop>>" at runtime. Are there some tools or standard manner for identifying the lines that participate in the loop? The use of "-debug" and "-prof -auto-all" only provides a call stack, and the loop is, is I understand it, due to a circular definition, so the call stack is of little help. -- Sincerely | Homepage: Jørgen | http://www.hex.no/jhf | Public GPG key: | http://www.hex.no/jhf/key.txt

2 1

Re: [Haskell-cafe] Use Haskell to extract GXL representation
by Santoemma Enrico 20 Sep '05

20 Sep '05

Sara, I've used extensively HaXml and the tool DtdToHaskell to do xml processing. HaXml marshalls/demarshalls xml data and DtdToHaskell creates the "data" statements to handle xml in haskell fashion. I learnt how to write a palatable DTD for the delicate DtdToHaskell, but in your case I guess you're not the dtd's author. It's very simple, once everything is setup: import MYDTD myXml :: String -> IO MYDTD myXml fileName = return $ fReadXml fileName where MYDTD.hs is the output of: $ DtdToHaskell MYDTD.dtd MYDTD.hs Feel free to ask if you'll have troubles with DtdToHaskell. I remember I fought a lot :) Salus, Enrico > -----Messaggio originale----- > Da: haskell-cafe-bounces(a)haskell.org > [mailto:haskell-cafe-bounces@haskell.org]Per conto di Sara Kenedy > Inviato: sabato 17 settembre 2005 3.11 > A: Haskell-Cafe(a)haskell.org > Oggetto: [Haskell-cafe] Use Haskell to extract GXL representation > > > Dear you all, > > > Currently, I am working with Haskell and GXL file (Graph > eXchange Language). GXL > is a sublanguage of XML and its syntax is based on XML DTD. > > 1) In my work, I use GXL representation to represent a quantification > (e.g. forall(x:Z|x = 3 and x^2 - 3x + 2 =0)) > > 2) My objective is to write a Haskell module to extract the content of > the GXL file such that a prover theorem (e.g, ICS) and a computer > algebra system (e.g, Matlab) can read the content of GXL file. > > If any of you have experiences or any ideas about the problem, please > share with me. > > I really appreciate for that.Thanks a lot. > > Sara. > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

a new Monad
by Malcolm Wallace 20 Sep '05

20 Sep '05

Microsoft has announced the following: Developers can also expect a new scripting language for management applications, called Monad. Monad is an object-oriented language based on .NET, and provides command-line based management while enabling management services to be passed between different commands. http://www.theregister.co.uk/2005/09/16/microsoft_longhorn_server/ What a strange choice of name for a language...! :-) Malcolm

5 4

RE: [Haskell-cafe] Template Haskell and Types
by Simon Peyton-Jones 20 Sep '05

20 Sep '05

| > putStrLn $(mysplice ''MyData) | > | | Thanks for responses. Is there any up-to-date documentation avaliable? Template Haskell is, alas, poorly documented. I would really welcome someone to volunteer to help write better documentation. Meanwhile, as the user manual says, the stuff about quoting names is described in a design note http://research.microsoft.com/~simonpj/tmp/notes2.ps Simon

2 2

TH Q Monad and fail
by Gracjan Polak 20 Sep '05

20 Sep '05

Hi all, The Q Monad in template haskell has fail method. As I understand it, it throws some kind of exception. How do I catch this exception? Some code I'm trying to create: infoToCode :: Info -> Q Exp infoToCode (ClassI dec) = -- ClassI Dec fail "ClassI not supported" -- this will be implemented infoToCode (ClassOpI name xtype name2 fixity) = -- ClassOpI Name Type Name Fixity fail "ClassOpI not supported" infoToCode (TyConI dec) = -- TyConI Dec fail "TyConI not supported" infoToCode (PrimTyConI name int bool) = -- PrimTyConI Name Int Bool fail "PrimTyConI not supported" infoToCode (DataConI name xtype name2 fixity) = -- DataConI Name Type Name Fixity fail "DataConI not supported" infoToCode (VarI name xtype maybedec fixity) = -- VarI Name Type (Maybe Dec) Fixity fail "TVarI not supported" infoToCode (TyVarI name xtype) = -- TyVarI Name Type fail "TyVarI not supported" nameToCode1 :: Name -> Q Exp nameToCode1 name = do info <- reify name Code <- infoToCode info runIO $ putStrLn $ pprint Code return Code -- Here be dragons... nameToCode name = nameToCode1 name `catch` c where c e = do runIO $ putStrLn $ show e fail "refailed" -- Gracjan

1 0

Dread __DISCARD__
by Steven Elkins 20 Sep '05

20 Sep '05

Hello everyone, I'm a Haskell newbie trying out various programs from the web. I'm trying to compile one called bjpop-ray (from Bernie Pope, I think) and I hit this at link-time: ghc --make -O0 -package wx Main.hs -o bjpop-ray Chasing modules from: Main.hs Skipping Data ( ./Data.hs, ./Data.o ) Skipping Sphere ( ./Sphere.hs, ./Sphere.o ) Skipping Parser ( ./Parser.hs, ./Parser.o ) Skipping Vector ( ./Vector.hs, ./Vector.o ) Skipping Polygon ( ./Polygon.hs, ./Polygon.o ) Skipping RayTrace ( ./RayTrace.hs, ./RayTrace.o ) Skipping Main ( Main.hs, Main.o ) Linking ... /usr/bin/ld: Undefined symbols: ___DISCARD__ collect2: ld returned 1 exit status I'm on Mac OS 10.4.2, using ghc 6.4 (from the haskell.org .dmg) and gcc 4.0.0. Other wxHaskell programs (the samples and my own experiments) compile without tripping over this. Googling __DISCARD__ led me to "...the binary on the ghc web site has the evil __DISCARD__ mangler problem..." on the darwinports bug mailing list, so I guess I'm not the first person to see this. Is there a workaround? Does the Darwin port have the same problem? Should I just work on the many other things I've yet to grasp? Usually ghc works fine. Thanks, Steve -- How wonderful it is that nobody need wait a single moment before starting to improve the world. -- Anne Frank Paradise is exactly where you are right now...only much, much better. -- Laurie Anderson

3 3

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

RE: [Haskell-cafe] Nofib documentation
by Simon Peyton-Jones 19 Sep '05

19 Sep '05

I don't think there's a nofib reference document. (Would someone like to write one?) The standard/slow/fast inputs are meant to vary the input data to the benchmarks so they take more or less time. Not all programs are set up that way because we didn't write all of them, and don't necessarily understand how they work. Any help in getting slow/fast data for programs currently lacking them would be great. Simon ________________________________ From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of Monique Louise Sent: 17 September 2005 13:51 To: haskell-cafe(a)haskell.org Subject: [Haskell-cafe] Nofib documentation Hi all. does anyone know where can I find a better documentation for Nofib benchmark? Is there any reference which contains the "standard" and "slow" inputs? In the CVS tree I just found the standard/slow/fast outputs. Thanks in advance, -- ________________________________ Monique Louise B.Monteiro Msc Student in Computer Science Center of Informatics Federal University of Pernambuco

1 0

RE: [Haskell-cafe] generics question, logical variables
by Ralf Lammel 19 Sep '05

19 Sep '05

Hi Frederik, [I call this "the dreadful lack of kind polymorphism strikes back" :-)] I put SPJ on cc; perhaps he can suggest a way to improve in this area. Based on input, I could try to work on this issue in the not so remote future. Let me briefly recapitulate. My recollection is that deriving works for Typeable, Tyepable1, ..., if all type parameters are of type kind "*". Whenever you can derive a Typeablen instance with n > 0, you can instead ask for Typeable to be derived. The reason why you cannot get both a Typeable and say a Typeable42 instance is that there are generic instances for getting an "n-1 instance" from the "n instance". However, this is also precisely the reason why you don't want them both. That is, you get everything you can ask for, if you have the "n instance" for the actual arity of the type constructor in question. (Getting a smaller n or no n just means that you limit polymorphic type case.) Recall that you *may* need a n>0 instance if you want to do polymorphic type case according to the SYB2 paper. As long as you are fine with monomorphic generic function extension, the plain Typeable instance should be fine. However, the real limitation is here, *indeed*, as said, that GHC does not derive Typeable[1|2|...] for parameter kinds other than "*". This was the reason that I had to hand-code some Typeable instances in your original example. Let us also be honest about another limitation of the current deriving code. "deriving Data" gives you Data instances that do *not* support polymorphic type case. That is the following code prints 0, 1, 0 whereas you may expect 0, 1, 2. newtype Foo x = Foo x deriving (Typeable, Data) f :: Data a => a -> Int f = const 0 `ext1Q` (\(_::Maybe x) -> 1) `ext1Q` (\(_::Foo y) -> 2) main = do print $ f True print $ f (Just True) print $ f (Foo (Just True)) This is the reason that I had to handcode some Data instances in your original example, which wasn't hard BTW. We thought that these two limitations were Ok since we didn't expect people to write many polymorphic datatype constructors on which SYB should work. Sounds like a feature request. Now I wonder how much work it is to improve the situation. We need to make the GHC deriving code a bit more kind-aware. I guess we are still not at the point where we want to add kind polymorphism to Haskell? Would be a nice topic for future work on SYB. Clearly, the GH folks have done splendid work in this area. Getting full-blown kind polymorphism in normal Haskell though seems to be less of a topic, simply because we do not have many scenarios around that would *really* require it. Does anyone want to speak up and mention scenarios that would benefit from kind polymorphism? (In Haskell, we are likely to see kind polymorphism, if at all, in the form of type classes whose type parameters can be of different, perhaps of all kinds.) Frederik, for the time being I propose to look into TH code for deriving Tyepable/Data instances and to make it fit for your purposes. There are several versions of Ulf Norell's code around. You may also use SYB3 with the TH code that readily comes with it. Thanks for bringing this up. Regards, Ralf > -----Original Message----- > From: Frederik Eaton [mailto:frederik@a5.repetae.net] > Sent: Sunday, September 18, 2005 7:50 PM > To: Ralf Lammel > Cc: haskell-cafe(a)haskell.org > Subject: Re: [Haskell-cafe] generics question, logical variables > > Hi Ralf, > > I'm revisiting this project and just have another question. The story > seems to be that GHC cannot derive Typeable1, or Typeable when > Typeable1 is available - so anyone who wants to use ext1Q must define > special instances for all of the datatypes they use, is this correct? > Will this change soon? > > Aside from that, your 'idify' in PseudoFmap2 certainly seems to have > the correct type for this application. However, the absence of > automatic derivation is somewhat of an impediment. > > Thanks for your help. > > Frederik > > On Tue, Aug 30, 2005 at 02:25:08PM -0700, Ralf Lammel wrote: > > Frederik, > > > > > As for your code example, it looks very interesting, but are you > > > saying that this could turn into an extension of the Data.Generics > > > library, or that this is something I could be implementing in terms of > > > what's already there? > > > > The posted code works with GHC 6.4 (SYB2) intentionally and actually. I > > have attached another attempt (again GHC 6.4, based on SYB2) which might > > be more useful for your purposes, and it may be useful in general, in > > fact. > > > > What I defined this time is a "certainty-improving" function: > > > > idify :: (Typeable1 f, Monad m, Data (a f), Data (a Id)) > > => (forall a. f a -> m a) -> a f -> m (a Id) > > > > That is, the function "idify get" takes a value whose type is > > parameterized in a type constructor f (such as Maybe or IORef), and the > > function attempts to establish Id instead of f on the basis of the > > function argument "get". > > > > > What is the 'a' parameter for in "force"? > > > > > > force :: ( Data (t Maybe a) > > > , Data (t Id a) > > > , Term t Maybe a > > > , Term t Id a > > > ) => t Maybe a -> t Id a > > > > The previous attempt was a more parameterized blow than required in your > > case. (I was guessing about what "typed logical variables" could mean. > > I was assuming that you would need some extra layer of embedding types > > on top of the Haskell term types. Looking at your code, this was not the > > case.) > > > > > For the part which I asked for help with, to get around my trouble > > > with generics, I defined a class GenFunctor and an example instance. > > > The intent is that generics should be able to provide this > > > functionality automatically later on, but you can see what the > > > functionality is. > > > > Let's look at the type of your GenFunctor: > > > > class GenFunctor f where > > gfmapM :: (Monad m, FunctorM b) => (forall x . a x -> m (b x)) -> f > > a -> m (f b) > > > > This type can be seen as a more relaxed version of the idify operation > > above. That is, idify fixes GenFunctor's b to Id. The particular > > encoding of idify (attached) takes advantage of this restriction. I > > wonder whether I should bother. (Exercise for reader :-)) > > > > > However, I am stuck on something else, the program doesn't typecheck > > > because of use of another function I defined, 'cast1'. Maybe you can > > > take a look. I had thought that I would be able to write a generic > > > 'unify' but I get the error: > > > > > > GenLogVar.hs:82:19: > > > Ambiguous type variable `a' in the constraint: > > > `Data a' arising from use of `cast1' at GenLogVar.hs:82:19-23 > > > Probable fix: add a type signature that fixes these type > > variable(s) > > > > > > This is because I need to do something special when I encounter a > > > "Var" variable in unification, but the compiler seems to not like the > > > fact that the type argument of the Var data type is not known. > > > > Please try to avoid new cast operations at all costs. :-) > > Your code can be arranged as follows: > > > > (i) Use extQ1 to dispatch to a special case for "Var x" for the first > > argument. (ii) In this special case, use again ext1Q to dispatch to a > > special case for "Var y" for the second argument. (iii) At this point, > > *cast* the variable value of *one* variable to the type of the other. > > > > So the problem with your code, as it stands, is that the target type of > > cast is ambiguous because you cast *both* arguments. The insight is to > > make the cast asymmetric. Then, not even polymorphism is in our way. > > > > Interesting stuff! > > > > Ralf > > > > > > -- > http://ofb.net/~frederik/

2 1

RE: [Haskell-cafe] generics question, logical variables
by Simon Peyton-Jones 19 Sep '05

19 Sep '05

Ralf, I'm a bit snowed under at the moment with the POPL PC meeting, but I'm quite open to changing GHC's "deriving" behaviour. It's not hard to change. The hard thing is figuring out just what the specification should be. So if you and others are able to evolve a better design, I'd be happy to implement it. (And of course think about it too.) I'm afraid that full-blown kind polymorphism is probably a bit of a stretch, though it comes up every now and again. So the best monomorphic compromise would be good. There's also the question of whether we should make any changes in GHC's libraries to take SYB3 (using classes) into account... Simon | -----Original Message----- | From: Ralf Lammel | Sent: 19 September 2005 04:34 | To: frederik(a)ofb.net | Cc: haskell-cafe(a)haskell.org; Simon Peyton-Jones | Subject: RE: [Haskell-cafe] generics question, logical variables | | Hi Frederik, | | [I call this "the dreadful lack of kind polymorphism strikes back" :-)] | | I put SPJ on cc; perhaps he can suggest a way to improve in this area. Based on input, I could try to | work on this issue in the not so remote future. | | Let me briefly recapitulate. My recollection is that deriving works for Typeable, Tyepable1, ..., if all | type parameters are of type kind "*". Whenever you can derive a Typeablen instance with n > 0, you | can instead ask for Typeable to be derived. The reason why you cannot get both a Typeable and say a | Typeable42 instance is that there are generic instances for getting an "n-1 instance" from the "n | instance". However, this is also precisely the reason why you don't want them both. That is, you get | everything you can ask for, if you have the "n instance" for the actual arity of the type constructor in | question. (Getting a smaller n or no n just means that you limit polymorphic type case.) Recall that | you *may* need a n>0 instance if you want to do polymorphic type case according to the SYB2 paper. | As long as you are fine with monomorphic generic function extension, the plain Typeable instance | should be fine. | | However, the real limitation is here, *indeed*, as said, that GHC does not derive Typeable[1|2|...] for | parameter kinds other than "*". This was the reason that I had to hand-code some Typeable instances | in your original example. | | Let us also be honest about another limitation of the current deriving code. "deriving Data" gives you | Data instances that do *not* support polymorphic type case. That is the following code prints 0, 1, 0 | whereas you may expect 0, 1, 2. | | newtype Foo x = Foo x deriving (Typeable, Data) | | f :: Data a => a -> Int | f = const 0 | `ext1Q` (\(_::Maybe x) -> 1) | `ext1Q` (\(_::Foo y) -> 2) | | main = do | print $ f True | print $ f (Just True) | print $ f (Foo (Just True)) | | | This is the reason that I had to handcode some Data instances in your original example, which wasn't | hard BTW. We thought that these two limitations were Ok since we didn't expect people to write many | polymorphic datatype constructors on which SYB should work. Sounds like a feature request. | | Now I wonder how much work it is to improve the situation. We need to make the GHC deriving code | a bit more kind-aware. I guess we are still not at the point where we want to add kind polymorphism | to Haskell? Would be a nice topic for future work on SYB. Clearly, the GH folks have done splendid | work in this area. Getting full-blown kind polymorphism in normal Haskell though seems to be less of a | topic, simply because we do not have many scenarios around that would *really* require it. | | Does anyone want to speak up and mention scenarios that would benefit from kind polymorphism? (In | Haskell, we are likely to see kind polymorphism, if at all, in the form of type classes whose type | parameters can be of different, perhaps of all kinds.) | | Frederik, for the time being I propose to look into TH code for deriving Tyepable/Data instances and to | make it fit for your purposes. There are several versions of Ulf Norell's code around. You may also use | SYB3 with the TH code that readily comes with it. | | Thanks for bringing this up. | | Regards, | Ralf

1 0

Dread __DISCARD__
by Wolfgang Thaller 19 Sep '05

19 Sep '05

> I'm on Mac OS 10.4.2, using ghc 6.4 (from the haskell.org .dmg) and > gcc 4.0.0. Other wxHaskell programs (the samples and my own > experiments) compile without tripping over this. GHC 6.4 is incompatible with gcc 4.0.0 when -O or -via-C is used. You can work around this problem by either not using -via-C and always adding -fasm *after* -O, or by setting your default compiler to gcc-3.3 using sudo gcc_select 3.3 ... but be aware that this also affects other C compilations; switch back using sudo gcc_select 4.0 I suspect that you compiled the program with -O before, and then switched to -O0 without removing your .o files. If you compiled wxHaskell yourself, then the problem might also be in wxHaskell (you'd have to recompile it then). The upcoming GHC 6.4.1 will of course fix this problem. Cheers, Wolfgang

3 2

Eq Type Class: Overloading (==)
by Tom Hawkins 19 Sep '05

19 Sep '05

Hello, Is it possible to overload (==) to a type other than a -> a -> Bool? I have an abstract datatype that somewhat behaves like a C integer: a comparison returns a boolean represented as the same datatype: (==) :: my_type -> my_type -> my_type Thanks for any help! -Tom

9 12

Nofib documentation
by Monique Louise 17 Sep '05

17 Sep '05

Hi all. does anyone know where can I find a better documentation for Nofib benchmark? Is there any reference which contains the "standard" and "slow" inputs? In the CVS tree I just found the standard/slow/fast outputs. Thanks in advance, -- ________________________________ Monique Louise B.Monteiro Msc Student in Computer Science Center of Informatics Federal University of Pernambuco

1 0

Re: [Haskell] Re: [Haskell-cafe] Haskell versus Lisp
by David F. Place 17 Sep '05

17 Sep '05

On Sep 16, 2005, at 6:26 PM, Glynn Clements wrote: > Haskell's safety and > consistency can get in the way, while Lisp's freedom can be quite > unsafe and inconsistent. I have many years of experience designing and implementing commercial software in lisp and I strongly agree with the second part of this sentence. However, my more recent experience with Haskell makes me doubt very much the first part. Haskell's powerful type system hasn't in the least cramped my style and lazy evaluation eliminates 99% of the need for macros in lisp. (The other 1% is syntactic sugar of doubtful utility.) Since Haskell supports recursive polymorphic types it can easily handle all of the metaprogramming problems where lisp first made its mark. I don't see any reason to continue to use lisp. ps. This thread was on Haskell-cafe which seems more appropriate, so I'm bringing it back. -------------------------------- David F. Place mailto:d@vidplace.com

2 1

Use Haskell to extract GXL representation
by Sara Kenedy 17 Sep '05

17 Sep '05

Dear you all, Currently, I am working with Haskell and GXL file (Graph eXchange Language). GXL is a sublanguage of XML and its syntax is based on XML DTD. 1) In my work, I use GXL representation to represent a quantification (e.g. forall(x:Z|x = 3 and x^2 - 3x + 2 =0)) 2) My objective is to write a Haskell module to extract the content of the GXL file such that a prover theorem (e.g, ICS) and a computer algebra system (e.g, Matlab) can read the content of GXL file. If any of you have experiences or any ideas about the problem, please share with me. I really appreciate for that.Thanks a lot. Sara.

2 1

Use Haskell to extract GXL file (GXL representation)
by Sara Kenedy 16 Sep '05

16 Sep '05

Dear you all, Currently, I am working with GXL file (Graph eXchange Language). GXL is a sublanguage of XML and its syntax is based XML DTD. In my work, I use GXL representation to represent a quantification: forall(x:Z|x = 3 and x^2 - 3x + 2 =0) My objective is to write a Haskell module to extract the content of the GXL file such that a computer algebra system (e.g, Matlab) or a prover theorem (e.g, ICS) can read the content of GXL file. Anybody

1 0

killing a running thread interactively
by S. Alexander Jacobson 16 Sep '05

16 Sep '05

If I am running a server interactively. (using ghci). Is there any way to kill its running threads without terminating the interpreter? -Alex- ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com

1 0

wxHaskell: convenience functions
by Mark Carter 16 Sep '05

16 Sep '05

I'm experimenting with wxHaskell, and I've got something like: main = run mainFrame mainFrame = do -- main application frame ... cbEdit <- checkBox p1 [text := "Edit Mode", on command ::= onCbEdit textlog] ... where ... It would be useful to have some convenience function, let's say, isEditing, which works out whether cbEdit is checked, or not. That way, one could just pass this in as a parameter without requiring any extra code. The problem is, I can't see how it can be done. I've tried various things in the main section, and nothing worked. I tried putting the following defintion into the where clause: isEditing = do checkedp <- get cbEdit checked return checkedp but the compiler complained that cbEdit is not in scope. I /could/ pass in cbEdit as a parameter to isEditing, but I'd rather not. ___________________________________________________________ To help you stay safe and secure online, we've developed the all new Yahoo! Security Centre. http://uk.security.yahoo.com

2 2

Re: [Haskell-cafe] wxHaskell: convenience functions
by Mark Carter 16 Sep '05

16 Sep '05

Re: [Haskell-cafe] wxHaskell: convenience functions Actually, I can see how my requirement of not wanting to pass in cbEdit might not be so good. From an FP point of view, that's just asking for trouble. A better solution would appear to be to put the cbEdit in as a parameter, and just face the fact that all callers will be required to pass an extra parameter. Mark Carter wrote: > > > I'm experimenting with wxHaskell, and I've got something like: > > main = run mainFrame > > mainFrame = do -- main application frame > ... > cbEdit <- checkBox p1 [text := "Edit Mode", on command ::= onCbEdit textlog] > ... > where > ... > > It would be useful to have some convenience function, let's say, isEditing, which works out whether cbEdit is checked, or not. That way, one could just pass this in as a parameter without requiring any extra code. The problem is, I can't see how it can be done. I've tried various things in the main section, and nothing worked. I tried putting the following defintion into the where clause: > > isEditing = do > checkedp <- get cbEdit checked > return checkedp > > but the compiler complained that cbEdit is not in scope. I /could/ pass in cbEdit as a parameter to isEditing, but I'd rather not. > > > > ___________________________________________________________ To help you stay safe and secure online, we've developed the all new Yahoo! Security Centre. http://uk.security.yahoo.com > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > ___________________________________________________________ Yahoo! Messenger - NEW crystal clear PC to PC calling worldwide with voicemail http://uk.messenger.yahoo.com

1 0

Re: [Haskell-cafe] Haskell versus Lisp
by Jacques Carette 16 Sep '05

16 Sep '05

Glynn Clements wrote: >Every other language (including Haskell) tends to have the problem >that eventually you will encounter a situation where the language's >own worldview gets in the way. > >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. > > I was just about to say something very similar. So to add a new point: Why is there a partial evaluator for full Scheme (http://www.informatik.uni-freiburg.de/proglang/software/pgg/) but none for full Haskell (or full ML for that matter)? The problem is considerably harder - see the papers listed at http://partial-eval.org/scheme_pe.html. The issue there is definitely one of worldview. The Haskell type system (and the ML type system as well) have a wordview that is incompatible with very powerful code manipulations. That is why Template Haskell is *untyped*, and why MetaOCaml (www.metaocaml.org) puts serious restrictions on what can be done with code so as to prevent unsoundness. However, Gilmore's work on Intensional Type Theory (http://www.cs.ubc.ca/spider/gilmore/) looks very promising to me as a method to attack this worldview problem. Others have tried to use modal logic (mostly S4), but I personally don't believe that is the right way to go. Jacques PS: yes, I know about http://www.cs.chalmers.se/~rjmh/PECourse/Exercises/PE.html and http://www.informatik.uni-freiburg.de/proglang/research/software/mlope/.

1 0

Re: [Haskell-cafe] wxHaskell: getting a checkbox state
by Mark Carter 16 Sep '05

16 Sep '05

Arthur Baars wrote: > Hi, > > A "Checkbox" is instance of the class Checkable: > http://wxhaskell.sourceforge.net/doc/ > Graphics.UI.WX.Classes.html#t%3ACheckable > > This means you can "get" and "set" the "checked" property for > checkboxes. > for example: > c <- get cbEdit checked > set cbEdit [checked := not c ] > > The following code makes the checkbox print its state every time it > is checked or unchecked: > cbEdit <- checkBox f [text := "Edit Mode" ] > set cbEdit [ on command := do v <- get cbEdit checked > print v > ] AHA! Yes, very useful. The problem I was having before was that I was trying to create a separate function onCbEdit, thus: cbEdit <- checkBox p1 [text := "Edit Mode", on command := onCbEdit textlog ] This had the problem that onCbEdit basically needed to have its control passed in (i.e. cbEdit) as a parameter in order to inspect its state. So I wanted to do something like: cbEdit <- checkBox p1 [text := "Edit Mode", on command := onCbEdit textlog cbEdit ] Except you can't do that, because cbEdit isn't yet defined. But your suggestion gets 'round that. In the main loop, I now do: cbEdit <- checkBox p1 [text := "Edit Mode" ] set cbEdit [ on command := onCbEdit textlog cbEdit ] and in my where clause I do: onCbEdit textlog me = do checkedp <- get me checked appendText textlog "onCbEdit\n" appendText textlog (show checkedp) Of course, I'll ultimately want it to do something much more interesting than that - but I was just scratching my head wondering how on earth it could be done; until you came along. Hmm. interesting. I'm finding Haskell a bit head-scratching generally. The syntax is unfamiliar, and Monads, blimey. My understanding of them so far is that they form a barrier between the big, nastey, stateful world, and the clean functional world that I as a programmer occupy. Although I seem to be using a lot of do statements, which presumably means that I'm back in the world of imperative programming. I program in VBA for a living now, but I have a lot of familiarity with Python, and I've done a fair amount of C in my time. I know a bit about C++, but have never gotten involved much with the GUI side of it. A few days ago, I installed an old version of Visual C++, and generated an MFC boilerplate app. My impression is that this MFC/C++ stuff is a confused mess. Admittedly I know very little about MFC; but I'm fairly confident that if a good programmer sat down to design a GUI system from scratch, he would not end up with something like MFC. There seems to be too many "bits" to it, and you have to scatter your declarations over too many files, with scaffolding everywhere. My application also needs to create GUI elements on the fly - and the MFC approach to doing this is woefully painful. I'm currently hacking BouncingBalls.hs to be more to my liking (my balls don't bounce, for starters). The way it adds balls is straighforward. I find I need to hack code that already-exists because my understanding of the syntax and principles is very limited. I continue my Haskell experiments further ... > Arthur > > PS: there is a mailinglist for wxhaskell-related questions: > http://lists.sourceforge.net/lists/listinfo/wxhaskell-users Seems quite dormant, though. Only 4 postings last month. BTW, apologies Arthur Baars - I meant to email this response to the newsgroup, but ended up posting to him personally. ___________________________________________________________ Yahoo! Messenger - NEW crystal clear PC to PC calling worldwide with voicemail http://uk.messenger.yahoo.com

3 3

And another basic typing question -- empty list
by Adam Wyner 16 Sep '05

16 Sep '05

Hi, I have some questions about using the empty list in Hugs. In June 2001, this was raised as a bug in hugs (see Hugs-Bugs Archives). References therein to a bug list on S. Thompson's pages come up a dead end. I haven't found any follow up or solution to this discussed. I would particularly like to use an empty list in the Trex module of Hugs. Suppose I have two expressions: emptyListA = null emptyListB = [] emptyListA is apparently a function from empty lists to Bool. I would have thought that emptyListB would just be the empty list and output it as such. > :t emptyListA emptyListA :: [a] -> Bool > emptyListA [] True The problem is that there is no "show" function for emptyListB, which is just [] > emptyListB ERROR - Cannot find "show" function for: *** Expression : emptyListB *** Of type : [a] What I would like, simply is: >emptyListB [] More to my purpose, I would like to use the empty list as a value of a record in Trex. For instance, while the first example below gives a good result, the second example has no "show" function. Looking at the Trex module, it would seem that there is a show function for the empty list (?? but frankly, I have never touched this area of haskell, so I haven't given it much thought). Sample command line I/O. > (a = 'a', b = [2]) (a = 'a', b = [2]) > (a = 'a', b = []) ERROR - Cannot find "show" function for: *** Expression : (a = 'a', b = []) *** Of type : Rec (a :: Char, b :: [a]) Clearly, the problem is the empty list labelled b. What I want is the following sort of result: > (a = 'a', b = []) (a = 'a', b = []) Further along, what I want is to have values for the field labelled b to be lists which contain something. So, in one case, the value is [], while in another it is [2], say. Moreover, I want to define a type which has a label with values of type lists. That is, I want to have a record something like Rec (a :: Char, b :: List). However, List is not a basic data type. And in any case, the values of labels cannot show empty lists. I'm unsure whether Trex or any record type can handle this. Here are some examples. The following is OK. type TestList01 = Rec (a :: Char, b :: [Char]) testList01 :: TestList01 testList01 = (a = 'a', b = "b") Input and output are: > testList01 (a = 'a', b = "b") ComplexActions01> :t (a = 'a', b = "b") (a = 'a', b = "b") :: Rec (a :: Char, b :: [Char]) But the following type is uninterpretable: type TestList02 = Rec (a :: Char, b :: []) ERROR "ComplexActions01.lhs":196 - Illegal type "[]" in constructor application. Suggestions about how to treat empty lists? Thanks, Adam Wyner

2 1

Basic Haskell Types Question
by Adam Wyner 16 Sep '05

16 Sep '05

Hi, I have a basic question about how output types are reported. I'm using Hugs. Suppose I have the following, where the type String is predefined in the Prelude as [Char]. type PropList = [String] atomicProps1 :: PropList atomicProps1 = ["prop1"] And I have a function on expressions of type PropList which takes every string from the input list and prefixes the string "neg-" to it. negationAtomicProps :: PropList -> PropList negationAtomicProps inPropsList = [ "neg-" ++ inString | inString <- inPropsList] So, with the following, I get the right result: > negationAtomicProps atomicProps1 ["neg-prop1"] The types for the parts are right: > :t negationAtomicProps negationAtomicProps :: PropList -> PropList > :t atomicProps1 atomicProps1 :: PropList But, what I don't understand or like is that the type of the whole is given as [[Char]], not what I thought it would be, namely PropList. Nor is it [String]. > :t negationAtomicProps atomicProps1 negationAtomicProps atomicProps1 :: [[Char]] I really want to get the following sort of report for the type: negationAtomicProps atomicProps1 :: PropList The reason I want this is that in more complex cases, it will be easier to see what is going wrong (as the functions are developed) if I can see the types I want. Am I supposed to be using newtype or data declarations here? How would I do this? I looked around for information in the usual sources, but haven't found an answer. Thanks, Adam Wyner

2 1

Functional vs Imperative
by Dhaemon 15 Sep '05

15 Sep '05

Hello, I'm quite interested in haskell, but there is something I don't understand(intuitively). I've been crawling the web for an answer, but nothing talks to me... So I was hoping I could find some help here: "How is evaluating an expression different from performing action?" I'm puzzled... Doesn't it amount to the same thing? Maybe I have a wrong definition of "evaluating"(determine the value of an expression)? Examples would be appreciated. Also, just for kicks, may I had this: I read the code of some haskell-made programs and was astonished. Yes! It was clean and all, but there were "do"s everywhere... Why use a function language if you use it as an imperative one?(i.e. most of the apps in http://haskell.org/practice.html) Thanks in advance,

9 13

Binary parser combinators and pretty printing
by Einar Karttunen 15 Sep '05

15 Sep '05

Hello I am trying to figure out the best interface to binary parser and pretty printing combinators for network protocols. I am trying to find the most natural syntax to express these parsers in Haskell and would like opinions and new ideas. As an example I will use a protocol with the following packet structure: 0 message-id 4 sender-id 8 receiver-id 12 number of parameters 16 parameters. Each parameter is prefixed by 32bit length followed by the data. We will use the following Haskell datatype: data Packet = Packet Word32 Word32 Word32 [FastString] 1) Simple monadic interface getPacket = do mid <- getWord32BE sid <- getWord32BE rid <- getWord32BE nmsg<- getWord32BE vars<- replicateM (fromIntegral nmsg) (getWord32BE >>= getBytes) return $ Packet mid sid rid nmsg vars putPacket (Packet mid sid rid vars) = do mapM_ putWord32BE [mid, sid, rid, length vars] mapM_ (\fs -> putWord32BE (length fs) >> putBytes fs) vars This works but writing the code gets tedious and dull. 2) Using better combinators packet = w32be <> w32be <> w32be <> lengthPrefixList w32be (lengthPrefixList w32be bytes) getPacket = let (mid,sid,rid,vars) = getter packet in Packet mid sid rid vars putPacket (Packet mid sid rid vars) = setter packet mid sid rid vars Maybe even the tuple could be eliminated by using a little of TH. Has anyone used combinators like this before and how did it work? 3) Using TH entirely $(getAndPut 'Packet "w32 w32 w32 lengthPrefixList (w32 bytes)") Is this better than the combinators in 2)? Also what sort of syntax would be best for expressing nontrivial dependencies - e.g. a checksum calculated from other fields. 4) Using a syntax extension Erlang does this with the bit syntax (http://erlang.se/doc/doc-5.4.8/doc/programming_examples/bit_syntax.html) and it is very nifty for some purposes. getPacket = do << mid:32, sid:32, rid:32, len:32 rest:len/binary >> ... The list of lists gets nontrivial here too... - Einar Karttunen

4 5

RE: [Haskell] ANNOUNCE: ghc-src version 0.2.0
by Simon Marlow 15 Sep '05

15 Sep '05

On 30 August 2005 12:05, Arthur Baars wrote: > Daan is right, I wrote a parser for GHC using Doaitse Swierstra's > parsing combinator library > (http://www.cs.uu.nl/groups/ST/Software/UU_Parsing/index.html) > I needed a drop-in replacement for GHC's Happy parser, to make a > prototype for syntax macros. Syntax Macros allow a programmer to > extend a language with new syntax. Combinator based parsers parsers > can be dynamically extended, making them suitable for implementing > syntax macros. Unfortunately, I never had time to really finish the > syntax macro implementation. > > But I did finish the combinator based parser for GHC. I tested it by > having GHC( with combinator parser) compile itself and all the > libraries. This took about 10% longer than with the original GHC, so > in practice its speed is acceptable. With all due respect, a 10% increase in compile time isn't acceptable at all! And when you consider that parsing is less than 10% of compile time overall (probably much less), a 10% increase represents at least a factor of 2 in the parser. I'm not criticising the work at all - far from it, just the notion that we would consider adding 10% to GHC's compile times "acceptable". I've recently been struggling to shave a few percent off GHC's compile times, BTW :-) Cheers, Simon

2 1

Doing Windows Programming
by Brian McQueen 15 Sep '05

15 Sep '05

How can I use Haskell to do general Windows programming, like you would be able to do if you were using one of those Windows IDEs: *moving data between windows apps *gaining access to windows registry *in general, access to the available Windows APIs I'm sure folks must be writing Windows apps in Haskell somewhere. How do I get started? Brian McQueen

5 5

RE: Re[2]: [Haskell-cafe] Weak hashtable memoization code?
by Simon Marlow 15 Sep '05

15 Sep '05

On 15 September 2005 13:44, Bulat Ziganshin wrote: > Hello Simon, > > Tuesday, September 13, 2005, 7:42:52 PM, you wrote: > >> There's the memo table implementation in the util package: >> hslibs/util/Memo.lhs. Note that this is scheduled for demolition in >> GHC >> 6.6. > > why? It doesn't perform very well, there's a general lack of interest, and nobody interested in supporting it. The right thing to do is make it available as a Cabal package. Cheers, Simon

1 0

Autrijus Tang interviewed by Perl.com
by John Goerzen 15 Sep '05

15 Sep '05

metaperl posted about this on the Haskell Sequence this morning and I thought all of you list readers might be interested as well. Autrijus Tang is well-known for developing the first working Perl 6 interpreter, Pugs. Pugs is written in Haskell. Perl.com has an interview with Autrijus, and page 2 of that interview gets particularly interesting. URL: http://www.perl.com/pub/a/2005/09/08/autrijus-tang.html?page=2 Favorite quote: "Haskell . . . is faster than C++, more concise than Perl, more regular than Python, more flexible than Ruby, more typeful than C#, more robust than Java, and has absolutely nothing in common with PHP." -- John

3 2

RE: [Haskell-cafe] Weak hashtable memoization code?
by Simon Marlow 15 Sep '05

15 Sep '05

On 28 August 2005 16:39, Bulat Ziganshin wrote: > Hello David, > > Sunday, August 28, 2005, 4:19:07 PM, you wrote: > >> Hi all, > >> Does anyone have a nice bit of example code to implement memoization >> using weak pointers and hash tables? It would be nice to have a >> pre-packaged module that I could just use, which has already been >> tested. The contents of Data.WeakPtr seem a bit lower-level than >> I'd rather work with. > > http://www.haskell.org/~simonmar/papers/weak.pdf There's the memo table implementation in the util package: hslibs/util/Memo.lhs. Note that this is scheduled for demolition in GHC 6.6. Cheers, Simon

2 1

How to call ICS from Haskell
by Huong Nguyen 15 Sep '05

15 Sep '05

Hello everybody, Do you know how to call ICS (Integrated Canonizer and Solver: www.icansolve.com <http://www.icansolve.com>) or PVS (Prototype Verification System) from Haskell ? Thank you in advance.

2 1

Re: Functional vs Imperative
by Dhaemon 15 Sep '05

15 Sep '05

Hi again, Thanks to everyone for replying. I think I get it now; I was focusing on the wrong aspect of the question. I was totally overlooking referential transparency and the cascade of 'capabilities'(lazyness, etc) it creates. Thus evaluation is just getting values out of expressions, actions(which modify the state of the 'world') are never performed... Except when 'cheating' with monads. Hat-anim is really interesting, I'm playing with it at the moment... Thanks again, Best regards,

2 1

wxHaskell: getting a checkbox state
by Mark Carter 14 Sep '05

14 Sep '05

I'm a complete n00b to Haskell, and I am trying to write an experimental app using wxHaskell. I'm getting on suprisingly well, given that I have practially no idea what I'm doing. In my main loop I have cbEdit <- checkBox p1 [text := "Edit Mode", on command := onCbEdit textlog ] where p1 is a panel, and textlog is a textCtrl that I want to write output to. In my where clause I have defined: onCbEdit textlog = do appendText textlog "onCbEdit\n" So far, this works. The thing that's got me totally stumped is this: suppose I want onCbEdit to do something dependent on the state of the checkbox (i.e. whether it is checked or unchecked). I've tried a variety of things, but I can't get anything to work. To put things into a wider context, here's the message I posted to fa.haskell yesterday: I'm the rawest of n00bs to Haskell. I was interested in evaluating it, and I've seen some GUI stuff that looked pretty impressive. I wanted to write a protoype for a commercial application to do hydrocarbon accounting. Which is to say, you've a number of so-called "streams" - think of them as graph nodes - feeding into each other in a directed fashion (assume the graph is acyclic). Then there's a bunch of business logic which determines how the values of one stream are affected by the values in another. An example of a stream might be a platform. Another one might be a well. Each stream would display on the window as some funky symbol, with its name underneath. It would be nice if the application had an edit mode, where you could add, move, delete, and join streams in a window; and a data mode, where you could click on the stream you were interested in and examine its properties. Is there a Haskell GUI toolkit which is particularly suitable for this? Other requirements of the toolkit would be: * Works on Windows (XP) * commercial-friendly licence: GPL is out, and even LGPL is a bit fiddly * free * bonus points for being easy to use, and well-documented ___________________________________________________________ To help you stay safe and secure online, we've developed the all new Yahoo! Security Centre. http://uk.security.yahoo.com

4 3

RE: [Haskell-cafe] static typing and interactivity
by Simon Marlow 14 Sep '05

14 Sep '05

On 18 August 2005 16:11, Jake Luck wrote: >> One slight annoyance using Haskell is the inability to load modules >> with type problems in the interactive environment (i.e. GHCi). When >> I have a type error, it would be nice to have an interactive way to >> explore what the compiler thinks about the types involved -- as it >> is, I have to resort to adding type signatures more or less at >> random to narrow down the problem. >> >> I'm not sure if it is technically feasible to (partially) load a >> module with definitions that fail type checking, but if it were, I >> thing it would make developing Haskell programs even nicer :-) > > Along similiar lines, it would be quite nice if one can mark their > haskell code(working or not) with "breakpoints" and drop the > programmer into GHCi so they can poke around, especially inside a > do-construct. e.g. something the evalutation engine can check during > reduction maybe? I find myself writing a lot of testing frameworks, > maybe this is a good thing!, when I program. How do most of the folks > here debug their large code base? I would really like to do this, and I've put some thought into how to do it. Basically you need 2 things: - A generic way to display data found in the heap. Heap data doesn't carry around it's type, but we need a way to display the arguments to polymorphic functions (for example). Fortunately GHCi has all the information about the layout of known data types, all that's needed is a way to map a heap closure to GHCi's representation of constructor (a DataCon), which is quite possible - some support from the dynamic linker is required, though. - A way to set breakpoints. This is far easier for interpreted code than for compiled code: for interpreted code we can just replace the appropriate BCO (byte code object) with a special breakpoint object. A breakpoint would contain information about its free variables, and a pointer to the original BCO. The harder part is to map source locations to byte code objects, retaining the information through the various compiler passes (HsDebug did some work in this direction, I believe). Anyone interested in working on this, please get in touch. Cheers, Simon

1 0