- Haskell-Cafe - Haskell.org

ANN: powerpc-0.0.1
by Tom Hawkins 11 Mar '10

11 Mar '10

Here is a new library for analyzing PowerPC programs [1]. At this point it does instruction set simulation on machine code -- and not all instructions are implemented yet, BTW. To run a simulation, the user defines an instance of the Memory class [2] to represent both instruction and data memory. The Memory class declares functions for memory loads and stores, instruction fetches, and reading and writing special purpose registers. In our test bench, we set up the 'fetch' method to dump out register values so we can see the state of the processor at every step. A neat feature of the library is the instruction behavior is captured by a little DSL [3]. This makes it easy to add new instructions because the translation from the instruction RTL spec [4] to the DSL is nearly one-to-one. And with instruction behavior captured symbolically, this opens the door to other types of analysis besides just simulation. I hope a few folks find it useful. -Tom [1] http://hackage.haskell.org/package/powerpc [2] http://hackage.haskell.org/packages/archive/powerpc/0.0.1/doc/html/Language… [3] http://hackage.haskell.org/packages/archive/powerpc/0.0.1/doc/html/Language… [4] http://www.ibm.com/developerworks/systems/library/es-archguide-v2.html

4 7

Problem installing wxHaskell on Haskell Platform on OSX.
by David Place 11 Mar '10

11 Mar '10

Hi: I have just installed the Haskell Platform 2009.2.0.2 on Mac OSX 10.6.2. When I try to install wx I get the following error which I do not understand. Can anyone give me a hint? $ cabal install wx Resolving dependencies... cabal: cannot configure containers-0.3.0.0. It requires base >=4.2 && <6 For the dependency on base >=4.2 && <6 there are these packages: base-4.2.0.0. However none of them are available. base-4.2.0.0 was excluded because of the top level dependency base -any Here are my packages: $ ghc-pkg list /Library/Frameworks/GHC.framework/Versions/610/usr/lib/ghc-6.10.4/./package.conf: Cabal-1.6.0.3, GLUT-2.1.1.2, HTTP-4000.0.6, HUnit-1.2.0.3, OpenGL-2.2.1.1, QuickCheck-1.2.0.0, array-0.2.0.0, base-3.0.3.1, base-4.1.0.0, bytestring-0.9.1.4, cgi-3001.1.7.1, containers-0.2.0.1, directory-1.0.0.3, (dph-base-0.3), (dph-par-0.3), (dph-prim-interface-0.3), (dph-prim-par-0.3), (dph-prim-seq-0.3), (dph-seq-0.3), editline-0.2.1.0, extensible-exceptions-0.1.1.0, fgl-5.4.2.2, filepath-1.1.0.2, (ghc-6.10.4), ghc-prim-0.1.0.0, haddock-2.4.2, haskell-src-1.0.1.3, haskell98-1.0.1.0, hpc-0.5.0.3, html-1.0.1.2, integer-0.1.0.1, mtl-1.1.0.2, network-2.2.1.2, network-2.2.1.4, old-locale-1.0.0.1, old-time-1.0.0.2, packedstring-0.1.0.1, parallel-1.1.0.1, parsec-2.1.0.1, pretty-1.0.1.0, process-1.0.1.1, random-1.0.0.1, regex-base-0.72.0.2, regex-compat-0.71.0.1, regex-posix-0.72.0.3, rts-1.0, stm-2.1.1.2, syb-0.1.0.1, template-haskell-2.3.0.1, time-1.1.2.4, time-1.1.4, unix-2.3.2.0, xhtml-3000.2.0.1, zlib-0.5.0.0 /Users/davidplace/.ghc/i386-darwin-6.10.4/package.conf: fingertree-0.0.1.0

3 4

Haskell course, training
by Günther Schmidt 11 Mar '10

11 Mar '10

Hi all, all going well this year I'll be able to invest some money on becoming a better Haskeller. I think I've reached the point where I need some tutoring, so provided I've got money for travel and course fees, and time, where do I get it? I'm not a student so some courses aren't available to me. Günther

8 7

Re: Fast Haskell Parser
by Ben Lippmeier 11 Mar '10

11 Mar '10

