August 2006 - Haskell

AJAX applications in Haskell
by Pasqualino 'Titto' Assini 14 Aug '06

14 Aug '06

Hi, Those among you who have an interest in AJAX-style web development - that is to say the development of web applications that run entirely into the browser environment, calling back to the server back-end only to get raw data -- will probably have noticed the recent appearance of the Google Web Toolkit (http://code.google.com/webtoolkit) The main idea behind it is very simple: you write your Ajax application in Java and your code is compiled down to JavaScript/HTML (rather then to Java Virtual Machine bytecode) so that it can be executed in any browser. The main advantages of this solution are: - Development using a typed language with good compile-time checks and debugger support - No plugins (e.g. a Java VM) required on the user machine The disadvantages are: - An additional compilation step - Probably, a significant loss of performance with respect to hand-written code Assuming that the balance is positive, this naturally raises the question: why not doing the same with our favourite language? This would require to: - Retarget one of the existing Haskell compilers to generate JavaScript (other possible targets would be Flash or higher level UI languages such as OpenLaszlo that in turn compiles down to either Flash or JavaScript/HTML) - Write a suitable runtime library (including support for native JavaScript or Flash UI components, remote method invocations, multi-threading, etc.) - Port a usable subset of the Haskell Libraries - Select an approach to write user interfaces in Haskell. There have been many attempts in this direction but I am unsure if any of them has proven particularly successful. All considered, quite a significant amount of work -- that would require a concerted group effort -- with a rather uncertain pay-off. Is anyone working on anything similar or that might be interested in such a project? And has anyone any thoughts to offer on what compilers/libraries/UI frameworks would be more suitable for the task? Regards, titto assini

2 2

We komen langs
by Henk-Jan van Tuyl 13 Aug '06

13 Aug '06

Hallo Diny, We komen vanmiddag langs, zoals afgesproken. Voor geval je het vergeten bent, hoop ik, dat je dit op tijd leest. -- Groeten, Henk-Jan -- http://Van.Tuyl.eu/ -- Using Opera's revolutionary e-mail client: https://secure.bmtmicro.com/opera/buy-opera.html?AID=789433

1 0

aosd 2007
by Oege.de.Moor＠comlab.ox.ac.uk 12 Aug '06

12 Aug '06

AOSD 2007: CALL FOR RESEARCH PAPERS 6th Conference on Aspect-Oriented Software Development http://www.aosd.net/2007/cfc/research.php >> on-line submission is now open << Deadline September 22 ------------------------------------------------------ The program committee especially welcomes submissions from researchers in functional programming on any topic relating to aspect-oriented extensions of Haskell (or why you don't need them!)

1 0

The history of Haskell
by Simon Peyton-Jones 11 Aug '06

11 Aug '06

Friends Some while ago I posted an announcement about our draft paper "The History of Haskell". A dozen or so people typed in pages of comments, or sent us email. Thank you so much! I have incorporated almost everything we received, and would like to invite your renewed attention. You'll find Version 2 (dated 11 August) in the same place as before: http://haskell.org/haskellwiki/History_of_Haskell I have started a new Talk page so that old comments do not get mixed up with new ones. If you'd like to check the revisions, or suggest other improvements, we'd love to hear from you. Our deadline for the Final Version is 14 Sept. Feedback before end Aug is more likely, therefore, to be used. I hope I have acknowledged everyone who contributed -- please yell if not. However, I don't know the real names of the following (these are their Wiki account names): Weihu, Joesf, Ruiz, Plareplane, Padator, Hoan, Saccade, davidk01 If you tell me who you are, I'll add you to the acks. Thanks! Simon

1 0

hs-plugins on MacOS X: unknown symbol
by Ulf Norell 11 Aug '06

11 Aug '06

Hi. I'm playing with hs-plugins (recent darcs version) on MacOS X (ghc-6.4.1) and I get some weird unresolved symbols. Here's what I'm trying to do: Test.hs ------- module Test where test = putStrLn "test" Main.hs ------- import System.Plugins main = do r <- load_ "Test.o" [] "test" case r of LoadFailure msg -> print msg LoadSuccess _ m -> m Now I do: $ ghc -c Test.hs $ ghc Main.hs -package plugins $ ./a.out a.out: unknown symbol `_SystemziIO_putStrLn_closure' a.out: user error (resolvedObjs failed.) I get the same error when I try with plugins-0.9.10. I've tried to use loadPackage "base" and resolveObjs to no avail. What does work (not surprisingly) is to use putStrLn in Main.hs to force it to be linked in but that's not really a solution. If someone knows what I'm doing wrong I'd be very grateful. / Ulf

1 0

The 2006 ACM SIGPLAN Workshop on ML: Call for Participation
by Francois Pottier 11 Aug '06

11 Aug '06

********************************************************************* * The 2006 ACM SIGPLAN Workshop on ML * * * * September 16, 2006 * * * * Colocated with the 11th ACM SIGPLAN * * International Conference on Functional Programming (ICFP 2006), * * Portland, Oregon. * * * * Call for Participation * * * * http://gallium.inria.fr/ml2006/ * ********************************************************************* Programme 9:30-10:30: chaired by Andrew Kennedy Welcome Invited talk: Whole-Program Compilation for MLton Stephen Weeks 10:30-11:00 Break 11:00-12:30: chaired by Derek Dreyer ML Grid Programming with ConCert Tom Murphy VII Type-Safe Modular Hash-Consing Jean-Christophe Filliâtre and Sylvain Conchon Type-Safe Distributed Programming for OCaml John Billings, Peter Sewell, Mark Shinwell and Rok Strnisa 12:30-14:30 Lunch 14:30-16:00: chaired by Stephanie Weirich A Separate Compilation Extension to Standard ML David Swasey, Tom Murphy VII, Karl Crary and Robert Harper Leveraging .NET Meta-Programming Components in F# Don Syme Backtracking Iterators Jean-Christophe Filliâtre 16:00-16:30 Break 16:30-18:00: chaired by Matthew Fluet SEMINAL: Searching for ML Type-Error Messages Benjamin Lerner, Dan Grossman and Craig Chambers Type-Sensitive control-flow analysis John Reppy Ocsigen: Typing interaction with Objective Caml Vincent Balat Scope The ML family of programming languages, whose most popular variants are SML and OCaml, has inspired a tremendous amount of computer science research, both practical and theoretical, and ML continues to underpin a variety of applications, ranging from compilers and theorem provers to low-level system software. This workshop aims to provide a forum for discussion and research on existing and future ML and ML-like languages. Proceedings will be published by ACM Press and will appear in the ACM Digital Library. General Chairs and Program Chairs Andrew Kennedy Microsoft Research Ltd, 7 JJ Thomson Ave, Cambridge CB3 0FB, UK akenn(a)microsoft.com François Pottier INRIA Rocquencourt BP 105 78153 Le Chesnay Cedex FRANCE francois.pottier(a)inria.fr Programme Committee Derek Dreyer (Toyota Technological Institute at Chicago) Matthew Fluet (Cornell University) John Harrison (Intel Corporation) Haruo Hosoya (University of Tokyo) Andrew Kennedy (Microsoft Research Cambridge, co-chair) Eugenio Moggi (Università di Genova) Michael Norrish (National ICT Australia) François Pottier (INRIA Rocquencourt, co-chair) Ian Stark (University of Edinburgh) Alley Stoughton (Kansas State University) Jérôme Vouillon (CNRS and Université Paris 7) Stephanie Weirich (University of Pennsylvania)

1 0

ANN: hpc -- Haskell Program Coverage
by Colin Runciman 11 Aug '06

11 Aug '06

We are pleased to announce the first release of hpc, a new tool for Haskell developers. Hpc records and displays Haskell program coverage. It provides coverage information of two kinds: source coverage and boolean-control coverage. Source coverage is the extent to which every part of the program was used, measured at three different levels: declarations (both top-level and local), alternatives (among several equations or case branches) and expressions (at every level). Boolean coverage is the extent to which each of the values True and False is obtained in every syntactic boolean context (ie. guard, condition, qualifier). Hpc displays both kinds of information in two different ways: textual reports with summary statistics (hpc-report) and sources with colour mark-up (hpc-source). For further information and a tar-ball for hpc 0.2 see http://www.galois.com/~andy/hpc-intro.html Colin Runciman and Andy Gill

1 0

Smash your boiler-plate without class and Typeable
by oleg＠pobox.com 10 Aug '06

10 Aug '06

We describe a new generic programming approach, which is powerful enough to traverse a term and return another term of a different type, determined by the original term's type/structure. The example is a generic function that replaces all Floats with Doubles in an arbitrary term. The approach combines the features of the original `Scratch your boilerplate' (SYB1, presented at TLDI2003) and the third version SYB3 (ICFP05): -- like SYB1, our generic function is an ordinary function rather than a typeclass method. Unlike SYB3, the end user of our library defines no typeclasses. We do not need any extensions like recursive instances either. -- unlike SYB1, we need neither Typeable nor (safe) typecast -- unlike SYB1 and SYB3, we do not need higher-rank types -- like SYB3, the library needs overlapping and undecidable instances. Unlike SYB3, the end user needs no such extensions. In fact, the use of these extensions is confined to a small part of the library, namely, to the implementation of TypeEq. The essence of our approach is the _typelevel_ typecase. It is inspired by the deepest functor, which has http://okmij.org/ftp/Haskell/typecast.html#deepest-functor This message and code have greatly benefited from discussions with Chung-chieh Shan, who also suggested the title. Our generic function is composed of a specific and generic parts. A specific part tells us what to do if the input term happens to be of some particular type. The generic part tells us what to do with all other terms. The specific part is just an HList of ordinary functions, with different argument types. If the type of the input term matches the argument type of one of the functions in the list, we apply that function. If no specific function applies, we do the generic action, implicit in the traversal strategy (for example, apply the generic function to the subterms and reduce the results). Generic programming described in the original SYB1 paper introduced two fundamental ideas: -- generic functions like |gmapQl op seed f term|, which traverses an arbitrary term and applies the user-defined function f to each subterm and reduces the results with a left-associative operator op. -- generic function f that transforms arbitrary (sub)terms of arbitrarily types. That transformation is specified as a composition of specific transformations (which apply only to the values of some specific types) and a generic, default transformation for all other types. In SYB1, the function gmapQl is implemented as a method of a class Data; the SYB library provides instances for all (interesting) types. The function 'f', OTH, is essentially a `typecase' operator, to tell one specific type from the rest. SYB relies on a run-time typecase, depending on the run-time type representation -- which is provided by the typeclass Typeable. The typeclass also has the method `cast' for a safe cast from the value of `generic type' to the value of a specific type. We observe that the typecase, _on the type level_, has always existed in Haskell (although that fact was not perhaps realized until HList). That typecase, which does not need any `cast' operation, is the type equality predicate TypeEq. We consider here two classes of generic functions. The first class of generics takes a term and returns a value of some fixed type. The example is a generic size function, counting the number of data constructors in a term with the specific size measure assigned to values of particular types, e.g., strings. The second class of generics takes a term and returns a potentially different term -- in value as well as in type. For example, replacing Floats with Doubles or vice versa, or replacing all tuples of integers in a complex term with a 2-element array. Our first example uses a generic query function gmapq, which recursively traverses a term in the depth-first order, and applies reducer to the list of term's children. First, we define a function that counts the number of data constructors and values of primitive types in any term: > gsize a = gmapq SNil (\l -> 1 + sum l) a > test1 = gsize (1::Int) -- 1 > test2 = gsize [1::Int,2,3] -- 7 == 3 integers + three (:) + one [] > test3 = gsize "abc" -- 7, as above, with Char instead of Int > test4 = gsize ["abc"] -- 9: one extra (:) and one extra [] Now, we shall treat strings specially: we assign each string size 999. We only need a small modification to gsize': > gsize' a = gmapq (SCons (\ (_::String) -> (999::Int)) SNil) (succ . sum) a > test1' = gsize' (1::Int) > test2' = gsize' [1::Int,2,3] -- 7 > test3' = gsize' "abc" -- 999 > test4' = gsize' ["abc"] -- 1001 In a different example, we check if a given data structure contains somewhere the letter 'a' (or an integer with the 'a' code): > hasa a = gmapq (SCons (== 'a') (SCons (== (fromEnum 'a')) SNil)) or a > testh = (hasa ('x',False), > hasa ('x',97::Int), hasa 'a', hasa [[["cde"],["abc"]]]) > -- (False,True,True,True) For generic term transformations, we take the following term: > term1 = ([1::Int,2], (True,('2',[(3::Int,4::Int)]))) Let us increment all integers in that term: > inci a = gtmapq (HCons (\ (x::Int) -> x + 1) HNil) a > testi1 = inci term1 -- result: ([2,3],(True,('2',[(4,5)]))) Let us replace all Int tuples (x,y) with an array [x,y], and negate all booleans > p2l a = gtmapq (HCons (\ (x::Int,y) -> [x,y]) (HCons not HNil)) a > test_p2l = p2l term1 -- result: ([1,2],(False,('2',[[3,4]]))) Let us replace an Int with a Double everywhere > i2d a = gtmapq (HCons (fromIntegral::Int->Double) HNil) a > test_i2d = i2d term1 -- result: ([1.0,2.0],(True,('2',[(3.0,4.0)]))) The complete implementation along with the examples is available at http://okmij.org/ftp/Haskell/syb4.hs The following is the key part of the implementation of gmapq. First, we introduce a heterogeneous list of functions a->w where all functions in the list have the same return type w. The argument type 'a' varies from one list member to another. The property that each function in the list has the same result type is guaranteed by the construction of the datatype. > data SNil w = SNil > data SCons a b w = SCons (a->w) (b w) Given the datum of the type 'a', we check if any function in the list 'spec w' has the argument type 'a' and so can be applied. If there is such a function, we apply it. Otherwise, we return the default, the third argument of sapply. > class SApply spec a where > sapply :: spec w -> a -> w -> w > > instance SApply SNil a where > sapply _ _ deflt = deflt > > instance (TypeEq a a' bf, SApply' bf (SCons a' r) a) > => SApply (SCons a' r) a where > sapply = sapply' (undefined::bf) > > class SApply' bf spec a where > sapply' :: bf -> spec w -> a -> w -> w > > instance SApply' HTrue (SCons a r) a where > sapply' _ (SCons p _) x _ = p x > > instance SApply r a => SApply' HFalse (SCons a' r) a where > sapply' _ (SCons _ r) x deflt = sapply r x deflt

1 0

Foreign.Marshal.Alloc questions
by Chris Kuklewicz 10 Aug '06

10 Aug '06

For the allocation functions in Foreign.Marshall.Alloc, are the function contracts that return new pointers such that the pointers are never nullPtr, or is it prudent to always check the new ptr? I can see on GHC than allocaBytes uses newPinnedByteArray# but I have not tracked down the source file for that to read it. -- Chris Kuklewicz

1 0

AJAX applications in Haskell
by Dimitry Golubovsky 09 Aug '06

09 Aug '06

Hi, Pasqualino 'Titto' Assini wrote: =================== Assuming that the balance is positive, this naturally raises the question: why not doing the same <generate Javascript/Ajax application code to run in browser - DMG> with our favourite language? This would require to: - Retarget one of the existing Haskell compilers to generate JavaScript (other possible targets would be Flash or higher level UI languages such as OpenLaszlo that in turn compiles down to either Flash or JavaScript/HTML) =================== Joel Björnson wrote: =================== I am currently working on a Google Summer of Code project relating to some of this... The project is more or less bound to Haskell Server Pages ( http://www.cs.chalmers.se/~d00nibro/hsp/) enabling JavaScript code generation. The main difference compared to the Google Web Toolkit approach is that there are no special compiler magic added for compiling directly into JavaScript. =================== Looks like the idea is picked up by more and more people ;) I saw some notes on this (generation of Javascript from Haskell source) in Jared Updike's blog, and I got this idea myself independently from Jared in about the same time. I am trying to add some code to nhc98 (contrary to GHC its code is much smaller and better observable) to generate Javascript at the same time when STG tree is converted into bytecodes*. I am in the very beginning though, so I cannot show any results. OTOH I do not feel like I have a lot of time to dedicate to this, so if someone else is working on this, could we team up (possibly for a different (if shown better) approach because one I chose is still questionable optimization-wise, but generation of Javascript from bytecodes does not seem better to me at the time)? -------------- * Work in progress may be observed at http://www.golubovsky.org/repos/nhc98/ in particular in http://www.golubovsky.org/repos/nhc98/src/compiler98/STGJcode.hs but at the moment there is virtually nothing done. -- Dimitry Golubovsky Anywhere on the Web

1 0