- Haskell-Cafe - Haskell.org

Whatever happened to Trex.hs
by Adam Wyner 02 Mar '07

02 Mar '07

Hi, I'd been using trex.hs for extensible records and programmed a bit using it. I liked it for what it did and also because it had very nice documentation on how to use it. I know there are other proposals and implementations in Haskell for records (HaskellDB and HList), but for the time being I still want to use Trex.hs. It seems to me that the current distribution of Haskell is not supporting Trex, or at least I can't find any information anymore about it, nor anything on the discussion lists. Installing recent distributions of Hugs gives me error messages about missing type constructors for records. Thanks, Adam

1 0

Automatic Recognition of Functors
by Walter Potter 02 Mar '07

02 Mar '07

Folks, Given f:: a -> b it is very natural to lift f to P f :: P a -> P b where P is the power set functor. Or L f :: [a] -> [b]. We are modeling structures using repeated application of the power functor, via repeated application of [ ]. It would be very nice if Haskell would recognize this lifting. That is, if f :: a -> b then one automatically has f :: [a] -> [b] without using fMap. We can do something similar with classes in the following way: Given class Addy a where (+.) :: a -> a -> a instance(Addy a) => Addy [ a] (+.) w [ ] = w (+.) [ ] w = w (+.) (a:as) (b:bs) = (a+b) :(as + bs) Now given instance Addy Int (+.) x y = x+y One can compute [[1,2],[3,4]] +. [ [2,3],[1,2,.3]]. I know I'm asking for a bit more here. I might need to use fMap f : [ a] -> [ b]. But I can't seem to get by with fMap f [[1,2],[3,4]] when f :: Int -> Int We often need to lift functions to higher power maps. It would be nice to have a way to do this with ease. Suggestions are welcome. Walt

3 2

Re: [Haskell-cafe] numeric minimization in Haskell
by Chad Scherrer 02 Mar '07

02 Mar '07

David Roundy wrote: > It seems like GSLHaskell is an awfully big stick, when all you need are > scalar multiply and vector addition. Of course, we don't know what > functions he wants to minimize, but in the absence of any need for GSL > functions, I don't see a good reason for it. The function is just a linear combination of sines and cosines. No need for GSL for that. > I see that GSLHaskell has a binding to a conjugate gradients minimizer, but > it's not useful for any hard problems (it stores the trajectory, which > defeats the purpose of using conjugate gradients), and can only be very, > very slow. I had been throwing the trajectory away without any more thought, but I suppose it would slow things down quite a bit. > >From the API alone it cannot be efficient. Code that is written by people > who obviously either don't know or don't care about efficiency is just not > in general a good idea. I don't know what you use GSLHaskell for in your > work, but I hope you don't use it for conjugate gradients, or only use it > on easy problems. I agree, given the API it seems like it could be very nice for visualizing how CG works, but it does seem to rule out high performance. > -- > David Roundy > Department of Physics > Oregon State University Chad Scherrer

1 0

Blog post: 'Haskell IO for imperative programmers'
by David House 02 Mar '07

02 Mar '07

It's not mine, but I just came across the following from a link in #haskell: http://blogs.nubgames.com/code/?p=22 A brilliantly written, fantastically clear exposition of IO from the point of view of a long-time imperative programmer. Don't miss it. One to forward to friends and coworkers. -- -David House, dmhouse(a)gmail.com

1 0

OO Design in Haskell Example (Draft)
by Steve Downey 02 Mar '07

02 Mar '07

In the last OO design in Haskell thread (and probably in every one preceeding it), it was suggested that having some examples might be a good idea. Since most people with existing designs will have some familiarity with Design Patterns, and those are typical building blocks for OO designs, it occured to me that implementing some of them might be a useful excersize. If for nothing other than learning some more Haskell. Now, some of them are probably bad ideas for implementing in Haskell. There's a better, or more natural, way than what is suggested by the design pattern. Visitor is probably not a good pattern to follow, for example. On the other hand, others may still be useful, even in a functional language. So, I've been working on a Composite example. I've used existential types to have a generic proxy to the base type, rather than a simple algebraic type, since adding new leaves to the algebraic type means modifying the whole type, a violation of the Open-Closed principle (open for extension, closed for modification) The interface of the composite. Two methods, add and draw. > class IComponent e where > draw ::e -> String > add :: (IComponent e') => e -> e' -> Component A proxy type which can hold any kind of component, and provides the 'virtual' dispatch implementation. That is, it forwards to the add or draw implementation of the instance it is proxying for. > data Component = > forall e.(IComponent e) => Component e > componentDraw :: Component -> String > componentDraw (Component c) = draw c > componentAdd :: (IComponent e) => Component -> e -> Component > componentAdd (Component e) a = Component (add e a) > instance IComponent Component where > draw = componentDraw > add = componentAdd The Single type, which is the leaf node in this composite, add is a no-op, except for wrapping the value in a Component. Since there isn't an implicit down cast from the 'derived' Single to the 'base' Component. > data Leaf = > Text String > deriving(Show, Eq) > leafDraw :: Leaf -> String > leafDraw (Text s) = show s > leafAdd :: (IComponent e) => Leaf -> e -> Component > leafAdd s _ = Component s > instance IComponent Leaf where > draw = leafDraw > add = leafAdd The Composite type, which holds a list of Components through the composite proxy. I was tempted to make the list a state variable, so that add could modify rather than produce a new Many, but I wanted to get the basics working. > data Composite = > Many [Component] > compositeDraw :: Composite -> String > compositeDraw (Many []) = "()" > compositeDraw (Many leaves) = "(" ++ (foldr1 (++) $ map draw leaves) ++ ")" > compositeAdd :: (IComponent e) => Composite -> e -> Component > compositeAdd (Many leaves) c = > Component $ Many ((Component c) : leaves) > instance IComponent Composite where > draw = compositeDraw > add = compositeAdd >

5 6

Hi can u explain me how drop works in Haskell
by iliali16 01 Mar '07

01 Mar '07

Hi I am trying to implement the function drop in haskell the thing is that I I have been trying for some time and I came up with this code where I am trying to do recursion: drop :: Integer -> [Integer] -> [Integer] drop 0 (x:xs) = (x:xs) drop n (x:xs) |n < lList (x:xs) = dropN (n-1) xs : |otherwise = [] So I want to understand how would this work and what exacttly should I put as an answer on line 4 couse that is where I am lost. I know I might got the base case wrong as well but I don't know what to think for it. I have done the lList as a function before writing this one. Thanks to those who can help me understand this. Thanks alot in advance! Have a nice day! -- View this message in context: http://www.nabble.com/Hi-can-u-explain-me-how-drop-works-in-Haskell-tf32904… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

7 10

State monad in the wikibood article
by TJ 01 Mar '07

01 Mar '07

In the wikibook article here: http://en.wikibooks.org/wiki/Haskell/Understanding_monads, which really does an excellent job explaining things (nuclear waste woohoo!), I am stuck at the following code snippet: container >>= fn = \st -> let (a, st2) = container st container2 = fn a in container2 st2 What stumps me is that (>>=) is supposed to return a container, but if we return (container2 st2) as in the code, then what we're really returning is the contents of the container! So what would happen if we do this: nuclearWasteInContainer >>= processTheWaste >>= thoroughProcessTheWaste It seems to me that the second (>>=) in the above expression would have the arguments (nuclearWaste) and (nuclearWasteProcessor), when what it really expects are (Container nuclearWaste) and (nuclearWasteProcessor). So isn't something wrong with the definition of (>>=) above? Or am I missing something? (I know the article says that the type for their supposed State monad at that point is not actually correct, and will be clarified further on, but that seems to be irrelevant to my question.) TJ the forever noobie.

2 2

Raiding the blogosphere
by dons＠cse.unsw.edu.au 01 Mar '07

01 Mar '07