Hi John, Doing a Google search for "haskell parser" returns the following link as its first result. That's the parser that GHC uses. http://www.haskell.org/happy/ You could also check out the following: http://www.haskell.org/haskellwiki/Parsec http://hackage.haskell.org/package/attoparsec This would also be a perfect question to ask on the haskell-cafe mailing list... Cheers, Ben. On 11/03/2010, at 10:39 AM, John D. Earle wrote: > I was thinking of ways to create an efficient Haskell parser. My initial thinking was to write a top down parser in Haskell, but if you want speed a table driven approach may make greater sense. > > Due to the existence of build bots there is a certain degree of compliancy concerning build times. I feel that convenience is an important factor. It should be convenient to build the source. Build bots make an assumption, namely the existence of a formal infrastructure. I believe that it should be possible to build something from source casually. > > This is a less demanding goal than high performance incremental builds. It would be nice to out perform make files because if you fail to do this, can it really be said that you are making progress? Correctness appears to be a low priority among computer programmers. That said, it may be worth investing some time in advance to figuring out how to best achieve both objectives, namely correctness and performance. Who knows skills acquired in one project may be useful in another and performance is usually welcome. > > So my question is, What sort of tools and methodologies exist in Haskell to create high performance parsers? My impression is the speed at which the parser performs its task is not the bottle-neck, but the parser might as well be designed to be efficient so as not to be intellectually lazy. It may even turn out that the parser may need to be efficient merely to compensate for the spawn of correctness, namely slow builds. > _______________________________________________ > Cvs-ghc mailing list > Cvs-ghc(a)haskell.org > http://www.haskell.org/mailman/listinfo/cvs-ghc

1 0

vector stream fusion, inlining and compilation time
by stefan kersten 10 Mar '10

10 Mar '10

hi, two questions in one post: i've been hunting down some performance problems in DSP code using vector and the single most important transformation seems to be throwing in INLINE pragmas for any function that uses vector combinators and is to be called from higher-level code. failing to do so seems to prevent vector operations from being fused and results in big performance hits (the good news is that the optimized code is quite competitive). does anybody have some more info about the do's and don'ts when programming with vector? the downside after adding the INLINE pragmas is that now some of my modules take _really_ long to compile (up to a couple of minutes); any ideas where i can start looking to bring the compilation times down again? i'm compiling with -O2 -funbox-strict-fields instead of -Odph (with ghc 6.10.4 on OSX 10.4), because it's faster for some of my code, but -O2 vs. -Odph doesn't make a noticable difference in compilation time. many thanks, <sk>

8 12

ANNOUNCE: yesod 0.0.0 (web framework)
by Michael Snoyman 10 Mar '10

10 Mar '10

Hello all, I'm happy to announce the first release of the Yesod Web Framework[1]. This framework has been in development for over a year and is in production use on a number of websites. The project homepage[2] provides a fairly thorough rundown of features; for here, I will suffice to say that this framework aims at the following goals: * RESTful applications * Deployable anywhere (based on WAI) * Safety While this framework is still in active development and can be expected to mature over time, this release is ready for use. To get started quickly, simply install the yesod package from Hackage and type "yesod init". Michael [1] http://hackage.haskell.org/package/yesod [2] http://www.yesodweb.com/code.html

2 6

Re: [Haskell-cafe] more thoughts on "Finally tagless"
by Tom Schrijvers 10 Mar '10

10 Mar '10

