- Haskell-Cafe - Haskell.org

The History of Haskell
by Simon Peyton-Jones 20 Jul '06

20 Jul '06

Friends, Phil Wadler, John Hughes, Paul Hudak and I have been writing a paper about the The History of Haskell We've submitted an earlier draft to the History Of Programming Languages conference (HOPL'07), and it's been accepted. We have to submit a more-or-less final draft by 1 September. This message is to invite you to read it, tell us what you think, and help us improve it. Here it is, along with a Wiki page for you to write comments: http://haskell.org/haskellwiki/History_of_Haskell Enjoy! Simon PS: If you followed a link earlier today, and have a version dated Feb, discard it. The one you want is dated July 14th.

4 3

REALLY simple STRef examples
by tpledger＠ihug.co.nz 19 Jul '06

19 Jul '06

Chad Scherrer wrote: > x = runST $ return 1 > > y = runST $ do {r <- newSTRef 1; readSTRef r} > > Neither of these works in ghci x = runST (return 1) y = runST (do {r <- newSTRef 1; readSTRef r}) The escaping s is something to do with rank 2 polymorphism. (Search for "rank" in the ghc user guide, for example.) The hassle is that runST must always be applied to an argument (e.g. not passed to ($)), and a benefit is that you're protected from using an STRef you created in the context of one runST, in the context of another runST. Regards, Tom

1 0

trace function
by tpledger＠ihug.co.nz 19 Jul '06

19 Jul '06

Alexander Vodomerov wrote: > import Debug.Trace > > main = do > putStrLn "xxx" > return (trace "yyy" ()) > putStrLn "zzz" > > only xxx and zzz is displayed. yyy is missing. > Why trace is not working? Nothing uses the value of (trace "yyy" ()), so it is never evaluated. Try this instead, which uses the value for a pattern match: () <- return (trace "yyy" ()) Or this, which makes the trace part of the sequence of IO actions: trace "yyy" (return ()) HTH, Tom

1 0

Compiling ghc for using STM
by Asfand Yar Qazi 19 Jul '06

19 Jul '06

Hi, I finally got my spiffy dual-core processor (an Opteron 165 no-less) and want to learn STM, since I think it and haskell are the future of concurrent programming. How do I compile Haskell to be able learn STM on it, using "proper" threading? I know there's a parallel haskell flag, but I read somewhere about it running on top of some special server that lets it work in parallel threads or something. Please excuse me if I'm waffing, can anybody help me? Thanks

4 4

irc channel stats
by dons＠cse.unsw.edu.au 19 Jul '06

19 Jul '06

While we're in a period of reflection, pondering the history of haskell, I've prepared some graphs of activity on the IRC channel. Summary: its growing much as the mailing lists are, with more than 5000 users over the past 5 years. Full details here, http://www.cse.unsw.edu.au/~dons/irc/ Another interesting note is that lambdabot's get more and more verbose over time, as it provides further features. It's turning into an ide of sorts. -- Don

1 0

Re: Type-Level Naturals Like Prolog?
by Jared Warren 19 Jul '06

19 Jul '06

Thank you to everyone for the responses. I guess what I should have clarified is that I know how Peano numbers are *normally* encoded in the type language (I am very familiar with the HList library), but I would like to know why the type language appears to require data structures to do so while [Idealised] Prolog has none. Niklas Broberg helpfully corrected my Prolog: > That is not a valid encoding of peano numbers in prolog, so I think > that's where your problems stem from. :-) > > % defining natural numbers > natural(zero). > natural(s(X)) :- natural(X). > > % translate to integers > toInt(zero, 0). > toInt(s(X), N) :- toInt(X, Y), N is Y + 1. Thank you. I can now more precisely state that what I'm trying to figure out is: what is 's', a predicate or a data structure? If it's a predicate, where are its instances? If not, what is the difference between the type language and Prolog such that the type language requires data structures?

4 5

Type level logic programming terminology
by oleg＠pobox.com 19 Jul '06

19 Jul '06

