- Haskell - Haskell.org

08 Jun '07

Hello I want to build and install some extralibs using Cabal. I have the Cabal-1.1.6.2 version installed. When I run the command $ runghc Setup.hs configure --ghc --user --prefix=$HOME it fails with the message Setup.hs:17:30: Couldn't match expected type `UserHooks' against inferred type `Maybe UserHooks' Expected type: Hook a Inferred type: PackageDescription -> LocalBuildInfo -> Maybe UserHooks -> BuildFlags -> IO () In the second argument of `($)', namely `buildHook defaultUserHooks' In the `buildHook' field of a record How can I fixe this bug ? Thanks B. Fotsing Talla

5 4

ANN: Catch (first ever release)
by Neil Mitchell 08 Jun '07

08 Jun '07

Hi, Do you sometimes encounter the dreaded "pattern match failure: head []" message? Do you have incomplete patterns which sometimes fail? Do you have incomplete patterns which you know don't fail, but still get compiler warnings about them? Would you like to statically ensure the absence of all calls to error? For the last few years I've been working on a pattern-match checker for Haskell, named Catch. I'm now happy to make a release: Hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/catch-0.1 Homepage: http://www-users.cs.york.ac.uk/~ndm/catch/ User manual: http://www.cs.york.ac.uk/fp/darcs/catch/catch.htm While a darcs version is available, I strongly recommend the use of the tarball on hackage. Features: * Detects all incomplete patterns and calls to error * Full support for Haskell, through the use of Yhc as a front end * Automatic - no annotations are required * Fast - checking times of under 5 seconds (excluding Yhc compilation) are typical Drawbacks: * Requires Yhc to be installed, which doesn't accept most Haskell extensions. This will be fixed once GHC.Core is available as a standalone library. The underlying tool is not limited to Haskell 98 in any way. Success stories: * The darcs version of HsColour has been proven free of pattern match errors, and Catch was able to find three previously unknown crashes which could be triggered by a malformed document. * System.FilePath has been checked, and is free of pattern-match errors * XMonad's central StackSet.hs module has been checked repeatedly, as it has evolved. Unfortunately currently this module goes beyond Haskell 98, but this should be fixed shortly. If you have any experiences with Catch, I'd be very interested to hear them. Thanks Neil

2 1

Einladung zum Kolloquium Programmiersprachen (KPS'07)
by Clemens Grelck 08 Jun '07

08 Jun '07

Our sincere apologies to all non German speaking readers of this mailing list for this workshop invitation in German. ====================================================================== Einladung zur Teilnahme KPS'07 Kolloquium Programmiersprachen und Grundlagen der Programmierung Timmendorfer Strand 10.-12. Oktober 2007 Anmeldeschluss: 1. August 2007 http://www.isp.uni-luebeck.de/kps07 Liebe Kollegen, das 14. Kolloquium Programmiersprachen und Grundlagen der Programmierung setzt eine traditionelle Reihe von Arbeitstagungen fort, die 1980 von den Forschungsgruppen der Professoren Friedrich L. Bauer (TU München), Klaus Indermark (RWTH Aachen) und Hans Langmaack (CAU Kiel) ins Leben gerufen wurde. Heute präsentiert sich die Veranstaltung allen interessierten deutschsprachigen Wissenschaftlern als ein offenes Forum zum zwanglosen Austausch neuer Ideen und Ergebnisse aus den Forschungsbereichen Programmiersprachen sowie Grundlagen des Programmierens. Wir würden uns freuen, Sie als Teilnehmer des 14. Kolloquiums Programmiersprachen und Grundlagen der Programmierung vom 10. bis zum 12. Oktober 2007 im Hotel Atlantis in Timmendorfer Strand an der Ostsee begrüßen zu können. Mit besten Wünschen Dr. Annette Stümpel und Dr. Clemens Grelck Institut für Softwaretechnik und Programmiersprachen Universität zu Lübeck http://www.isp.uni-luebeck.de

1 0

TFP 2007: Draft Proceedings Articles
by Marco Morazan 08 Jun '07

08 Jun '07

Dear Colleagues, Thank you for the interest expressed in the draft proceedings of TFP 2007. To make accessing individual articles easier for those who do not wish to download the entire proceedings, we have added links to individual articles. You may download the complete draft proceedings at: http://cs.shu.edu/tfp2007/draftProcDocument.pdf You may download individual articles in the draft proceedings at: http://cs.shu.edu/tfp2007/schedule.html Cheers, Marco

1 0

new keywords in lhs2TeX
by Wolfgang Jeltsch 07 Jun '07

07 Jun '07

Hello, is there a way to declare certain non-standard Haskell keywords as keywords in lhs2TeX so that they get formatted like keywords? This would be helpful for rendering arrow syntax expressions with lhs2TeX since they use proc and sometimes rec. Best wishes, Wolfgang

2 1

arrow syntax with LaTeX
by Wolfgang Jeltsch 07 Jun '07

07 Jun '07

Hello, I want to typeset Haskell code using arrow syntax with LaTeX in math mode (using lhs2TeX and polycode.fmt). However I don’t know how to produce a nice LaTeX math mode equivalent for -<. Does anybody have an idea what to do at this point? Best wishes, Wolfgang

3 3

Re: [Haskell] arrow syntax with LaTeX
by Wolfgang Jeltsch 07 Jun '07

07 Jun '07

Am Donnerstag, 7. Juni 2007 01:08 schrieben Sie: > On Thu, Jun 07, 2007 at 12:51:18AM +0200, Wolfgang Jeltsch wrote: > > I want to typeset Haskell code using arrow syntax with LaTeX in math > > mode (using lhs2TeX and polycode.fmt). However I don???t know how to > > produce a nice LaTeX math mode equivalent for -<. Does anybody have > > an idea what to do at this point? > > I used this rather crude definition: > > %format -< = "\Aapply " > \newcommand{\Aapply}{\mathrel{-\!\!\!\!\prec}} Thank you for this info. However, this doesn’t look to nice since the right part of -< is really big. Meanwhile I came across \mapsfromchar from the stmaryrd package and switched to the following definition: %format -< = "\mathrel{\relbar\mapsfromchar}" This is not really the -< symbol but at least it comes close. Maybe someone should create \lefttailchar so that \mathrel{\relbar\lefttailchar} can be used. Best wishes, Wolfgang

1 0

TFP 2007: Draft Proceedings Available On-line
by Marco Morazan 05 Jun '07

05 Jun '07

Dear Colleagues, The draft proceedings of TFP 2007 are now available on the symposium's website. You may access the draft proceedings directly at: http://cs.shu.edu/tfp2007/draftProcDocument.pdf . This volume represents the articles associated with the work presented at TFP 2007. As in previous versions of TFP it is called the draft proceedings to distinguish it from the formal peer-reviewed post-symposium proceedings. The work presented at TFP 2007 was selected by its international program committee through the screening of extended abstracts. Cheers, Marco

1 0

20th European Summer School in Logic, Language and Information
by Simon Marlow 05 Jun '07

05 Jun '07

[ posting on behalf of Rineke Verbrugge <L.C.Verbrugge(a)ai.rug.nl> ] %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 20th European Summer School in Logic, Language and Information ESSLLI 2008 Monday, 4 August - Friday, 15 August 2008 Hamburg, Germany %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% CALL FOR COURSE and WORKSHOP PROPOSALS -------------------------------------- The European Summer School in Logic, Language and Information (ESSLLI) is organized every year by the Association for Logic, Language and Information (FoLLI, http://www.folli.org) in different sites around Europe. The main focus of ESSLLI is on the interface between linguistics, logic and computation. ESSLLI offers foundational, introductory and advanced courses, as well as workshops, covering a wide variety of topics within the three areas of interest: Language and Computation, Language and Logic, and Logic and Computation. Previous summer schools have been highly successful, attracting up to 500 students from Europe and elsewhere. The school has developed into an important meeting place and forum for discussion for students and researchers interested in the interdisciplinary study of Logic, Language and Information. The ESSLLI 2008 Program Committee invites proposals for foundational, introductory, and advanced courses, and for workshops for the 20th annual Summer School on a wide range of timely topics that have demonstrated their relevance in the following fields: - Logic and Language - Logic and Computation - Language and Computation PROPOSAL SUBMISSION: Proposals should be submitted through a web form available at http://www.folli.org/submission.php All proposals should be submitted no later than ******* Monday July 2, 2007. ******* Authors of proposals will be notified of the committee's decision no later than Monday September 10, 2007. Proposers should follow the guidelines below while preparing their submissions; proposals that deviate can not be considered. GUIDELINES FOR SUBMISSION: Anyone interested in lecturing or organizing a workshop during ESSLLI-2006, please read the following information carefully. ALL COURSES: Courses are taught by 1 or max. 2 lecturers. They consists of five sessions (a one-week course), each session lasting 90 minutes. Lecturers who want to offer a long, two-week course should submit two independent one-week courses (for example an introductory course in the first week of ESSLLI, and a more advanced course during the second). The ESSLLI program committee has the right to select only one of the two proposed courses. Timetable for Course Proposal Submissions: July 2, 2007: Proposal Submission Deadline Sep 10, 2007: Notification June 2, 2008: Deadline for receipt of camera-ready course material (by ESSLLI Local Organizers) FOUNDATIONAL COURSES: These are strictly elementary courses not assuming any background knowledge. They are intended for people to get acquainted with the problems and techniques of areas new to them. Ideally, they should allow researchers from other fields to acquire the key competences of neighboring disciplines, thus encouraging the development of a truly interdisciplinary research community. Foundational courses may presuppose some experience with scientific methods in general, so as to be able to concentrate on the issues that are germane to the area of the course. INTRODUCTORY COURSES: Introductory courses are central to the activities of the Summer School. They are intended to equip students and young researchers with a good understanding of a field's basic methods and techniques. Introductory courses in, for instance, Language and Computation, can build on some knowledge of the component fields; e.g., an introductory course in computational linguistics should address an audience which is familiar with the basics of linguistics and computation. Proposals for introductory courses should indicate the level of the course as compared to standard texts in the area (if available). ADVANCED COURSES: Advanced courses should be pitched at an audience of advanced Masters or PhD students. Proposals for advanced courses should specify the prerequisites in detail. WORKSHOPS: The aim of the workshops is to provide a forum for advanced Ph.D. students and other researchers to present and discuss their work. Workshops should have a well defined theme, and workshop organizers should be specialists in the theme of the workshop. It is a strict requirement that organizers give a general introduction to the them during the first session of the workshop. They are also responsible for the organization and program of the workshop including inviting the submission of papers, reviewing, expenses of invited speakers, etc. In particular, each workshop organizer will be responsible for producing a Call for Papers for the workshop by November 11, 2007. The call must make it clear that the workshop is open to all members of the LLI community. It should also note that all workshop contributors must register for the Summer School. Timetable for Workshop Proposal Submissions: July 2, 2007: Proposal Submission Deadline Sep 10, 2007: Notification Nov 11, 2007: Deadline for receipt of Call for Papers (by ESSLLI PC chair) Nov 18, 2007: Workshop organizers send out (First) Call for Papers Mar 17, 2008: Deadline for Papers (suggested) Apr 28, 2008: Notification of Workshop Contributors (suggested) June 2, 2008: Deadline for receipt of camera-ready copy of Workshop Proceedings (by ESSLLI Local Organizers) Notice that workshop speakers will be required to register for the Summer School; however, they will be able to register at a reduced rate to be determined by the Local Organizers. FORMAT FOR PROPOSALS: The web-based form for submitting course and workshop proposals is accessible at http://www.folli.org/submission.php. You will be required to submit the following information: * Name (name(s) of proposed lecturer(s)/organizer) * Address (contact addresses of proposed lecturer(s)/organizer; where possible, please include phone and fax numbers) * Title (title of proposed course/workshop) * Type (is this a workshop, a foundational course, an introductory course, or an advanced course?) * Section (does your proposal fit in Language & Computation, Language & Logic or Logic & Computation? name only one) * Description (in at most 150 words, describe the proposed contents and substantiate timeliness and relevance to ESSLLI) * External funding (will you be able to find external funding to help fund your travel and accommodation expenses? if so, how?) * Further particulars (any further information that is required by the above guidelines should be included here; in particular, indicate here your teaching experience in an interdisciplinary field as the one addressed by ESSLLI.) FINANCIAL ASPECTS: Prospective lecturers and workshop organizers should be aware that all teaching and organizing at the summer schools is done on a voluntary basis in order to keep the participants fees as low as possible. Lecturers and organizers are not paid for their contribution, but are reimbursed for travel and accommodation (up to a fixed, maximum amount that will be notified to lecturers when courses are accepted). It should be stressed that while proposals from all over the world are welcomed, the Summer School cannot guarantee full reimbursement of travel costs, specially from destinations outside Europe. Please note the following: In case a course is to be taught by two lecturers, a lump sum is reimbursed to cover travel and accommodation expenses for one lecturer. The splitting of the sum is up to the lecturers. The local organizers highly appreciate it if, whenever possible, lecturers and workshop organizers find alternative funding to cover travel and accommodation expenses, and such issues might be taken into account when selecting courses. PROGRAM COMMITTEE: Chair: Rineke Verbrugge Institute of Artificial Intelligence University of Groningen Grote Kruisstraat 2/1 9712 TS Groningen The Netherlands phone +31 (0)50 571 81 41 e-mail : rineke (at) ai.rug.nl www : http://www.ai.rug.nl/~rineke Local co-chair: Benedikt Löwe Area Specialists: Petra Hendriks and Philippe Schlenker (Logic and Language) Michael Kaminski and Enrico Franconi (Logic and Computation) Khalil Sima'an and Massimo Poesio (Language and Computation) ORGANIZING COMMITTEE: Walter von Hahn and Cristina Vertan FURTHER INFORMATION: The website for ESSLLI 2008 will become operational in the second half of 2007. For this year's summer school, please see the web site at http://www.cs.tcd.ie/esslli2007/ . With best regards, Rineke Verbrugge

1 0

Smash along your boilerplate; how to traverse a non-existent term
by oleg＠pobox.com 05 Jun '07

05 Jun '07

We describe a generalization of the Smash-your-boilerplate generic programming approach to extensible traversal strategies. To the pre-defined gmap, reduction, and two-terms-in-lockstep strategies, the programmer may at any time add a new class of traversals. The present message shows one such extension, lazy gmap, and its application to mapping of terms that do not exist. This lets us implement gminimum and gmaximum -- which traverse `undefined' and produce the fully-defined smallest (resp. largest) term of a desired type: gminimum () :: (Maybe Int,Either Bool (Maybe Char)) ==> (Nothing,Left False) gmaximum () :: (Maybe Int,Either Bool (Maybe Char)) ==> (Just 2147483647,Right (Just '\1114111')) The result of traversing (undefined::(Maybe Int,Either Bool (Maybe Char))) is (Nothing,Left False). This meaningful traversal of non-existing terms is another benefit of Haskell's non-strictness. The complete code is available at http://darcs.haskell.org/generics/comparison/SmashA/ The code includes sample applications and examples, within the generic programming comparison framework by Alexey Rodriguez Yakushev, Alex Gerdes, and Johan Jeuring. The code is tested with GHC 6.4.1 and 6.6. The Smash approach is based on the typecase-like function stapply defined at the beginning of Syb4A.hs -- which expresses (or, reifies) the typeclass selection in Haskell itself: stapply :: spec -> a -> d -> w Given a heterogeneous list |spec| of functions |ai->wi| (where |ai| and |wi| vary from one function to another in the list) and a datum of the type |a|, we check to see if there is a function in that list whose argument type |ai| is equal to |a|. If so, we apply that function to the datum and return its result of the type |wi|. If no such function is found, we return the supplied default value, of the type |d|. Thus the result type |w| of stapply is a (type-level) function of the types |spec|, |a|, and |d|. The function stapply is dual to typeclasses: for example, the following typeclass method > class C a where fn :: a -> Int > instance C Bool where fn x = if x then 10 else 20 > instance C Char where fn x = fromEnum x is dually > testtyc_fn x = > stapply ((\ (x::Bool) -> if x then 10 else 20) :+: > (\ (x::Char) -> fromEnum x) :+: > HNil) > ((error "no match")::Int) x (One may say that testtyc_fn corresponds to a closed typeclass. That is true in the above definition. However, HLists may be open too). Our most general generic function is |gapp|, which applies a generic function to a term. A generic function is (quite literally) made of two parts. First, there is a term traversal strategy, identified by a _label_ |tlab|. One strategy may be to `reduce' a term using a supplied reducing function (cf. fold over a tree). Another strategy may rebuild a term. The second component of a generic function is |spec|, the list of `exceptions'. Each component of |spec| is a function that tells how to transform a term of a specific type. Exceptions override the generic traversal. The function |gapp| is defined generically. The code below says: first, check to see if any of the exceptions apply. If not, do the generic traversal. > class (STApply spec a df w, LDat tlab spec a df) > => GAPP tlab spec a df w | tlab spec a -> df w where > gapp :: tlab -> spec -> a -> w > > instance (STApply spec a df w, LDat tlab spec a df) > => GAPP tlab spec a df w where > gapp tlab spec x = stapply spec x (gin tlab spec x) The function |gin| does a generic traversal. It (may) invoke |gapp| on the children of the term, if any (and if the traversal strategy calls for traversing the children). This class is similar to the class Data of SYB: > class LDat tlab spec x w | tlab spec x -> w where > gin :: tlab -> spec -> x -> w However, different traversal strategies of Data are methods of that class: gfold, gunfold, gmapT, etc. Here, different strategies are identified by the label |tlab| and so the set of strategies is _extensible_. In SYB, for each new data type we need to define an instance of Data with several methods. Here, for each new data type we need to define several instances of LDat with one method each. The extensible strategies were discovered when generalizing the classes Dat and TDat in the original Smash approach. The file Syb4A.hs defines the following popular strategies - Reconstruct the term: used in generic mapping > data TL_recon = TL_recon - Reduce the term: used in folding over a term > newtype TL_red w = TL_red ([w]->w) - The same as above but the reducer accepts the name of the term's constructor, a string. This is used for generic show > newtype TL_red_ctr w = TL_red_ctr (String -> [w]->w) - Traverse and reduce two terms in lock-step: we traverse the term (Couple x y) where x and y have the same type, and reduce the result using the supplied function 'f'. This is used for generic equality > data Couple a = Couple a a > data TL_red_lockstep w = TL_red_lockstep w ([w] -> w) The TL_recon strategy is the generalization of fmap. Here are a few instances, for a primitive type and products and recursive sums (list). The analogy with fmap should be obvious. It should also be obvious that the instances below can be automatically generated from the definition of a datatype. That is, LDat instances could be automatically derived. > instance LDat TL_recon spec Int Int where > gin _ spec x = x > instance (GAPP TL_recon spec a dfa wa, GAPP TL_recon spec b dfb wb) > => LDat TL_recon spec (a,b) (wa,wb) where > gin tlab spec (x,y) = (gapp tlab spec x, gapp tlab spec y) > instance (GAPP TL_recon spec [a] [w] [w], GAPP TL_recon spec a dfa w) > => LDat TL_recon spec [a] [w] where > gin tlab spec [] = [] > gin tlab spec (x:xs) = (gapp tlab spec x):(gapp tlab spec xs) We can define the generic gmap in one line: > gmap f = gapp TL_recon (f :+: HNil) It takes a function |f::a->b| and a term and returns a term with all values of the type |a| replaced with the corresponding values of the type |b|. The type of the result is computed. When the input term is a list, gmap is the ordinary map. Given a term > termc = (["ab"],(Just 'c', Just 'd')) we can replace all Chars with their Int equivalents > testc1 = gmap ord termc where ord (c::Char) = fromEnum c *SmashA.Syb4A> testc1 ([[97,98]],(Just 99,Just 100)) Alternatively, we can replace only those Chars that occur in Maybe Char > testc2 = gmap maybeord termc > where maybeord (Just (c::Char)) = Right (fromEnum c) > maybeord Nothing = Left 0 *SmashA.Syb4A> testc2 (["ab"],(Right 99,Right 100)) Unlike the regular fmap, we can fuse two traversals > testc3 = gapp TL_recon (ord :+: maybeord :+: HNil) termc > where maybeord (Just (c::Char)) = Right (fromEnum c) > maybeord Nothing = Left 0 > ord (c::Char) = fromEnum c We can even traverse and replace under functions: > testt3 = gmap (\x -> if x then 'a' else 'b') > ([not], (True,('2',[(&&),(||)]))) whose inferred type is *SmashA.Syb4A> :t testt3 testt3 :: ([Bool -> Char], (Char, (Char, [Bool -> Bool -> Char]))) The source code shows equality on nested data types and various reductions (summing all Ints in a term; finding the size of the term; printing the term, treating Strings differently from other lists, etc). The programmer may introduce a new traversal strategy. For illustration, let us define a lazy version of the strategy TL_con. The motivation is determining the smallest or the largest term of a given type. The first stab at such a generic minimum may be gmin x = gmap (\ (x::Bool) -> False) x which replaces all Bools with the smallest Bool in a sample term x. For example, |gmin (True,False)| should give (False,False). The mapping function is clearly non-strict in its argument, so the same result can be achieved by applying gmin to the sample term (undefined::Bool,undefined::Bool). The sample term merely gives the structure of the desired type -- the structure to traverse. One may observe that we don't even need that! We can apply gmin to the sample term that is just (undefined::(Bool,Bool)) -- hence we don't need to supply any real sample term. The key is that (fst (undefined::(Bool,Bool))) is a correct expression, which evaluates to (undefined::Bool). Hence, "undefined" is deconstructible and traversable, standing for a term of any structure we may want. It can be traversed and mapped with real results -- providing the mapping and traversal functions are not strict. The TL_recon strategy above is strict, however, which is apparent from the instance of LDat for pairs: > gin tlab spec (x,y) = (gapp tlab spec x, gapp tlab spec y) That is easy to fix: just replace (x,y) with an irrefutable match ~(x,y). Alas, the problem is more complex in the case of sums (cf the instance LDat for lists above): > gin tlab spec [] = [] > gin tlab spec (x:xs) = (gapp tlab spec x):(gapp tlab spec xs) If we replace patterns with irrefutable match ~[] and ~(x:xs), then the first alternative will always match, and so the second clause will never be effective. We should recognize that sums give us a choice. We should propagate this choice back to the users: we should report the available alternatives, and let the users make the choice. We arrive thus at the following design, implemented in Syb4ABuild.hs in the DARCS repository above. We define a new traversal label > newtype TL_recon_lazy = TL_recon_lazy (forall a. [a] -> a) where the argument of TL_recon_lazy is a user-supplied choice function. The instance for pairs is simple as we don't have any choice here: > instance (GAPP TL_recon_lazy spec a dfa wa, > GAPP TL_recon_lazy spec b dfb wb) > => LDat TL_recon_lazy spec (a,b) (wa,wb) where > gin tlab@(TL_recon_lazy f) spec ~(x,y) = > f [(gapp tlab spec x, gapp tlab spec y)] We do have the choice for sums, e.g., lists: > instance (GAPP TL_recon_lazy spec [a] [w] [w], > GAPP TL_recon_lazy spec a dfa w) > => LDat TL_recon_lazy spec [a] [w] where > gin tlab@(TL_recon_lazy f) spec x = > f [[], > (gapp tlab spec (head x)):(gapp tlab spec (tail x))] The term to traverse may be either an empty list, or non-empty list. In the latter case, we speculatively map its head and tail. We let the user make the choice. Due to non-strictness, we don't actually traverse anything unless it is required. This lets us define generic minimum simply as > __ = error "nonexistent" > gminimum () = r > where r = gapp (TL_recon_lazy head) lst (__ `asTypeOf` r) > lst = (mb (__::Int)) :+: (mb (__::Bool)) :+: (mb (__::Char)) > :+: HNil > mb :: Bounded t => t -> t -> t > mb _ _ = minBound The definition for gmaximum is similar, modulo replacing minBound with maxBound and head with last. We thus obtain the results mentioned at the beginning. Other examples: > test_gmin3 = gminimum () :: (Maybe Int,[Bool]) *SmashA.Syb4ABuild> test_gmin3 (Nothing,[]) > test_gmax1 = take 5 $ gmaximum () :: [Bool] *SmashA.Syb4ABuild> test_gmax1 [True,True,True,True,True] The presence of "take 5" is telling. The largest term of the type [Bool] is the infinite list of True -- which gmaximum faithfully computes. The function gminimum is akin to the de-typechecker since both convert `undefined' to `defined'. De-typechecker produces only polymorphic functions, whereas gminimum yields data (including monomorphic functions).

1 0