On Tue, Mar 9, 2010 at 2:45 PM, Tillmann Rendel <rendel(a)mathematik.uni-marburg.de> wrote: > Tom Schrijvers wrote: >>> >>> Yeah, subject "Finally Tagless" again, sorry, I'm just not done with it >>> yet. >>> >>> In Olegs haskell implementation he is using classes mainly to model the >>> syntax and instances to use for evaluators / compilers to allow multiple >>> interpretations. >>> >>> I wonder if it'd be possible to do the same without classes using data >>> types >>> instead? >>> >>> Something similar to what Luke Palmer has done here: >>> >>> >>> http://lukepalmer.wordpress.com/2010/01/24/haskell-antipattern-existential-… >> >> You can just use the dictionary translation of type classes to replace >> them with data types: >> >> E.g. >> >> class Eval sem where >> val :: Int -> sem Int >> add :: sem Int -> sem Int -> sem Int >> >>> --> >> >> data EvalDict sem = EvalDict { val :: Int -> sem Int, add :: sem Int >> -> sem Int -> sem Int } > > This is the way to program in the final tagless style without using type > classes, but there is an important difference to what Luke Palmer did in the > blog post cited above. While both approaches allow to encode type classes > using data types, they are technically different, and applicable for > different programs. > > In the dictionary approach, the dictionary contains fields of the same types > as the members of the class. For example, val has the type Int -> sem Int in > both the type class and the data type. > > This is not the case in the pattern described by Luke. There, the w type is > dropped from the types of the methods when converting to a data type. For > example, the type of growHorizontal is w -> Bool in the type class, but > simply Bool in the data type. > > The reason for this difference is that Luke uses the fact that w is going to > be always existentially bound, so it will not be externally usable anyway. > The information contained in the w values can just as well be stored in each > of the fields of the data type. > > The dictionary approach encodes abstract data types: The data type is the > interface, each value of the data type is an implementation, and a function > which takes the dictionary and is parametric in the type parameters of the > dictionary is a program which uses the data type abstractly. > > For example, a program using the Eval abstract data type from above could > look like this: > > -- using the type class > add_two :: Eval sem => sem -> sem > add_two x = add x (val 2) > > -- using the dictionary > add_two :: EvalDict sem -> sem -> sem > add_two dict x = add dict x (val dict 2) > > On the other hand, Luke describes an encoding of objects: The data type > describes the interface of an object, and each value of that data type is an > object, with possibly different implementations of each function in the > interface. A program using these objects can invent arbitrary new objects, > as long as all fields in the interface are defined. > > Since abstract data types and objects are fundamentally different, so are > these two programming patterns. Tillmann, Thanks for your insight of objects vs. abstract data types. William Cook's Onward! essay is relevant here. He characterizes the difference between objects and abstract data types nicely: the latter allow binary methods that pattern match (to exploit the combined knowledge of the internals of two different values) whereas objects only know their own implementation. Dictionaries by themselves are objects in Cook's sense: they are just a record of functions that cannot be inspected. We can have an infinite number of them (while we can only have one type class instance per sem type). However, the (sem a) values are not objects, and varying the dictionaries while keeping the sem type the same does not seem very useful for implementing different semantics. For a type class function like add :: sem Int -> sem Int -> sem Int, binary pattern matching seems essential for meaningful implementations, and hence objects don't make much sense. Would you agree? Cheers, Tom

2 1

Anyone up for Google SoC 2010?
by Malcolm Wallace 10 Mar '10

10 Mar '10

Google has announced that the Summer of Code programme will be running again this year. If haskell.org people would like to take part again this year, then we need volunteers: First, * suggestions for suitable projects (in the past this was organised using a reddit) * an administrator to co-ordinate the application to Google (I have done it for the last three years but am very willing to hand on to someone else) Google will accept applications from organisations in the period 8th - 12th March 2010, approx 1900UTC. If haskell.org is accepted again, students can apply between 29th March - 9th April. More volunteers will be required: * to review student applications and choose which to accept * to supervise the accepted students Both of these roles are called "mentor" in the Google system. Putting together a good team of mentors before applying as an organisation is helpful towards us being accepted into the programme. Regards, Malcolm

17 32

Detecting extensions of the host processor
by Henning Thielemann 10 Mar '10

10 Mar '10

I like to detect at runtime whether the processor my program runs on has certain extensions (SSE2, SSE3 or so) in order to execute optimized code. On Linux I can process the contents of /proc/cpuinfo but this will not work on Windows. Is there a portable way in Haskell?

2 1

Re: If the local variable can be changed ...
by John Lato 10 Mar '10

10 Mar '10

> From: zaxis <z_axis(a)163.com> > > So if the local variable can be changed, then we can use loop, etc. same as > imperative languages. For example, for (i=0; i<100; i++) where `i` is a > local variable in function. > In addition to John Millikin's suggestion, you can also do: map f [0..99] where f :: Int -> a; f = ... or mapM f [0..99] where f :: Int -> m a; f = ... for monadic actions. Here "f" is the body of the loop. The loop bodies must be completely independent, but this is a very useful technique. Cheers, John

1 0