Most systems of (first-order) logic differentiate between function letters (aka, symbols) and predicate letters (symbols). The former are used to build terms; the latter build atomic formulas (which can later be combined in more complex formulas using negation, conjunction, disjunction, and quantification): http://plato.stanford.edu/entries/logic-classical/ Formulas like Even (succ zero) can be interpreted to be `true' or `false' (alternatively: succeed or fail). In the atomic formula above, Even is a predicate symbol. OTH, terms like `succ zero' (an application of a function symbol succ to a constant zero) is not interpreted as true or false: it just is. In Prolog, there is likewise distinction between terms (which can be compared and unified, but cannot 'fail') and goals. The following gives a good introduction in the typed setting: http://www.cs.mu.oz.au/research/mercury/information/doc-release/reference_m… Incidentally, many Prolog systems also permit declarations of goals and of terms (because it helps produce better code). Lambda-Prolog, like Mercury, insists on declarations. The distinction between terms and goals is a bit blurred in Prolog, due to its reflection facilities: one can add a new term as a rule or a fact (e.g., using assert), one can examine the rules or facts, etc. In Haskell type-level programming: type -> term type constructor -> function symbol class name -> predicate symbol class constraint -> atomic formula (atomic goal) There is a subset of Prolog called Datalog, which is commonly defined as Prolog without function symbols. Logic without function symbols is equivalent to logic with function symbols, _provided_ we have the infinite supply of constants. For example, Foo(f(x),g(x)) can be represented as exists y y'. F(x,y) & G(x,y') & Foo(y,y') So, each function symbol f of arity n is represented as a predicate F of arity n+1. That predicate is a functional predicate: for each combination of the first n arguments, there exists exactly one object (for the last argument) that makes the predicate hold. Since terms in logic are finite, the infinitely countable supply of constants is enough. In Datalog however, the extensional database is finite. There is a finite number of facts and hence the finite number of constants. That breaks the above correspondence, and so terms like f(f(f(... x))) can no longer be emulated as the corresponding F predicate is finite (its domain is finite). That's why in pure Datalog (without negation or with stratified negation), termination is assured. This is not the case in pure Prolog because of the possibility to construct longer and longer terms like succ(succ(x)). Regarding termination, minimal models, and the correspondence between logic formulas (and pure, positive, stratified, etc. Datalogs) and P-complete etc. programs, please see http://www.csupomona.edu/~jrfisher/www/logic_topics/positive/positive.html

1 0

deepSeq vs. rnf?
by Chad Scherrer 18 Jul '06

18 Jul '06

Now and again I see references to "deepSeq", and I've never understood how this could be any different than using rnf from Control.Parallel.Strategies. Is there really any difference? When is it better to use one or the other? Thanks, -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

1 0

XML transformation difficulties
by Greg Fitzgerald 18 Jul '06

18 Jul '06

I'm trying to think of a way to translate this input, to the output below: Input: <test> <foo name="a"> <wahoo>A</wahoo> </foo> <foo name="b"> <wahoo>B</wahoo> </foo> <foo name="c"> <wahoo>C</wahoo> </foo> <group> <bar ref="b"/> <bar ref="a"/> </group> </test> Output: <test> <group> <wahoo>B</wahoo> <wahoo>A</wahoo> </group> </test> That is, anywhere there is a 'bar', replace it with the contents of the 'foo' it references. I'm having a difficult time representing this with HXT's Arrow API because the value of the 'ref' attribute is the output of an arrow, but I need it to be just a plain string so that I could use it as an input parameter to the 'hasAttrValue' function. A similar problem, using 'processTopDown', once I traverse to a 'bar' node, I need to then traverse the root again to find the 'foo', but I'm in the context of the 'bar' node, not the root. My ears are open to solutions with HaXML or Scrap Your XML-plate, or anything else. Thanks, Greg

2 4

announce: (preliminary) dbus haskell bindings
by Evan Martin 18 Jul '06

18 Jul '06

"D-Bus is a message bus system, a simple way for applications to talk to one another." [1] It's particularly popular on free software desktops (Gnome, KDE). HDBus wraps the DBus APIs so your Haskell code can broadcast messages and make calls to services. For example, on my recent Ubuntu system, these bindings are sufficient to pop up balloon-tip-style notifications via a daemon I wasn't previously aware of. Very preliminary code, so please let me know if you find it useful. (Also, I don't know where it's appropriate to announce this, so please direct me to other mailing lists.) Home page: http://neugierig.org/software/hdbus/ Haddock: http://neugierig.org/software/hdbus/doc/ Repository browser: http://neugierig.org/software/darcs/browse/?r=hdbus;a=summary [1] http://www.freedesktop.org/wiki/Software/dbus

2 1