I've done a quick pass over the 100s of blog articles written in the last few months about Haskell, collecting and categorizing the best on Haskell.org: http://haskell.org/haskellwiki/Blog_articles Since it would be a real shame to not take advantage of these new tutorials. That page should serve something like the cookbook page, but for external contributions. If you have some older favourites, please add them! The list might also serve to inspire people to write about areas not yet well covered... (hint hint: more articles on parallelism, XML, building servers ... ;) -- Don

1 0

Logic programming using lazy evaluation
by Henning Thielemann 01 Mar '07

01 Mar '07

I suspect that someone has already done this: A Haskell library which solves a system of simple equations, where it is only necessary to derive a value from an equation where all but one variables are determined. Say 1+2=x -- add 1 2 x y*z=20 -- times y z 20 x+y=5 -- add x y 5 should be solved as x=3 y=2 z=10 Of course, it is easy to do this for a finite number of variables and equations by assigning integer identifiers to the variables, then scanning the equations repeatedly until all determinable variables are determined. However, imagine I have an infinite number of equations and an infinite number of variables, say 1=x0 -- equal 1 x0 2*x0=x1 -- times 2 x0 x1 2*x1=x2 -- times 2 x1 x2 2*x2=x3 -- times 2 x2 x3 ... Accessing variable values by integer identifiers means that the garbage collector cannot free values that are no longer needed. Thus I thought about how to solve the equations by lazy evaluation. Maybe it is possible to ty the knot this way let (_,_,x0) = add 1 2 x (y0,z0,_) = times y z 20 (x1,y1,_) = add x y 5 x = alternatives [x0,x1] y = alternatives [y0,y1] z = alternatives [z0] in (solve x, solve y, solve z) Independent from the question of how to implement 'alternatives' and 'solve' I wonder if there is a less cumbersome way to do this kind of logic programming in Haskell.

3 5

TFP 2007: Last Call for Participation
by TFP 2007 28 Feb '07

28 Feb '07

Dear Colleagues, The deadline to register for TFP 2007 is quickly approaching. You may register at: http://cs.shu.edu/tfp2007/registration.html . Also, please be advised that the deadline to make hotel reservations at the guaranteed rate for TFP 2007 participants is also quickly approaching. Hotel information can be found at: http://cs.shu.edu/tfp2007/accomodations.html . You may browse the program and schedule for TFP 2007 at: http://cs.shu.edu/tfp2007/schedule.html . We look forward to seeing you in NYC!!! Cheers, Marco ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0

Plotting in Haskell
by Chris Witte 28 Feb '07

28 Feb '07

Are there any good libraries for drawing plots (2D and 3D) in Haskell (under Windows using GHC)? Cheers Chris Witte

6 5

Re: overlapping instances, selecting if type a does not belong to class?
by oleg＠pobox.com 28 Feb '07

28 Feb '07

The problem you report can be fixed with some trickery and local functional dependencies. I'd like to show a different solution, which follows a useful general pattern, of isolating overlapping instances to one small part of the program that analyzes the type. The rest of the type program just uses the results of the analysis. > I wasn't able to find the definition of AllOf(But): It is in the complete code http://pobox.com/~oleg/ftp/Haskell/poly2.hs It isn't that interesting: > data AllOfBut x y {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} {-# OPTIONS -fallow-overlapping-instances #-} module HAA where import HListPrelude data HTrue data HFalse -- If two arguments are HList's, concatenate them. If only one of them -- is HList, add the other to the head. We assume at least one is an HList. class IsHList a b | a -> b instance IsHList HNil HTrue instance IsHList (HCons a b) HTrue instance TypeCast HFalse y => IsHList x y -- The are no overlapping instances below class (HList c) => HListAppendArbitrary a b c | a b -> c where hAppendArbitrary :: a -> b -> c instance (IsHList a af, IsHList b bf, HAA af bf a b c) => HListAppendArbitrary a b c where hAppendArbitrary = haa (undefined::af) (undefined::bf) class (HList c) => HAA af bf a b c | af bf a b -> c where haa :: af -> bf -> a -> b -> c -- Both are HLists instance (HList c, HAppend a b c) => HAA HTrue HTrue a b c where haa _ _ = hAppend instance HList a => HAA HTrue HFalse a b (HCons b a) where haa _ _ a b = HCons b a instance HList b => HAA HFalse HTrue a b (HCons a b) where haa _ _ a b = HCons a b -- deliberately unimplemented: at least one must be an HList... -- instance HList b => HAA HFalse HFalse a b c where test1 = hAppendArbitrary HNil True test2 = hAppendArbitrary True (HCons () HNil) test3 = hAppendArbitrary (HCons () HNil) (HCons False HNil) test4 = hAppendArbitrary (HCons () HNil) 'a' -- testf = hAppendArbitrary 'n' () -- TypeCast is skipped

1 0

What inhabits this type: (forall a. a -> b) -> (forall a. m a -> m b)
by Jacques Carette 28 Feb '07

28 Feb '07

Since my last query was answered so quickly, let's try another. I have looked on Hoogle. I would have asked Djinn, but I don't have it around. So, can someone find a term that inhabits (forall a. a -> b) -> (forall a. m a -> m b) ? I think of this as the type of functions that, given a function from any boxed-up a to a b, will give me a function from a boxed-up ma to a m b -- m does not have to be a Monad!. Jacques

5 4

Re: [Haskell-cafe] What inhabits this type: (forall a. a -> b) -> (forall a. m a -> m b)
by Bryan Burgers 28 Feb '07

28 Feb '07

> Since my last query was answered so quickly, let's try another. > > I have looked on Hoogle. I would have asked Djinn, but I don't have it > around. So, can someone find a term that inhabits > (forall a. a -> b) -> (forall a. m a -> m b) > ? I think of this as the type of functions that, given a function from > any boxed-up a to a b, will give me a function from a boxed-up ma to a m > b -- m does not have to be a Monad!. > > Jacques (Jacques, sorry you got this twice--I forgot to send it to the list.) How about this one? f g x = return $ g x Since 'g' can, by definition, take any type and return a 'b', then it should be able to take some 'm a' and return something of type 'b', which we just return. I'm not really familiar with foralls, but the two explicit foralls make the two a's different, right? (After reading the other responses, I must be wrong, but can somebody explain why?) Bryan Burgers

2 1

Re: [Haskell] [Fwd: Re: Computer Language Shootout]
by Claus Reinke 28 Feb '07

28 Feb '07

