- Haskell - Haskell.org

Missing docs on Debian?
by Yitzchak Gale 06 Sep '05

06 Sep '05

Using Debian testing with the ghc6-doc package installed (version 6.4-3), I just noticed that I only seem to have the "Hierarchical Libraries" manual, but not the "User's Guide" nor the "Cabal" docs (nor hslibs docs). Those links are broken on the "index.html" page that was installed. Did I do something wrong, or is there a reason that those were omitted? Thanks, Yitz

2 3

emacs haskell mode
by Frederik Eaton 06 Sep '05

06 Sep '05

Hi Stefan, Sorry if I've asked this before, but is version 2.0 of haskell-mode on your website really the newest version? I ask because the file haskell-mode.el says "Version: 1.43" in the header, and I thought I remembered certain bugs being fixed which are present in your version. For instance, I thought that "\(x)->x" parsed correctly in the latest version, but in the version 2.0 which you distribute, the backslash is still interpreted incorrectly as escaping the parenthesis. Frederik -- http://ofb.net/~frederik/

3 5

FLOPS 2006 Call for Papers
by Masami Hagiya 06 Sep '05

06 Sep '05

Dear Moderator, Could you consider distributing the following call for papers? -- Masami Hagiya === First Call For Papers Eighth International Symposium on Functional and Logic Programming FLOPS 2006 April 24--26 Fuji Susono, JAPAN Submission deadline: November 11 http://hagi.is.s.u-tokyo.ac.jp/FLOPS2006 FLOPS is a forum for research on all issues concerning declarative programming, including functional programming and logic programming, and aims to promote cross-fertilization between the two paradigms. Previous FLOPS meetings were held in Fuji Susono (1995), Shonan Village (1996), Kyoto (1998), Tsukuba (1999), Tokyo (2001), Aizu (2002), and Nara (2004). TOPICS FLOPS solicits original papers in all areas of functional and logic programming, including (but not limited to): Declarative Pearls: new and excellent declarative programs with illustrative applications; Language issues: language design and constructs, programming methodology, integration of paradigms, interfacing with other languages, type systems, constraints, concurrency and distributed computing; Foundations: logic and semantics, rewrite systems and narrowing, type theory, proof systems; Implementation issues: compilation techniques, memory management, program analysis and transformation, partial evaluation, parallelism; Applications: case studies, real-world applications, graphical user interfaces, internet applications, XML, databases, formal methods, and model checking. For 2006, we wish to particularly encourage papers on new application areas, including security, bioinformatics, and quantum computation. The proceedings will be published as a LNCS volume. The proceedings of the previous meeting (FLOPS2004) were published as LNCS2998. SUBMISSION Submissions must be unpublished and not submitted for publication elsewhere. Work that already appeared in unpublished or informally published workshops proceedings may be submitted. Submissions should fall into one of the following categories: Regular research papers: they should describe new results and will be judged on originality, correctness and significance. System descriptions: they should contain a link to a working system and will be judged on originality, usefulness and design. All submissions must be written in English and can be up to 15 proceedings pages long. Authors are strongly encouraged to use LaTeX2e and the Springer llncs class file, available at http://www.springer.de/comp/lncs/authors.html Regular research papers should be supported by proofs and/or experimental results. In case of lack of space, this supporting information should be made accessible otherwise (e.g. a link to a web page, or an appendix). Submission is Web-based and under preparation. Please visit http://hagi.is.s.u-tokyo.ac.jp/FLOPS2006/ INVITED SPEAKERS Peter Van Roy (Louvain, Belgium) other speakers to be decided CO-CHAIRS Philip Wadler (Edinburgh, UK) Masami Hagiya (Tokyo, Japan) PC MEMBERS Peter Selinger (Dalhousie, Canada) Manuel Hermenegildo (New Mexico & Madrid, US & Spain) Eijiro Sumii (Tohoku, Japan) Konstantinos Sagonas (Uppsala, Sweden) Jacques Garrigue (Nagoya, Japan) Peter Thiemann (Freiburg, Germany) David Warren (Stony Brook, US) Gabrielle Keller (UNSW, Sydney, Australia) Alain Frisch (INRIA Roquencourt, France) Veronica Dahl (Simon Fraser, Canada) Ken Satoh (NII, Tokyo, Japan) Naoyuki Tamura (Kobe, Japan) Michael Rusinowitch (INRIA Lorraine, France) Vincent Danos (Paris, France) IMPORTANT DATES Submission deadline: November 11 Author notification: January 6 Camera-ready copy: January 20 PLACE The meeting will be held at Fuji Institute of Education and Training (http://www.fujiken.gr.jp/) located in Fuji Susono, JAPAN, where the first FLOPS was held. It is famous of its view to Mt. Fuji. Previous FLOPS: FLOPS 2004, Nara: http://logic.is.tsukuba.ac.jp/FLOPS2004/ FLOPS 2002, Aizu: http://www.ipl.t.u-tokyo.ac.jp/FLOPS2002/ FLOPS 2001, Tokyo: http://www.ueda.info.waseda.ac.jp/flops2001/ SPONSOR University of Tokyo IN COOPERATION (pending) ACM SIGPLAN Japan Society for Software Science and Technology (JSSST) Association for Logic Programming (ALP) Asian Association for Foundation of Software (AAFS) INQUIRIES to Masami Hagiya hagiya(a)is.s.u-tokyo.ac.jp