> I hoped at least to stimulate interest in repeating GP experiment with latest GHC version. until that happens, I'd be wary to draw too many conclusions for today's applications from this paper. two orders of magnitude difference would seem to imply programming problems to me (though the authors did have the problem/ excuse of lack of profiling tools). > (the experiment: > http://www.dcs.ed.ac.uk/home/stg/sfpw/book/Garmendia-Doval/cameraready.ps) not only is it old (ghc-4.08), it doesn't show much code, and what it shows, looks suspiciously like a case of ML-mindset programming in Haskell (the kind that people get help with on the various Haskell lists nearly every day, nowadays). according to 3.5, the Haskell version came first, was used for experiments, and errors in design were corrected, then came the ML version, which was at this point already substantially faster (from which i would be tempted to conclude that the coding style was a better fit for ML than for Haskell; cf also 3.5.1, third para). the ML version was then profiled and improved, after which these improvements were backported from the ML to the Haskell version! okay, profiling was not available for the Haskell version back then, but using ML profiling to improve a Haskell version sounds highly dangerous to me, even more so if the authors do not even mention any awareness of this danger. in 3.5.1, we see Alleles as a BoolVector, which sounds fine until we see it converted to its list of associations, which is then foldl-ed (!) over with a non-strict function (good that those chromosome lengths appear to be only 60..), for every evaluation. this is the main evaluation function for fitness, so it should be very much inner loop, with population sizes and generations ranging to 7500/700 and 50/150000. . of course, the same function in the ML version just means running a loop over a vector, with a strict accumulator.. that is just the code shown in the paper - and it is the only piece of code, apart from structure declarations. perhaps inlining and strictness analysis caught this particular problem, and perhaps calling out to C for random numbers didn't slow down the program, either - the paper just doesn't give enough information to tell. "So far, we have found the Standard ML version to out-perform the Haskell version by over two orders of magnitude. Despite extensive study of the Haskell version, no clear reason has emerged for this poor performance." note that they do not say "any Haskell version would have to be slow because of..", they say they don't know. well, enough of this fud!-) i hope it is fair to say that not just todays compilers are different, but also the user communities. i cannot imagine anyone experiencing this level of performance difference in a concrete application without asking questions about it on one of the Haskell lists, nor would i expect such questions to remain unanswered for long enough to merit a paper (at least not about the question; Data.ByteString shows that there are still papers to be written about answers;-). and if it is too complicated for a public discussion, the project in question could always hire Haskell expertise, in the form of consulting (although i see that most entries have disappeared from the Haskell consultants list, probably because they tend to answer questions for free on the mailing lists?-). claus

2 2

Re: [Haskell] [Fwd: Re: Computer Language Shootout]
by Andrzej Jaworski 28 Feb '07

28 Feb '07

On 2/26/07, Kirsten Chevalier honored me with his attention: >Can you clarify what you mean by this? How do you formally prove that >a programming language (rather than a specific implementation of one) >performs better for a given problem? (..) It is about my saying:"SML was exhaustively proved to predict this logic much better." Formal proof requires a theory. So you might use Copernicus model to formally prove that Australia is on the other side of Earth against Europe. Exhaustive prove might require you to dig a very deep hole in the ground;-) In case of proving softspots of Haskell, a couple of very knowledgeable people here and there dug through exhaustive set of alternatives. That's it. In case of formal proves over programming languages aspirations are limited to program correctness and probably will never address performance. (see http://unit.aist.go.jp/cvs/Agda/) Unfortunately I spend most of my time doing first kind of proofs, I am not sure how it is with you;-) >I've read a few of your posts and I still don't understand what you >mean by a compiler "address[ing] specific properties of a program". >Can you give an example of the kinds of program properties you're >talking about, and explain how C compilers exploit them in a way that >Haskell compilers currently fail to do? My posts were intentionally motivational because I wanted to get feedback on the problem. As to "address[ing] specific properties of a program". In ADP a program deals with DNA and molecular structures. Because the program is a sort of inference engine and simulator at the same time it is desirable to introduce likelihood function as low as possible to avoid blowing up search spaces when everything is constructed and reconstructed at the same time. C is low so that's it. However that is done at a cost - the routines that access the pre-calculated data are no longer identical to those that access the routines that initially calculated the data. In Prolog or Haskell they could remain the same. Have a good time, -Andrzej

1 0

Re: Trouble with record syntax and classes
by Thomas Nelson 28 Feb '07

28 Feb '07

Thank you all for your advice so far. I went back and tried to simplify my code, but I'm still stuck. The basic idea I want is something like an arbitrary tree structure, where MetaSines are the branches containing Sines, and Sines are the leaves containing strings. I want to recurse through the tree and pick up all the leaf strings, but only if that branch/leaf is "on" for that time. Here's my second attempt at the code: data ISine = Sine Integer Integer Integer String | MetaSine Integer Integer Integer [ISine] letter (Sine _ _ _ l) = l sub_sines (MetaSine _ _ _ xs) = xs period p _ _ _ = p offset _ o _ _ = o threshold _ _ t _ = t on :: Integer->ISine->Bool on time (p o t x) = (mod (time-(offset p o t x)) (period p o t x)) < (threshold p o t x) act time (MetaSine p o t s) |on time (p o t s) = foldr (++) (map (act time) (sub_sines p o t s)) |otherwise = [] act time (Sine p o t l) |on time p o t l = [letter p o t l] |otherwise = [] the on, period, offset, and threshold functions should work exactly the same for Sine and MetaSine, so I'd prefer to only write them once. But the act function needs to differentiate: for a Sine, it just returns a singleton list if on is true, or an empty list otherwise; but for a Metasine, it needs to get the list of all the strings in Sine objects in it's sub_sines field. It only does this if it's on. For example, let's say A / | \ B C D / | / | \ E F G H I If A, C, D, E, F and I are all on, only the strings of Sines C and I should be joined to make a to element list. If everything is on, C, E, F, G, H, I will all be joined. Anyway, the above code still doesn't work; there's a parse error for the definition of on. I don't think my arguments are right somehow. I appreciate your collective patience and expertise, and hope you can put me on the right track. Thomas

3 2

Declaring variance of class parameters?
by Jacques Carette 28 Feb '07

28 Feb '07

If I have a class, say class Symantics repr where int:: Int -> repr Int and so on, I would like to *require* that 'repr' be covariant. Is there any way to do that? Jacques

2 1

overlapping instances, selecting if type a does not belong to class?
by Marc Weber 28 Feb '07

28 Feb '07

I want to write a class introducing a function which should append a b resulting in a HList containing a and b (order doesn't matter) So I came up with: ============= code =================================================== class (HList c) => HListAppendArbitrary a b c | a b -> c where hAppendArbitrary :: a -> b -> c -- instance HList + HList (1) instance (HList a, HList b, HAppend a b c, HList c) => HListAppendArbitrary a b c where hAppendArbitrary a b = hAppend a b -- overlapping instance HList + value (2) instance (HList a, HList c) => HListAppendArbitrary a b c where hAppendArbitrary a b = HCons b a ============= error ================================================== hps-lib/HPS/Utils.hs|130| 0: || Duplicate instance declarations: || instance [overlap ok] (HList a, HList b, HAppend a b c, HList c) => || HListAppendArbitrary a b c -- Defined at hps-lib/HPS/Utils.hs|130| 0 || instance [overlap ok] (HList a, HList c) => || HListAppendArbitrary a b c -- Defined at hps-lib/HPS/Utils.hs|134| 0 ============= ======================================================= instance (2) should be used if b does not belong to class HList. Of course there is another opportunity by writing (HCons a x) instead of to force the first type beeing a HList... Which is the topic to read from the ghc/ haskell manual ? Marc Weber

2 3

Re: [Haskell-cafe] Trouble with record syntax and classes
by Andreas Rossberg 27 Feb '07

27 Feb '07

<ajb(a)spamcop.net> wrote: > > When you type "class Foo" in Java or C++, it does three things: > > 1. It declares a new type called "Foo". > > 2. It declares a _set_ of types (i.e. a "class"). > > 3. It declares that the type Foo (and all of its subtypes) is a member > of the set of types Foo. I would add: 4. Define a namespace, also called "Foo", for a set of values (and probably nested classes). > In Haskell, these three operations are distinct. > > 1. You declare a new type using "data" or "newtype". > > 2. You declare a new set of types using "class". > > 3. You declare that a type is a member of a class using "instance". 4. You define a new namespace using "module". Cheers, - Andreas -- Andreas Rossberg, rossberg(a)ps.uni-sb.de

1 0

Re: [Haskell] [Fwd: Re: Computer Language Shootout]
by Fawzi Mohamed 27 Feb '07

27 Feb '07

On Feb 27, 2007, at 3:51 PM, Andrzej Jaworski wrote: > [...] > Nevertheless my point is still valid: when on compiler side the > heap is > stretched and on program side you need Ockham's Razor in action > Haskell > chokes. I hoped at least to stimulate interest in repeating GP > experiment > with latest GHC version. This could make a hot publication and > save nice > people from reappearance of this thread:-) > > (the experiment: > http://www.dcs.ed.ac.uk/home/stg/sfpw/book/Garmendia-Doval/ > cameraready.ps) Thanks for the link! I had not found it. An interesting read. Indeed it would be very interesting to repeat the experiment with the actual GHC... Sincerely Fawzi

1 0

Re: [Haskell] [Fwd: Re: Computer Language Shootout]
by Fawzi Mohamed 27 Feb '07

27 Feb '07

On Feb 27, 2007, at 1:59 PM, Sven Panne wrote: > On Tuesday 27 February 2007 13:44, Andrzej Jaworski wrote: >> I have learned logic from much deeper sources;-) >> My statement was: >> Guys started in Haskell and got to conclusion that for performance >> reasons >> it is better to move to C. The guys know what they are doing. >> >> I hope that helps;-) > > Hmmm, is there any paper/blog/etc. describing exactly what the > performance > problems were? If something is too slow, usually either the language > implementor or the language user can learn something. Furthermore, > when > moving from programming language X to Y and seeing performance > improvements, > it is more often than not the case that the reason for this is not > that Y is > faster than X, but that one has learned a lot about the problem when > implementing in X. So in general you see an improvement even when X > == Y, > i.e. dump your old Haskell code and start from scratch. I could not find references for the other stuff, but for Algebraic Dynamic Programming I found this http://bibiserv.techfak.uni-bielefeld.de/adp/adplit.html and citing my previous message ;) >>> they went from an embedded haskell implementation to a direct >>> compiler implementation. >>> >>> From what I understood I believe that mis-performance in that >>> case came from the embedded nature of the DSL >>> 1) not having a specialized parsing step (making the usage more >>> difficult) >>> 2) no abstract representation of the program that could be >>> optimized with special transformations relative to the DSL >>> 3) not fully optimized kernel methods >>> >>> writing a real compiler for that language made sense, and also >>> the choice of c as language for it, but I think that it would >>> have been possible to write it in haskell without a big >>> performance hit. I haven't seen that haskell compiler >>> significantly worse than others except in really low level >>> computational code, which (with more effort than with C) can be >>> optimized so that it is not really so terribly worse. >>

1 0

Delaling with State StateT and IO in the same function
by Alfonso Acosta 27 Feb '07

27 Feb '07

Hello, I know StateT is exactly aimed at dealing with a state and an inner monad but I have an example in which I have to mix State and IO and in which I didn't get to an elegant solution using StateT. I have a higher order function which gets some State processing functions as input, makes some internal operations with IO and has to return a State as output. My (ugly) function interface is netlist :: DT.Traversable f => (State s (S HDPrimSignal) -> State s v ) -> -- new (State s (Type,v) -> S v -> State s ()) -> -- define State s (f HDPrimSignal) -> -- the graph StateT s IO () The returned type is a StateT and the only way in which I succesfully managed to internally work with both State and StateT is converting from the former to the later one using this function (not elegant at all) state2StateT :: Monad m => State s a -> StateT s m a state2StateT f = StateT (return.runState f) I tried avoiding to use state2StateT by changing the interface to netlist :: DT.Traversable f => (State s (S HDPrimSignal) -> State s v ) -> -- new (State s (Type,v) -> S v -> State s ()) -> -- define State s (f HDPrimSignal) -> -- the graph State s (IO ()) but the function ended up being even uglier and I had to be care full about all the internal IO actions being executed (it is aesy to formget about it), let me show a (quite stupid) example myState :: State () (IO ()) myState = (return $ putStrLn "first line") >> (return $ putStrLn "second line") > eval myState () second line The first line is obviously lost Here is the full code of my function (many type definitions are missing but I hope it is understandable anyway) import qualified Data.Traversable as DT (Traversable(mapM)) import qualified Control.Monad.Trans import Language.Haskell.TH(Type) netlist :: DT.Traversable f => (State s (S HDPrimSignal) -> State s v ) -> -- new (State s (Type,v) -> S v -> State s ()) -> -- define State s (f HDPrimSignal) -> -- the graph StateT s IO () -- Generates a netlist given: -- new: generates the new (and normally unique) tag of every node given -- the iteration state which is updated as well. -- define: given the tag of a node, -- current iteration state, its type, and the tag of its children, -- generates the netlist of that node, updating the iteration state -- pSignals: the graph itself, a traversable collection of root -- signals including the initial state of the iteration -- It returns the final iteration state and the tags of outputs -- (root primitivesignals) netlist new define pSignals = do f <- state2StateT pSignals tab <- lift table let -- gather :: State s HDPrimSignal -> StateT s IO v gather sm = do HDPrimSignal t node <- sm visited <- lift (find tab node) case visited of Just v -> return v Nothing -> do let sP = deref node v' <- state2StateT (new (return sP)) lift (extend tab node v') sV <- DT.mapM (gather.return) sP state2StateT (define (return (t,v')) sV) return v' in DT.mapM (gather.return) f >> return() ---- just in case it helps table :: IO (Table a b) find :: Table a b -> Ref a -> IO (Maybe b) extend :: Table a b -> Ref a -> b -> IO () ---- Maybe is asking too much but would anyone be able to provide a more elegant netlist function which ... option a) returns StateT but doesn't make use of state2StateT? or option b) returns State but doesnt end up being messy? Thanks in advance, Alfonso Acosta

3 5

Safe lists with GADT's
by oleg＠pobox.com 27 Feb '07

27 Feb '07