1 0

FunDeps and MArray
by Scherrer, Chad 05 Sep '05

05 Sep '05

Hi, I'm trying to use functionally dependent typeclasses to create an overloaded (+=) function. A simplified example of a first bit of code is... class PlusEq a b c | a b -> c where (+=) :: a -> b -> c instance (MArray a e m, Num e, Ix i) => PlusEq (a i e) (a i e) (m ()) where (+=) x y = let updateX i = do xi <- readArray x i yi <- readArray y i writeArray x i (xi + yi) in sequence_ . map updateX $ indices x I keep getting this error in GHCi: Illegal instance declaration for `PlusEq (a i e) (a i e) (m ())' (the instance types do not agree with the functional dependencies of the class) In the instance declaration for `PlusEq (a i e) (a i e) (m ())' Failed, modules loaded: none. Looking at GHC's documentation for MArray, the definition starts out class (HasBounds a, Monad m) => MArray a e m where ... It seems to me if MArray were written using fundeps (something like MArray a e m | a e -> m) things may work out. Is there a reason it's not written this way? If so, is there another way to do what I'm trying to do? Thanks. Chad Scherrer Computational Mathematics Group Pacific Northwest National Laboratory "Time flies like an arrow; fruit flies like a banana." -- Groucho Marx

2 1

SVV'05 CFP: INTERNATIONAL WORKSHOP ON SOFTWARE VERIFICATION AND VALIDATION
by Zijiang (James) Yang 05 Sep '05

05 Sep '05

-------------------------------------------------------------------------------- CALL FOR PAPERS SVV'05: 3RD INTERNATIONAL WORKSHOP ON SOFTWARE VERIFICATION AND VALIDATION October 31, 2005 Manchester, UK http://www.cs.wmich.edu/~zijiang/svv2005/ In Conjunction with International Conference on Formal Engineering Methods (ICFEM'05) -------------------------------------------------------------------------------- Goal of the Workshop Software is playing an important role in economy, government, and military. Since software is often deployed in safety critical applications, correctness and reliability have become issues of utmost importance. Techniques for verification and validation traditionally fall into three main categories. The first category involves informal methods such as software testing and monitoring. The second involves formal verification, i.e., model checking and theorem proving. The third is abstract interpretation and static program analysis techniques. The goal of this workshop is to promote discussion on novel combinations of these methodologies, as well as study the individual contribution of each of these methodologies in verifying software. An example of a combined verification methodology is the recent research direction that combines abstraction (of infinite-state programs into finite-state ones) with model checking (of finite-state systems). There is a growing conviction in the research community that such hybrid methodologies are imperative for the process of analyzing full-fledged software systems. This workshop will study combination of analysis methodologies for verification of software. This research is very important and timely since . Software is being increasingly used to control embedded systems which are often safety critical (such as automobile parts). . There is renewed promise in program verification in the recent years due to (a) progress in generating models from code, and (b) combination of model checking with other analysis techniques such as abstract interpretation. Topics Covered The workshop will focus on theoretical techniques, practical methods as well as case studies for verification of conventional and embedded software systems. In particular, we welcome papers which describe combinations of formal and informal reasoning, as well as formal verification and program analysis techniques. Tool papers and case studies, which report on advances in verifying large scale programs in standard languages are particularly sought. The list of topics include, but are not restricted to: . Tools, environments and case studies for large scale software verification . Static analysis/Abstract interpretation/Program transformations for verification . Use of model checking and deductive techniques for software verification . Role of declarative programming languages (such as Prolog) for infinite state software verification. . Techniques to validate system software (such as compilers) as well as assembly code/Java bytecode . Proof techniques for verifying specific classes of software (such as object-oriented programs) . Integrating testing and run-time monitoring with formal techniques . Validation of UML diagrams, and/or requirement specifications . Software certification and proof carrying code . Integration of formal verification into software development projects Submissions Information . Regular submissions should be no more than 15 pages. Short papers (upto 5 pages) describing initial ideas are also welcome. All submitted papers should be in PS or PDF. Please avoid using zip, gzip, compress, tar etc. Papers should be submitted via e-mail to zijiang.yang(a)wmich.edu . The workshop proceeding will be published as Electronic Notes in Theoretical Computer Science (ENTCS). Note that ENTCS papers should be at least 10 pages in ENTCS format. . The deadlines are as follows. . Submission deadline: September 30, 2005 . Notification of Acceptance: October 14, 2005 . Final Version submission: October 21, 2005 Program Committee . Rajeev Alur (University of Pennsylvania, USA) . Tevfik Bultan (University of California, Santa Barbara, USA) . Sandro Etalle (University of Twente, Netherlands) . Daniel Kroning (ETH Zurich, Switzerland) . Lunjin Lu (Oakland University, USA) . C. R. Ramakrishnan (SUNY Stony Brook, USA) . Chao Wang (NEC Laboratories, USA) . Farn Wang (National Taiwan University, Taiwan) . Yi Wang (Uppsala University, Sweden) . Lintao Zhang (Micosoft Research, USA) Invited Speakers . TBA Organizers . Supratik Mukhopadhyay, West Virginia University, USA. . Abhik Roychoudhury, National University of Singapore, Singapore. . Zijiang Yang, Western Michigan University, USA (Workshop Co-ordinator). If you have any queries about the workshop, please send e-mail to zijiang.yang(a)wmich.edu

1 0

ANNOUNCE: h4sh - Haskell functions for shell scripting
by dons＠cse.unsw.edu.au 04 Sep '05

04 Sep '05

h4sh -- Haskell functions for shell scripting Unix is all about programs that do one thing, and one thing well. Unfortunately, over time, the common unix text processing commands have become bloated and silly, with rather arbitrary features for programs that should have simple semantics (consider uniq and wc outputting leading space, or cut indexing fields from 1, just for starters). On the other hand Haskell has a powerful and beautiful List library for processing text as lists of strings. h4sh exposes the Haskell List library as a set of shell utilities. Utilising function composition via pipes, we can transparently program in Haskell, in the shell :) Commands are generated from a description of their type. Higher order functions like map are handled using runtime evaluation, provided by the hs-plugins System.Eval library, allowing arbitrary Haskell code to be provided as arguments to, for example, map and filter. A (contrived) example: take -n 100 f | id | map -e show.length | filter -e '/= "0"' | sort | reverse | head Get it: http://www.cse.unsw.edu.au/~dons/h4sh.html darcs get --partial http://www.cse.unsw.edu.au/~dons/code/h4sh -- Don Stewart

1 1

Extended Deadline - ACM SAC'06: Software Verification
by l2lu＠oakland.edu 02 Sep '05

02 Sep '05

---------------------------------------------------------------- CALL FOR PAPERS Software Verification Track ACM Symposium on Applied Computing April 23-27, 2006, Dijon, France http://www.cs.wmich.edu/~zijiang/sac2006 ***PAPER SUBMISSION DEADLINE: September 15, 2005**** ----------------------------------------------------------------- 1. SAC 2006 For the last twenty years, the ACM Symposium on Applied Computing has been a primary gathering forum for applied computer scientists, computer engineers, software engineers, and application developers from around the world. SAC 2006 is sponsored by the ACM Special Interest Group on Applied Computing, and is hosted this year by Bourgogne University, Dijon, France. 2. Technical track on software verification In the next decade the software industry will have to face its responsibility imposed by a computer-dependent society. Since software is increasing deployed in safety critical applications, correctness and reliability are becoming issues of utmost importance. Consequently, software verification will be a grand challenge for both academic world and computer industry. The track will focus on theoretical foundations, practical methods as well as case studies for verification of conventional and embedded software. We welcome papers that describe work on combinations of formal verification and program analysis techniques. Tool papers and case studies which report on advances in verifying large software systems are particularly sought. The list of topics includes but not limited to . Tools, and case studies for large scale software verification . Static analysis/Abstract interpretation for verification . Model checking and deductive techniques for software verification . Role of declarative programming languages (such as Prolog) for infinite state software verification. . Proof techniques for verifying specific classes of software . Integration of testing and run-time monitoring with formal techniques . Validation of UML diagrams, and/or requirement specifications . Software certification and proof carrying code . Integration of formal verification into software development projects 3. Guidelines for paper submission Each paper must not exceed 4,000 words and should not be more than 15 pages long using 11 point font and 1 inch margins on all four sides on letter size paper. Papers that fail to comply with length limitations risk rejection. Each submitted paper will be fully referenced and undergo a blind review process. Author(s) must not be identified in the submissions, either explicitly or by implication. Before submitting paper, author(s) should submit a separate cover page that includes title, abstract, list of keywords, and list of authors with full names and postal addresses, telephone numbers, fax numbers, and e-mail addresses. One of the authors must be designated as the primary contact person. Please upload the cover page via http://milo.cs.iupui.edu/sac2006/SubmitAbstract.aspx?TrackID=62. A confirmation email with further instructions on paper submission will be sent to the contact author. Please contact track chairs or Jeff Allen (jallen(a)cs.iupui.edu) for any problems with submission. Authors of accepted papers must submit an editorial revision of their papers that must fit within five two-column pages following the ACM proceedings format (an extra three extra pages may be available at additional cost to the authors). At least one of the authors of an accepted paper must register for the conference and present the paper. Accepted papers will be published in the ACM SAC 2006 proceedings. 4. Important dates . Electronic submission of full papers: September 15, 2005 . Notification of paper acceptance: October 15, 2005 . Camera-ready copy of accepted paper due: November 5, 2005 5. Program Committee . Franjo Ivancic, NEC Labs America, Inc, U.S.A. . Radu Grosu, SUNY-Stony Brook, U.S.A. . Francesco Logozzo, Ecole Polytechnique, France . Lunjin Lu(Co-Chair), Oakland University, U.S.A. . Madhusudan Parthasarathy, UIUC, U.S.A. . Robby, Kansas State University, U.S.A. . Abhik Roychoudhury, National Univ. Singapore . Fausto Spoto, Univ. di Verona, Italy . Frank Stomp, Wayne State University ,U.S.A. . Zijiang Yang(Co-Chair), Western Michigan University, U.S.A. . Tian Zhao, University of Wisconsin-Milwaukee, U.S.A

1 0

Rewriting Calculi and Higher-Order Reductions - special issue of MSCS
by Horatiu Cirstea 01 Sep '05

01 Sep '05

CALL FOR PAPERS Mathematical Structures in Computer Science, Special Issue on Rewriting Calculi and Higher-Order Reductions Following from the success of the workshops on rewriting calculus, there will be a special issue of the journal Mathematical Structures in Computer Science (MSCS, Cambridge University Press) on Rewriting Calculi and Higher-Order Reductions. Submissions for this special issue are hereby solicited. The integration of first-order and higher-order paradigms has been one of the main problems raised since the beginning of the study of programming language semantics and of proof environments. This has been handled either by enriching first-order rewriting with higher-order capabilities or by adding to lambda-calculus algebraic features. The rewriting calculus has been introduced as a general means to uniformly integrate rewriting and lambda calculus. This calculus makes explicit and first-class all of its components: matching (possibly modulo given theories), abstraction, application and substitutions. The rewriting calculus is designed and used for logical and semantical purposes. It could be used with powerful type systems and for expressing the semantics of rule based as well as object oriented paradigms. It allows one to naturally express exceptions and imperative features as well as expressing elaborated rewriting strategies. This special issue of the MSCS will be devoted to the foundations of the rewriting calculus and of related systems combining matching and higher-order features. Topics for the special issue include, but are not limited to, the following aspects of these calculi: - operational semantics, - type systems, - models, - associated logics, - implementation issues, - applications. Submissions should be sent electronically to rho-editors(a)loria.fr by 15th January 2006 (all submissions will be acknowledged). Information about the journal, including style files, can be found at: http://www.cambridge.org/uk/journals/journal_ifc.asp?mnemonic=MSC Submissions will be refereed according to the usual very high standards of MSCS. Horatiu Cirstea and Maribel Fernandez will serve as guest editors for this special issue. Final decisions on editorial matters rest with the editor-in-chief of MSCS.

1 0

[CfP] Special Issue on Answer Set Programming (ASP) in Annals of Mathematics and Artificial Intelligence
by Juergen Dix 01 Sep '05

01 Sep '05

[we apologize for multiple copies of this e-mail] ---------------------------------------------------------------------- Call for Papers: Special Issue on Answer Set Programming (ASP) in Annals of Mathematics and Artificial Intelligence http://cig.in.tu-clausthal.de/ASP06/ * Special Issue Editors: Gerhard Brewka (University of Leipzig, Germany) Juergen Dix (Clausthal University of Technology, Germany) * About the Special Issue: Answer set programming (ASP) is a promising declarative programming paradigm which has proven to be successful in a variety of areas such as planning, diagnosis, configuration and space shuttle control. It emerged from deductive databases as wellas from non-monotonic reasoning. Answer sets are sets of literals representing intended models of generalized logic programs with two types of negation. They were introduced by Gelfond and Lifschitz and generalize stable models to more expressive logic programs. The basic idea underlying ASP is to represent a problem in a way such that answer sets correspond to solutions of the problem. A Working Group on ASP funded by the EC (http://wasp.unime.it/) coordinates and represents most of the work on ASP done in Europe. We invite papers describing original research advancing the state of the art in ASP. Contributions may range from theoretical foundations (e.g. language extensions, first order programs) to implementation methods (e.g. new answer set generation methods, intelligent grounding or related heuristics) and innovative applications (e.g. information extraction, agent technology,dynamic systems). In particular applications showing that ASP scales up or is competing with special-purpose techniques are welcome. * Relevant topics include the following (but are not limited to): - Foundations of ASP - Systems of ASP - Algorithms and heuristics - Language extensions (aggregates, preferences , etc.) - Integrated approaches (description logic, constraints, etc.) - ASP methodology (modularization, debugging etc.) - Planning in ASP - Knowledge representation in ASP - Innovative applications (bioinformatics, linguistics, etc.) * Submission Details: We are expecting full papers to describe original, previously unpublished research, be written in English, and not be simultaneously submitted for publication elsewhere (previous publication of partial results at workshops with informal proceedings is allowed). Papers should be formatted according to the Instructions for AMAI submissions and should be between 20 and 40 pages long. (www.springeronline.com/journal/10472/submission) Please submit a PDF file of your paper by the 1st of December2005 at http://cig.in.tu-clausthal.de/ASP06/ (click on Submissions: you can enter your paper into the easychair system provided by Andrei Voronkov). * Important Dates: Submission Deadline: December 1, 2005 Author Notification: February 1, 2006 Final Paper Deadline: April 1, 2006 Special Issue: Fall 2006 * About the special issue editors: Gerhard Brewka is Professor for Intelligent Systems at Leipzig University (Germany) since 1996. Before that he was Professor for Knowledge-Based Systems at Technical University of Vienna. He is director of the Leipzig doctoral programme in Knowledge Representation. His research interests include knowledge representation, nonmonotonic reasoning, inconsistency handling, preference models and logic programming. Juergen Dix is Professor for Computational Intelligence at Clausthal University of Technology (Germany) (http://cig.in.tu-clausthal.de/) He is also member of the CS Department at the Technical University of Vienna, and honorary member at The University of Manchester, where he lived from 2000-2003. Since 1989 he is working in several areas of Computational Logic (nonmonotonic reasoning, logic programming, deductive databases, knowledge representation) and, in the past 7 years, also in Multi-Agent Reasoning. * About the journal: Annals of Mathematics and Artificial Intelligence (AMAI) is devoted to reporting significant contributions on the interaction of mathematical and computational techniques reflecting the evolving disciplines of artificial intelligence: http://www.informatik.uni-trier.de/~ley/db/journals/amai/. Annals of Mathematics and Artificial Intelligence publishes edited volumes of original manuscripts, survey articles, monographs and well refereed conference proceedings of the highest caliber within this increasingly important field. All papers will be subject to the peer reviewing process with at least two referees per paper. ------------------------------------------------------------------------ This e-mail was delivered to you by event(a)in.tu-clausthal.de, what is a moderated list runned by Computational Intelligence Group of Technical University of Clausthal, Germany. All event announcements sent through this list are also listed in our conference planner at http://cig.in.tu-clausthal.de/index.php?id=planner. In the case of any requests, questions, or comments, do not hesitate and contact event-owner(a)in.tu-clausthal.de ASAP. ****************************************************** * CIG does not take any responsibility for validity * * of content of messages sent through this list. * ****************************************************** Computational Intelligence Group Institute of Informatics Technical University Clausthal Germany http://cig.in.tu-clausthal.de/

1 0

How to use STArray?
by oleg＠pobox.com 01 Sep '05

01 Sep '05

Benjamin Franksen wrote: > On Thursday 25 August 2005 19:58, Udo Stenzel wrote: > > [...] you'll need a type signature somewhere to help ghc resolve > > the overloading of newArray and readArray, which is surprisingly > > tricky due to the "s" that must not escape. This works: > > > > compute :: Int -> Int > > compute n = runST ( do > > arr <- newArray (-1, 1) n :: ST s (STArray s Int Int) > > readArray arr 1 > > ) > I am fighting with a similar problem. I want to use STUArray but > without committing to a fixed element type. That problem has been addressed in a message http://www.haskell.org/pipermail/haskell-cafe/2004-July/006400.html which discussed several solutions. Given below is one of the solutions adjusted to fit the question of the original poster. His code is almost unchanged. It would havebeen nice if the GHC library supported the second solution, a class Unpackable. Currently there are instances of MArray (STUArray s) e (ST s) and IArray UArray e for exactly the same set of types `e'. Alas, that condition is not stated formally, so we cannot infer that MArray (STUArray s) e (ST s) holds whenever IArray UArray e does. > {-# OPTIONS -fglasgow-exts #-} > > module Foo where > > import Data.Array.Unboxed > import Data.Array.ST > import Control.Monad.ST > > data Allocator m i e = forall a. MArray a e m => > Allocator ((i, i) -> m (a i e)) > > > copy :: (MArray a e m, IArray b e) => > a Int e -> Int -> b Int e -> Int -> Int -> m () > copy dest destix src srcix cnt > | cnt <= 0 = return () > | otherwise = do > writeArray dest destix (src ! srcix) > copy dest (destix+1) src (srcix+1) (cnt-1) > append :: (IArray UArray e, STUGood e) => > UArray Int e -> UArray Int e -> Int -> UArray Int e > append x y low = > runST (case allcg of Allocator newArray_ -> > (do > z <- newArray_ (low,low+len x+len y) > copy z low x (first x) (len x) > copy z (low+len x) y (first y) (len y) > unsafeFreeze z)) > where > len = rangeSize . bounds > first = fst . bounds > > class STUGood e where > allcg::Ix i => Allocator (ST s) i e > > instance STUGood Bool where > allcg = Allocator (newArray_:: Ix i => (i,i) -> ST s (STUArray s i Bool)) > > instance STUGood Float where > allcg = Allocator (newArray_:: Ix i => (i,i)-> ST s (STUArray s i Float)) > > -- etc. > > test = > append (listArray (1,1) [True]) (listArray (1,1) [False]) 0

2 2