Stefan O'Rear wrote: > Personally I like the GADT approach best since it is very flexible and > convienient. I have never used a purpose-build computer proof system, > but (modulo _|_) it took me less than 10 minutes to answer > LoganCapaldo (on #haskell)'s challenge to proof that + was commutative > ( http://hpaste.org/522 ) I'm afraid it may be premature to call this a proof. Here's your code > data S x > data Z > > data Add :: * -> * -> * -> * where > AddZZ :: Add Z Z Z > AddS1 :: !(Add x y z) -> Add (S x) y (S z) > AddS2 :: !(Add x y z) -> Add x (S y) (S z) > > add_is_commutatative :: Add a b c -> Add b a c > add_is_commutatative (AddZZ) = AddZZ > add_is_commutatative (AddS1 a) = AddS2 (add_is_commutatative a) > add_is_commutatative (AddS2 a) = AddS1 (add_is_commutatative a) First of all, where is the coverage proof? Given two numbers, S (S Z) and S Z, how to find their sum using the above code? Someone needs to construct the sequence of Adds, _at run-time_! But where is the proof that the sequence of Add applications expresses all possible ways of computing the sum, and each possible sum can be represented as a sequence of Adds? One may say -- this is so trivial; to which I reply that the original question was trivial as well. If we talk about the formal _proof_, then let's do it rigorously and formally all the way. Also, we can write > main = let x = AddS1 (undefined::Add Z Z (S Z)) in print "OK" > main2 = let x = add_is_commutatative (undefined::Add Z Z (S Z)) in print "OK" and the evaluation of 'main' and main2 prints OK. Thus we need to do forcing _all_ the way. But what if we forget some forcing? Incidentally, this is exactly what happened: add_is_commutatative should have been strict. But the code above misses the strictness annotation and still it compiles and seems to work -- and gives one a reason to call it a proof despite the deficiency. I'm afraid I have little trust in the system that permits such lapses. > but (modulo _|_) That is quite an unsatisfactory disclaimer! From the CH point of view, Haskell is inconsistent as every type is populated. Showing that a function is total is precisely demonstrating that the function is the proof of its type. So, showing the absence of bottoms is precisely making the proof! The problem with GADTs and other run-time based evidence is just that: _run-time_ based evidence and pattern-matching. In a non-strict system, checking that the evidence is really present is the problem on and of itself. BTW, Omega, Dependent ML and a few other systems with GADTs are strict.

3 2

problems installing ghc 6.6 with extralibs (bad interface file)
by Thomas Hartman 27 Feb '07

27 Feb '07

I installed ghc 6.6 from source ok. But then when I tried installing it with the "extralibs" to get all the functionality that had been unbundled in 6.6, I hit a glitch. Anyone ever seen anything like this? In case it matters, this is ssh-ed in to a virtualized user mode linux session. ***************************************** thartman@linodewhyou:~/haskellInstalls$ cat install-ghc-6.6.sh if [ ! -f ghc-6.6-src.tar.bz2 ]; then wget http://www.haskell.org/ghc/dist/6.6/ghc-6.6-src.tar.bz2 fi if [ ! -f ghc-6.6-src-extralibs.tar.bz2 ]; then wget http://www.haskell.org/ghc/dist/6.6/ghc-6.6-src-extralibs.tar.bz2 fi tar -tvjf ghc-6.6-src.tar.bz2 tar -tvjf ghc-6.6-src-extralibs.tar.bz2 pushd ghc-6.6 ./configure make make install popd thartman@linodewhyou:~/haskellInstalls$ sudo ./install-ghc-6.6.sh 2>&1 | tee out.txt thartman@linodewhyou:~/haskellInstalls$ tail -n20 out.txt ------------------------------------------------------------------------ make[2]: Nothing to be done for `install'. ------------------------------------------------------------------------ == make install - --no-print-directory -r; in /home/thartman/haskellInstalls/ghc-6.6/utils/ghc-pkg ------------------------------------------------------------------------ Creating a symbolic link from ghc-pkg-6.6 to ghc-pkg in /usr/local/bin for i in ghc-pkg-6.6; do \ /usr/bin/install -c -m 755 $i /usr/local/bin; \ done /usr/local/bin/ghc -H16m -O -cpp -Wall -fno-warn-name-shadowing -fno-warn-unused-matches -i../../compat -ignore-package Cabal -Rghc-timing -c Main.hs -o Main.o -ohi Main.hi Main.hs:19:0: Bad interface file: ../../compat/Distribution/InstalledPackageInfo.hi mismatched interface file versions: expected 6060, found 6 <<ghc: 24591324 bytes, 4 GCs, 106128/106128 avg/max bytes residency (1 samples), 16M in use, 0.00 INIT (0.02 elapsed), 0.25 MUT (0.42 elapsed), 0.10 GC (0.12 elapsed) :ghc>> make[2]: *** [Main.o] Error 1 make[1]: *** [install] Error 1 make: *** [install] Error 1 ~/haskellInstalls thartman@linodewhyou:~/haskellInstalls$

2 1

Re: Re: [Haskell-cafe] Build failed - hidden package ?
by Dunric 27 Feb '07

27 Feb '07

Yes, that did the trick. Thank You. >-----Puvodni zprava----- >Od: J. Garrett Morris [mailto:trevion@gmail.com] >Komu: Dunric <dunric29a(a)atlas.cz> >Předmět: Re: [Haskell-cafe] Build failed - hidden package ? > > >Hello, > >Are you building with Cabal? In case you are, Cabal hides all >packages by default and only shows those which are mentioned in your >cabal file. To fix this, you can add 'base' to the build-depends: >list. > >If you're not using Cabal, I don't have a clue. (-; > >Good luck! > >/g > >On 2/26/07, Dunric <dunric29a(a)atlas.cz> wrote: >> Hi. >> I've got stuck with the following compilation error I probably can't fully understand: >> >> ---------------------------------------------------------------------- >> Building library... >> ... >> Using package config file: /usr/local/lib/ghc-6.6/package.conf >> wired-in package base mapped to base-2.0 >> wired-in package rts mapped to rts-1.0 >> wired-in package haskell98 mapped to haskell98-1.0 >> wired-in package template-haskell mapped to template-haskell-2.0 >> Hsc static flags: -static >> ... >> Graphics/UI/SDL/Rotozoomer.hs:15:7: >> Could not find module `Foreign.C': >> it is a member of package base, which is hidden >> >> ---------------------------------------------------------------------- >> >> What does such error mean ? >> >> Modules Foreign and Foreign.C are installed and available from the default path. >> Lines 12-15 of Rotozoomer.hs: >> ------------------------------------------ >> module Graphics.UI.SDL.Rotozoomer where >> >> import Foreign >> import Foreign.C >> ------------------------------------------ >> >> Any idea what's wrong, resp. some explanation why compilation fails ? >> >> Thanks in an advance. >> >> ------------------------------------------ >> >> www.icqsms.cz >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >> > > >-- >It is myself I have never met, whose face is pasted on the underside of my mind. ------------------------------------------ www.icqsms.cz

1 0

rebinding >>= for restricted monads
by David Roundy 27 Feb '07

27 Feb '07

Hello fellow haskellers, I am wondering if anyone has an idea whether I'd run into trouble if I rebound >>= in order to provide a more restricted monad. My idea is to define a class: class WitnessMonad wm where (>>=) :: wm w w' a -> (a -> wm w' w'' b) -> wm w w'' b (>>) :: wm w w' a -> wm w' w'' b -> wm w w'' b return :: a -> wm w w' a fail :: String -> wm w w' a which obviously just adds a couple of phantom types indicating the monad state prior to and after each operation. I actually rather like this redefined monad, as it seems like it'd be useful in lots of places (e.g. a restricted IO monad that disallows use of a file handle after it's closed). It seems to me like this would be a pretty cool kind of monad. It'd allow us to encode typechecked "properties" in a monad, and there'd be very little restriction on how tricky those properties could be. And we'd get this all using the same do syntax we all love (and the new properties are by definition sequential, so a monad is precisely what we want, only at the type level). One trouble I see is how to move an ordinary monad into the WitnessMonad class. Of course, they differ in kind, so we need to do something, but I'm not sure what, and suspect that folks with experience using monad transformers will immediately see the answer. Of course, I want to be able to use both my fancy witnessed monad and IO in the same module, and I want to be able to use do notation for both of them. I suppose we could easily define data M m w w' c = M (m c) lift = M lower (M m) = m instance WitnessMonad (M m) where f >>= g = lift $ Prelude.(>>=) (lower f) (lower . g) ... but then we'd have to lift all our operations, so an ordinary IO function in a module that used my fancy rebound do notation would look like f :: IO Char f = lower $ do lift $ putStr "Hello world" lift $ getChar which seems rather heavy. Can anyone think of syntax-light way to allow my hypothesized rebound do-notation to also work with ordinary monads? -- David Roundy Department of Physics Oregon State University

10 17

FFI basics
by Yitzchak Gale 27 Feb '07

27 Feb '07

Hi, I would like to use FFI for the first time. Can someone give me a really, really simple complete example? I want to be able to take a simple C program and access a function from it in Haskell. A simple example of the other way around would be nice, too, but I don't happen to need that just now. I started reading the Addendum, but that looks like it would be a lot easier to read if I saw a simple complete example first. Everything I found on the wiki seems way beyond that - maybe I missed it. I am using GHC. I am not using Windows. Thanks, Yitz

10 16

Splitting Hairs Over Terminology
by P. R. Stanley 27 Feb '07

27 Feb '07

Hi folks in C and C++ world the humble comma is an operator. Is this also the case in Haskell or, is it classed as a function? In the wikibook they talk about consing new elements onto a list. Does this cons stand for anything meaningful in the English language? For example, is it short for construction or something similar? I'm assuming that the ":" function takes two arguments and returns a newly constructed list which is assigned to the variable holding/pointing to the old list. Cheers Paul

4 6

OO Design in Haskell Example (Draft)
by oleg＠pobox.com 27 Feb '07

27 Feb '07

Steve Downey wrote: > In the last OO design in Haskell thread (and probably in every one > preceeding it), it was suggested that having some examples might be a good > idea. > > Since most people with existing designs will have some familiarity with > Design Patterns, and those are typical building blocks for OO designs, it > occured to me that implementing some of them might be a useful > excersize. Have you looked at OOHaskell? http://homepages.cwi.nl/~ralf/OOHaskell/ http://darcs.haskell.org/OOHaskell/ With the exception of pure-functional objects and binary methods, I think we have considered almost every OO pattern/idiom we could find, including nominal/structural subtyping, co- and contra-variance, self-typing, etc. The DARCS repository contains the complete code for all of the examples and patterns. To clarify, the point of OOHaskell is to use Haskell as a tool, laboratory bench, for exploring various (thorny) OO issues.

2 1

Trouble with record syntax and classes
by Thomas Nelson 27 Feb '07

27 Feb '07

I'm brand new to haskell and I'm having trouble using classes. The basic idea is I want two classes, Sine and MetaSine, that are both instances of ISine. This way I can use the act method and recurse through the metasines and sines. Here's my code: module Main where class ISine a where period :: a -> Integer offset :: a -> Integer threshold :: a -> Integer act :: (ISine b) => Integer -> a -> b on :: Integer -> a -> Bool --on needs offset, period, threshold on time self = (mod (time-(offset self)) (period self)) < (threshold self) data Sine = Sine { period :: Integer, offset :: Integer, threshold :: Integer, letter :: String } instance Sine ISine where act time (Sine self) |on time self = [letter self] |otherwise = [] data MetaSine = MetaSine { period :: Integer, offset :: Integer, threshold :: Integer, sines :: (ISine a) => [a] } instance MetaSine ISine where act time (MetaSine self) |on time self = foldr (++) (map (act time) (sines self)) |otherwise = [] The errors I get involve multiple declarations of period, offset, and threshold. Any help would be greatly appreciated. -Thomas

6 6

Re: [Haskell-cafe] State of OOP in Haskell
by dons＠cse.unsw.edu.au 27 Feb '07

27 Feb '07

deliverable: > Well, I'm thinking in terms of OOD/OOA/OOP -- Design, Architecture, > Programming. That's about the only way to model a bog system. Say I > have a stock market model -- I'll have a database of tickers, a > simulator to backtest things, a trading strategy, etc. > > Do Haskell modules provide enough encapsulation to design a system in > terms of them? What are the design/architecture units in Haskell if > not OO-based? Haskell's pretty big on encapsulation (we like our strong statically checked guarantees after all) Some of the encapsulation mechanisms used in large (>5k loc up to 100k + Haskell programs I've hacked on): modules qualified modules type classes to specify generic interfaces existential types to hide implementations completely (and statically) existentials using typeclasses to package the interface monads for state/effect encapsulation abstract data types data types with smart constructors first class modules via existentials purity laziness So the same kind of encapsulation as OO stuff provides (existentials are essentially OO objects), and a few more besides. Monads in particular are perfect for encapsulating interesting effects, and having that encapsulation statically enforced. Probably some of the OO refugees can think of other mechanisms. Cheers, Don

4 4

Safe lists with GADT's
by Neil Mitchell 27 Feb '07

27 Feb '07

Hi I'm starting to play with GADT's, and I was trying to write a safe version of head and tail, on a safe version of lists. What I came up with is: > data ConsT a > data NilT > > data List a t where > Cons :: a -> List a b -> List a (ConsT b) > Nil :: List a NilT > > instance Show a => Show (List a t) where > show (Cons a b) = show a ++ ":" ++ show b > show Nil = "[]" > > safeHead :: List a (ConsT t) -> a > safeHead (Cons a b) = a > > safeTail :: List a (ConsT t) -> List a t > safeTail (Cons a b) = b > > safeMap :: (a -> b) -> List a t -> List b t > safeMap f Nil = Nil > safeMap f (Cons a b) = Cons (f a) (safeMap f b) Defining safeMap was trivial, but one thing I couldn't figure out was how to write something like fromList: fromList [] = Nil fromList (a:as) = Cons a (fromList as) fromList could obviously be anything such as reading from a file etc, where the input is not known in advance. Are there any techniques for this? In addition I was expecting to find some example like this in one of the papers/examples on GADT's, but I didn't. The Haskell wikibook has a slight example along these lines, but not with the recursive field in ConsT. [http://en.wikibooks.org/wiki/Haskell/GADT] Any help or hints would be appreciated, Thanks Neil

7 11

Re: [Haskell] [Fwd: Re: Computer Language Shootout]
by Kirsten Chevalier 27 Feb '07

27 Feb '07

[redirecting to haskell-cafe, since this is getting to be a long discussion] On 2/26/07, Andrzej Jaworski <himself(a)poczta.nom.pl> wrote: > The examples I pointed to seem to share strong and relatively consistent > logic of a program. In case of large GA (e.g. Royal Road Problem) and IFP > (e.g. ADATE) SML was exhaustively proved to predict this logic much better. > Can you clarify what you mean by this? How do you formally prove that a programming language (rather than a specific implementation of one) performs better for a given problem? Or do you mean that a specific implementation of this problem in SML performed better than a specific implementation of it in Haskell? > In case of Algebraic Dynamic Programming C compiler seems to address > specific properties of a program more adequately which leads to substantial > improvements in optimization. It is important to stress that we deal in ADP > with strong logic of the domain application. Handcrafting C code for regular > applications does not show that kind of advantage, so it wouldn't leave > Haskell in the dust. In general declarative nature has the edge over C > craftsmanship (see: > http://www.clip.dia.fi.upm.es/papers/carro06:stream-interpreter-TR.pdf) > I've read a few of your posts and I still don't understand what you mean by a compiler "address[ing] specific properties of a program". Can you give an example of the kinds of program properties you're talking about, and explain how C compilers exploit them in a way that Haskell compilers currently fail to do? Cheers, Kirsten -- Kirsten Chevalier* chevalier(a)alum.wellesley.edu *Often in error, never in doubt "Religion is just a fancy word for the Stockholm Syndrome." -- lj user="pure_agnostic"

1 0

Links in Haskell code in HaskellWiki
by Henk-Jan van Tuyl 27 Feb '07

27 Feb '07

L.S., Links in the Haskell code in the wiki pages point to wrong labels; for example, if 'print' is used, it is linked to: http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:print the colon should be "%3A": http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3Apri… For '==', the link is: http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:== it should be: http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3A%3D… (see for example http://haskell.org/haskellwiki/OOP_vs_type_classes ) Can someone correct this? -- Met vriendelijke groet, Henk-Jan van Tuyl -- http://Van.Tuyl.eu/ -- Using Opera's revolutionary e-mail client: https://secure.bmtmicro.com/opera/buy-opera.html?AID=789433

1 0

reed-solomon or other ECC codes
by Bulat Ziganshin 27 Feb '07

27 Feb '07

Hello haskell-cafe, is there a haskell library for any ECC codes? -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0

Did quickchekc get dropped from ghc from 6.4 to 6.6?
by Thomas Hartman 27 Feb '07

27 Feb '07

According to http://www.cs.chalmers.se/~rjmh/QuickCheck/ Quickcheck is distributed with ghc. I seem to recall this came with ghc 6.4. After upgrading to ghc 6.6, however, I don't seem to have it anymore. Do I need to install it from cabal? If so, I assume this would start by wgetting http://hackage.haskell.org/packages/archive/QuickCheck/QuickCheck-1.0.tar.gz and building that. thomas. thartman@linodewhyou:~/learning/haskell/lists$ ghci ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. Prelude> :m Control.Monad Prelude Control.Monad> :m Test.QuickCheck Could not find module `Test.QuickCheck': Use -v to see a list of the files searched for. Prelude Control.Monad> :m Quickcheck Could not find module `Quickcheck': Use -v to see a list of the files searched for. Prelude Control.Monad>

4 3

R wrapper in haskell
by Peng Zhang 27 Feb '07

27 Feb '07

Hi folks, My primary language is R, which is an imperative functional language. I start to learn haskell and try to use it instead when a project is time-consuming and it takes months in R. I like the language very much so far, but I do miss some important functions in R which can generate random numbers from all kinds of distributions. R provides a standalone library in c which contains all these functions and I try to write a wrapper for haskell. Since I am very new to haskell, I want to hear some suggestions to confirm that I am on the right track. The functions are the following: void set_seed(unsigned int, unsigned int); void get_seed(unsigned int *, unsigned int *); they can set or get seed for random number generator. For any distribution, we have four functions for it -- Normal distribution double dnorm4(double x, double mu, double sigma, int give_log) double pnorm5(double x, double mu, double sigma, int lower_tail,int log_p) double qnorm5(double p, double mu, double sigma, int lower_tail, int log_p) double rnorm(double mu, double sigma) where dnorm calculates density, pnorm calculates p-value, qnorm calculates quantile, and rnorm generates normal random variables. dnorm, pnorm, qnorm are easy since they don't have side-effect. I think I can just use the following: foreign import ccall "dnorm4" dnorm :: Double -> Double -> Double-> Int -> Double foreign import ccall "pnorm5" pnorm :: Double -> Double -> Double-> Int -> Int -> Double foreign import ccall "qnorm5" qnorm :: Double -> Double -> Double-> Int -> Int -> Double (Should I use CDouble or CInt here?) But for rnorm, if I use "foreign import ccall rnorm :: Double -> Double -> IO Double", then my main function should carry IO monad all the time. Maybe the better way is that I should "encapsulate" it into a state monad rng -> (rng, randomnumber). Therefore for rnorm, I should first write a wrapper in c like seed2 rnorm_wrapper(seed1, parameters){ set_seed(seed1); rnorm(parameters); get_seed(seed2); } and then write another wrapper for rnorm_wrapper in haskell. Can somebody tell me if this is the right approach? Thank you! Best, Peng

3 3

haskell-art mailing list
by alex 26 Feb '07

26 Feb '07

Hi all, After a bit of discussion with Rohan Drape I've made a mailing list for inclusive discussion of 'artistic' uses of Haskell. The initial thought for it to be about Haskell sound and music in particular, but we decided to broaden it to include visual, robotic and related work as well. [Right now I'm seeing Haskell itself and all code written in it as high art, but I suppose this list is for discussion of Haskell code that outputs art as well.] If you'd like to join the list please visit this site: http://lists.lurk.org/mailman/listinfo/haskell-art Let me know if you have any problems subscribing. If it proves a popular and/or useful list, perhaps it could be moved to haskell.org in the future. alex

3 2

How you can help improve Haskell implementations!
by dons＠cse.unsw.edu.au 26 Feb '07

26 Feb '07

Just a quick note to say that the Haskell implementation shootout is progressing, now supporting jhc, fixing a range of bugs, and providing more benchmark programs. Nice average numbers are also reported for the relative performance of each compiler or interpreter. On x86: http://www.cse.unsw.edu.au/~dons/nobench/i686/results.html On amd64: http://www.cse.unsw.edu.au/~dons/nobench/x86_64/results.html Several bugs in our beloved Haskell compilers have been spotted, and most of them already fixed! ** I'd like to invite contributions of benchmark programs**. If you have a nice benchmarky program, that's reasonably portable (mostly h98 + base libs is ok), and freely licensed, let me know, and we can add it to the benchmark suite. Programs that show up interesting results between systems or that were difficult to get to perform well are particuarly welcome. 3 kinds of programs are welcome: * small artificial programs that illustrate particular issues e.g. (prime sieves, FFT, great language shootout programs) * 'kernels' from larger programs, that illustrate some functionality e.g. a mandelbrot generator, or some other core algorithm * larger real programs. These are particularly welcome. Limited to around 25 modules maximum, and capable of being run with simple stdin/args, producing simple output. Raytracers, chess programs, and small theorem provers are existing examples. So send me your unwashed code. Whatever code doesn't kill them will only make our compilers stronger! :-) The darcs repo for nobench/nofib is at: http://www.cse.unsw.edu.au/~dons/nobench.html Happy hacking! Don

3 3

A "real" Haskell Cookbook
by Martin Bishop 26 Feb '07

26 Feb '07

I made a preliminary page, and fleshed out some of the headers/sub-headers on the wiki page for a good Haskell Cookbook (aka NOT a PLEAC clone). Please contribute and/or fix the examples and explanations so we can make a really nice Cookbook for newbies. :) http://haskell.org/haskellwiki/Cookbook

9 13

Memoisation
by Tony Morris 26 Feb '07

26 Feb '07

I have a backtracking algorithm that I need to memoise with. Rather than go into the intricacies of the algorithm, I figure (and hope) the factorial function is trivial enough to point out my problem. Simply, suppose I wish to calculate the factorial of 10, then "later" the factorial of 5. I have already calculated the factorial of 5, but now I must do it again. I have thought of various ways of preventing this; perhaps passing an Array in a state monad. I'm wondering if there is a general solution for this kind of problem. Thanks for any tips. -- Tony Morris http://tmorris.net/

3 2

How to build a python module using Haskell?
by Albert Lee 26 Feb '07

26 Feb '07

I have found some docs about build Windows DLL using Haskell and then using ctypes from python. But how to do this on Linux/FreeBSD ?

2 1

Illegal polymorphic or qualified type: forall l.
by Marc Weber 25 Feb '07

25 Feb '07

how can i fix this? Mmmh I really need some haskell type class traingings ;) ============= test file ============================================== module Main where import HList import HOccurs import Control.Monad.Reader class Get a b where get :: a -> b data D1 = D1 Int -- dummy type type ActionMonad a l = forall l. (HOccurs D1 l) => ( ReaderT l IO a ) data CR = CR (ActionMonad Bool ()) instance Get CR (ActionMonad Bool ()) where get (CR a) = a main = do print "test" ============= error ================================================== || [1 of 1] Compiling Main ( uqt.hs, uqt.o ) || uqt.hs|16| 0: || Illegal polymorphic or qualified type: forall l. || (HOccurs D1 l) => || ReaderT l IO Bool || In the instance declaration for `Get CR (ActionMonad Bool ())' ====================================================================== Marc

2 2

newbie question about denotational semantics
by Alexander Vodomerov 25 Feb '07

25 Feb '07

Hi all! I'm just started learning denotational semantics and have a simple question. Suppose, we have simple language L (e.g. some form of lambda-calculus) and have a semantic function: E : Term_L -> Value. Now, suppose, we extended our language with some additional side-effects (e.g. state or continuations). For this purpose we first add new syntactic construct to language (e.g 'call/cc'), and then write semantic via monadic approach. We have: L_ext = L + 'call/cc' E_ext : Term_{L_ext} -> M (Value), where M is some monad (Cont Value for our case). Now, I want to proof statement that original and extended semantics are coincide on expressions that don't use new constructs (call/cc). It would be natural to formulate such "theorem": "Theorem". If t is expression, that doesn't use new construct, then E_orig(t) = E_ext(t). Alas, this equation doesn't make any sense, because E_orig(t) and E_ext(t) are elements of different domains: Value and M(Value). The obvious "fix" it to use "unit" operation of monad ("return" in Haskell syntax) to put both values into the same space. So we get: "Theorem" (second try). For all t, bla-bla-bla.. unit_M(E_orig(t)) = E_ext(t). However, this still doesn't work because Values are in fact different: -- in original semantic we have (more source code available below) data Value1 = Number Int | Func (Value1 -> Value1) -- in extended semantic we have data Value2 = Number Int | Func (Value2 -> M Value2) ^ note this M The monad M seems to be "wired in" recursively in Value definition. >From the mathematical point of view it is common to use projection or injection when one need to compare functions to different sets. However, I don't see any obvious injection Value1 -> Value2 or projection Value2 -> Value1. Some monads can be "removed", for example StateT can be eliminated with runState with initial state and etc. However, some monads, for example Error, Maybe, non-deteminism monad (powerdomain) don't have such "removal function". What is needed is general definition that can be used for _any_ monad M. The question is: how can this "theorem" be formulated (and prooved) in mathematically precise way? It seems that I missing something very trivial, so just reference to article will be nice. The more general question is: suppose original language already has side-effects and was described using monad M_1. Now we add additional effects and use bigger monad M_2. The same question arises: how one can compare elements in Value domain defined via M_1 and M_2? With best regards, Alexander. PS. Some code I played with: -- original semantic import Control.Monad.Reader import Control.Monad.State import qualified Data.Map as Map type Id = String type Env = Map.Map String Value stdops :: Map.Map String (Int -> Int -> Int) stdops = Map.fromList [("+", (+)), ("-", (-)), ("*", (*))] data Expr = Const Int | Var String | BinOp String Expr Expr | Lambda Id Expr | Appl Expr Expr deriving Show data Value = Number Int | Func (Value -> Value) instance Show Value where show (Number v) = show v show (Func _) = "*func*" eval :: Expr -> Reader Env Value eval (Const c) = return (Number c) eval (Var i) = do env <- ask return $ env Map.! i eval (BinOp op x y) = do vx <- eval x vy <- eval y let opfun = stdops Map.! op case (vx, vy) of (Number a, Number b) -> return $ Number (opfun a b) _ -> error "standard operation on not-numbers" eval (Lambda i expr) = do env <- ask let f = \v -> let newenv = Map.insert i v env in runReader (eval expr) newenv return (Func f) eval (Appl fun arg) = do vfun <- eval fun varg <- eval arg case vfun of Func f -> return $ f varg _ -> error "application of not-function" do_eval :: Expr -> Value do_eval expr = runReader (eval expr) Map.empty -- extended semanic import Control.Monad.Reader import Control.Monad.Cont import qualified Data.Map as Map type Id = String type Env = Map.Map String Value type M = Cont Value stdops :: Map.Map String (Int -> Int -> Int) stdops = Map.fromList [("+", (+)), ("-", (-)), ("*", (*))] data Expr = Const Int | Var String | BinOp String Expr Expr | Lambda Id Expr | Appl Expr Expr | CallCC Expr deriving Show data Value = Number Int | Func (Value -> M Value) instance Show Value where show (Number v) = show v show (Func _) = "*func*" eval :: Expr -> ReaderT Env M Value eval (Const c) = return (Number c) eval (Var i) = do env <- ask return $ env Map.! i eval (BinOp op x y) = do vx <- eval x vy <- eval y let opfun = stdops Map.! op case (vx, vy) of (Number a, Number b) -> return $ Number (opfun a b) _ -> error "standard operation on not-numbers" eval (Lambda i expr) = do env <- ask let f = \v -> let newenv = Map.insert i v env in runReaderT (eval expr) newenv return (Func f) eval (Appl fun arg) = do vfun <- eval fun varg <- eval arg case vfun of Func f -> lift $ f varg _ -> error "application of not-function" eval (CallCC expr) = do f <- eval expr case f of Func vf -> lift $ callCC (\k -> vf (Func k)) _ -> error "call/cc with not-function" do_eval :: Expr -> Value do_eval expr = runCont (runReaderT (eval expr) Map.empty) id

3 3

How to build a generic spreadsheet?
by Greg Fitzgerald 25 Feb '07

25 Feb '07

I want to write a program where a user would update a bunch of variables, and everything that depends on those variables (and nothing else) are recalculated. Basically, a spreadsheet, but generalized for any computation. Could someone recommend an elegant way to do it or some good reading material? Thanks, Greg

6 8

Need help of explanation possible!!! Pls
by iliali16 25 Feb '07

25 Feb '07

Hi I am abit new to this language though I manage to study it very fast and understand it well. I have some tutorials to do inorder to practice it. The thing is I want to declear some functions but to do that I need to understand how exactly "take" works in hugs. Couse I want to build a similar function but I don't know how I will continue: this is where I reach take :: Integer -> [Integer] -> [Integer] take _ [] = [] take n xs |x < lenghtList xs = (take (n-1) xs :[]) |otherwise = xs I have decleared lenghtList before. I am not going to discuse lenght now couse it is easy and not for the scope of what I need. I know that what I did up there is completly wrong but that is what I came out while trying to understand how would the interpreter read and implement this. If you have any ideas how this function works please explain me I would be very greatfull.I have to do a similar one but to do it I have to understand this one. If u try it in hugs u will realise it is an allready decleared function but what I need is to understand how it works.What it must do is to get a num and a list and to display the elements of the list till the nth element which is the number we have given.if the list is smaller in lenght then the given num we return the whole list. Thanks in advance to all the folks who do help me please :(( ! -- View this message in context: http://www.nabble.com/Need-help-of-explanation-possible%21%21%21-Pls-tf3282… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

2 1

Embedding ghc
by Brian Smith 25 Feb '07

25 Feb '07

"If you have to ask, you can't afford it." :) The GHC API is not modular--if you use it, then the entirety of GHC is included into your program. That means that your executable will increase by the size of ghc.exe. Furthermore, you will also need to ship several of the supporting executables, alongside the result. Basically, using the GHC API is going to add nearly the entire size of the full GHC distribution to your application. On Windows, If you don't use via-C code generation, then you might be able to cut out some parts of the embedded GCC distribution (libraries, etc.) I once looked at modularizing GHC so that parts like the bytecode interpreter, via-C compilation, template haskell, and compilation to/from external core could be removed to reduce the size of the program. However, it is non-trivial to do this, and I didn't want to maintain a branch of GHC with these parts factored out. it would be better to come up with a proposal that the GHC maintainers will accept for the mainline, and then implement it, if you want a modular GHC. I would like to do so but currently I am busy on other projects. - Brian On 2/10/07, Joel Reymont <joelr1(a)gmail.com> wrote: > > Has anyone tried embedding ghc into their app? > > How big are the resulting binaries? > > Thanks, Joel > > -- > http://wagerlabs.com/ > > > > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

2 1

Extracting structured data in XML into records
by Johan Tibell 24 Feb '07

24 Feb '07

Hi! I'm trying to extract HCards (http://microformats.org/wiki/hcard) from HTML documents. HCard is a microformat. Microformats is an attempt to add semantic information to XML documents without adding any new tags. This is done by adding semantic information in class attributes instead (see the 'testXml' string below). I'm trying to find a good way to extract HCards into Haskell records. To do this I need to map XML elements with certain attribute values onto record fields. Some of the elements are optional in the XML and I represent that using Maybe fields in my record. The order of the elements is not guaranteed only the way they are nested. This makes it more difficult to first extract the fields I want into a list of Strings and then map that onto my record since I need to tag each string with the value it represents. So my question is. How can I write the function 'extractElementsIntoRecords' below. Or, perhaps HXT is the wrong tool for the job and I should be trying to walk the DOM tree instead? > module HCard where > > import Text.XML.HXT.Arrow > > data HCard = HCard > { > familyName :: String, > givenName :: String > org :: Maybe String > url :: Maybe String > } deriving Show > > parseHCards xml = runX $ parseXml xml > > parseXml xml = > readString [(a_parse_html, v_1)] xml >>> > deep (hasClassName "vcard") >>> > extractElementsIntoRecords > > extractElementsIntoRecords = undefined > > hasClassName s = hasAttrValue "class" (elem s . words) > > testXml = > "<div class=\"vcard red\">" ++ > " <a class=\"url\" href=\"http://tantek.com/\">" ++ > " <span class=\"n\" style=\"display:none\">" ++ > " <span class=\"family-name\">Çelik</span>" ++ > " <span class=\"given-name\">Tantek</span>" ++ > " </span>" ++ > " <span class=\"fn\">Tantek Çelik</span>" ++ > " </a>" ++ > " <div class=\"org\">" ++ > " <span class=\"organization-name\">Technorati</span>" ++ > " </div>" ++ > "</div>" > > main = parseHCards textXml Cheers, Johan Tibell

2 1

Re: Code and Perf. Data for Prime Finders
by oleg＠pobox.com 24 Feb '07

24 Feb '07

Perhaps you might want include in your test the following: http://www.haskell.org/pipermail/haskell-cafe/2007-February/022437.html It seems quite close to the genuine Eratosthenes sieve algorithm: it employs the idea of marks, it can cross composite numbers off several times, and it never tries to divide or examine prime numbers. In fact, the algorithm doesn't even use the full division or full comparison (let alone other arithmetic operations).

1 0