- Haskell - Haskell.org

Fixed-length vectors in Haskell, Part 1: Using GADTs
by David Menendez 08 May '05

08 May '05

I wrote this up a few days ago and thought I'd share it with the list. It's yet another implementation of fixed-length vectors (that is, lists which reflect their length in their type). It's a nice demonstration of GADTs and an unexpected use of a technique Ralf Hinze describes in "Generics for the Masses". -- This is the first of two modules implementing fixed-length vectors in Haskell. This one uses Generalized Algebraic Datatypes (GADTs), a recent extension currently only available in GHC 6.4. The second will implement the same functions using no extensions to Haskell 98. This message is literate Haskell. To use, save it as "Vector_GADT.lhs". > {-#OPTIONS -fglasgow-exts #-} > module Vector_GADT where (Note: The Arrow Transformer Library[1] includes a class for "Sequences"[2], which lie between functors and monads in terms of power. If you have the arrows package installed, change the lines beginning with "*>" to ">" to use the instance declared here.) [1] <http://haskell.org/arrows/download.html> [2] <http://haskell.org/arrows/arrows/Control.Sequence.html> *> import Control.Sequence We want to create a type for vectors where the length of the vector is reflected in its type. We start by defining type-level naturals: > data Zero > data Succ n These don't need data constructors because they will only appear as phantom types. Some aliases for convenience: > type One = Succ Zero > type Two = Succ One > type Three = Succ Two > type Four = Succ Three Next, the vectors themselves: > data Vec n a where > Nil :: Vec Zero a > Cons :: a -> Vec n a -> Vec (Succ n) a The first argument to Vec represents the length of the vector. Nil constructs empty vectors (length zero), and Cons adds an element to a vector of length n, creating one of length n+1. It's possible to declare head and tail as total functions by indicating with their types that they require vectors with non-zero lengths: > vhead :: Vec (Succ n) a -> a > vhead (Cons x xs) = x > > vtail :: Vec (Succ n) a -> Vec n a > vtail (Cons x xs) = xs Similarly, we can declare a version of zipWith which requires its vector arguments to have the same length: > vzipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c > vzipWith f Nil Nil = Nil > vzipWith f (Cons x xs) (Cons y ys) = Cons (f x y) (vzipWith f xs ys) Some other useful functions: > vfoldr :: (a -> b -> b) -> b -> Vec n a -> b > vfoldr f z Nil = z > vfoldr f z (Cons x xs) = f x (vfoldr f z xs) > > toList :: Vec n a -> [a] > toList = vfoldr (:) [] > > inner :: Num a => Vec n a -> Vec n a -> a > inner x y = vfoldr (+) 0 (vzipWith (*) x y) Note that we can't type "vfoldr Cons Nil", because the result type of Cons does not match the second argument. Here's an instance for Functor. > instance Functor (Vec n) where > fmap f Nil = Nil > fmap f (Cons x xs) = Cons (f x) (fmap f xs) We would like a function "vec :: a -> Vec n a", such that "vec x" returns a vector of length n with every element equal to x. The basic algorithm is simple: vec{0} x = Nil vec{n+1} x = Cons x (vec{n} x) The usual way to declare a function like this involves a type class, which lets us define functions with different behaviors for different types: class Nat n where vec :: a -> Vec n a instance Nat Zero where vec x = Nil instance Nat n => Nat (Succ n) where vec x = Cons x (vec x) This gives vec the type "Nat n => a -> Vec n a", which is good because it points out that the type argument to Vec must be a natural, formed from Zero or Succ applied to another natural. However, this solution is unsatisfactory, because it requires the Nat class to include every possible function which might depend on a type-level argument. The solution is a technique Ralf Hinze describes in "Generics for the Masses"[3]: create another class for functions which depend on the type parameter. [3] <http://www.informatik.uni-bonn.de/~ralf/publications.html#P21> Thus: > class Nat n where > natCase :: NatCase g => g n > > class NatCase g where > caseZero :: g Zero > caseSucc :: Nat n => g (Succ n) > > instance Nat Zero where natCase = caseZero > instance Nat n => Nat (Succ n) where natCase = caseSucc If you're unfamiliar with Mr Hinze's technique, this may seem pretty opaque. The idea is to give each function that depends on a natural type parameter a distinct type, using newtype, and then give the member functions for caseZero and caseSucc as the cases where the parameter is Zero and Succ n, respectively. For example, here is the code for vec: > newtype MkVec a n = MkVec { runMkVec :: a -> Vec n a } > > vec :: Nat n => a -> Vec n a > vec = runMkVec natCase > > instance NatCase (MkVec a) where > caseZero = MkVec (\x -> Nil) > caseSucc = MkVec (\x -> Cons x (vec x)) Here's another function, which converts a list to a vector, provided the list is long enough: > newtype FromList a n = FromList > { runFromList :: [a] -> Maybe (Vec n a) } > > fromList :: Nat n => [a] -> Maybe (Vec n a) > fromList = runFromList natCase > > instance NatCase (FromList a) where > caseZero = FromList (\l -> Just Nil) > caseSucc = FromList (\l -> case l of > x:xs -> fmap (Cons x) (fromList xs) > [] -> Nothing > ) WIth this technique we can create as many functions which have type-specific behavior for naturals as we need, without having to create new classes or member functions. With vec, we can make Vec n an instance of Sequence, from the Arrow Transformer Library: *> instance Nat n => Sequence (Vec n) where *> lift0 = vec *> lift2 = vzipWith In fact, we can go further and make Vec n a monad. Since we already have fmap, we just need an equivalent to join; that is, a function that takes a vector of vectors, and returns a vector. One possibility is to take the nth element of the nth vector, like so: > diag :: Vec n (Vec n a) -> Vec n a > diag Nil = Nil > diag (Cons x xs) = Cons (vhead x) (diag (fmap vtail xs)) > > instance Nat n => Monad (Vec n) where > return = vec > m >>= k = diag (fmap k m) This might make the Sequence instance seem superfluous, since 'lift0' and 'lift2' correspond to 'return' and 'liftM2', respectively, but 'lift2' is able to take advantage of the vector's structure in a way that 'liftM2' cannot. Thus, lift2 is O(n), whereas liftM2 has three calls to diag, which is O(n^2). ('fmap' is better than 'liftM' for similar reasons.) More interestingly, we can make Vec n a an instance of Num: > instance Show a => Show (Vec n a) where show = show . toList > > instance Eq a => Eq (Vec n a) where > Nil == Nil = True > Cons x xs == Cons y ys = x == y && xs == ys > > -- alternately, x == y = vfoldr (&&) True (vzipWith (==) x y) > > instance (Nat n, Num a) => Num (Vec n a) where > (+) = vzipWith (+) > (*) = vzipWith (*) > (-) = vzipWith (-) > negate = fmap negate > abs = fmap abs > signum = fmap signum > fromInteger = vec . fromInteger This gives us element-wise arithmetic on equal-sized vectors and scalar arithmetic. *Vector_GADT> let v = Cons 1 (Cons 2 (Cons 3 (Cons 4 Nil))) *Vector_GADT> v [1,2,3,4] *Vector_GADT> 3 + v [4,5,6,7] *Vector_GADT> 3 * v [3,6,9,12] *Vector_GADT> v + v [2,4,6,8] *Vector_GADT> v * v [1,4,9,16] Using fixed-length vectors, we can create matrices which are guaranteed to be rectangular. > type Matrix m n a = Vec m (Vec n a) > > mat :: (Nat m, Nat n) => a -> Matrix m n a > mat x = vec (vec x) > > fromLists :: (Nat m, Nat n) => [[a]] -> Maybe (Matrix m n a) > fromLists xs = mapM fromList xs >>= fromList > > row :: Vec n a -> Matrix One n a > row v = Cons v Nil > > col :: Vec n a -> Matrix n One a > col = fmap (\x -> Cons x Nil) Because matrices are just vectors of vectors, the old instances for Eq, Show, and Num still apply. *Vector_GADT> let Just (m::Matrix Two Two Int) = fromLists [[1,2],[3,4]] *Vector_GADT> m [[1,2],[3,4]] *Vector_GADT> m + 1 [[2,3],[4,5]] *Vector_GADT> m * m + m == m * (m + 1) True We can define functions to transpose and multiply matrices that guarantee the dimensions will work out. > transpose :: Nat n => Matrix m n a -> Matrix n m a > transpose Nil = vec Nil > transpose (Cons x xs) = vzipWith Cons x (transpose xs) > > mult :: (Nat n, Num a) => Matrix k m a -> Matrix m n a -> Matrix k n a > mult x y = fmap (\r -> fmap (inner r) y') x > where y' = transpose y *Vector_GADT> row v `mult` col v [[30]] *Vector_GADT> col v `mult` row v [[1,2,3,4],[2,4,6,8],[3,6,9,12],[4,8,12,16]] We can even define a zero-argument function that creates an identity matrix of the appropriate size. > newtype IdMat a n = IdMat { runIdMat :: Matrix n n a } > > idMat :: (Nat n, Num a) => Matrix n n a > idMat = runIdMat natCase > > instance Num a => NatCase (IdMat a) where > caseZero = IdMat Nil > caseSucc = IdMat (Cons (Cons 1 (vec 0)) (fmap (Cons 0) idMat)) *Vector_GADT> idMat :: Matrix Four Four Int [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]] *Vector_GADT> idMat :: Matrix Two Three Int <interactive>:1:0: Couldn't match `One' against `Zero' Expected type: Matrix Two Three Int Inferred type: Matrix Two Two a In the expression: idMat :: Matrix Two Three Int In the definition of `it': it = idMat :: Matrix Two Three Int -- David Menendez <zednenem(a)psualum.com> <http://www.eyrie.org/~zednenem/>

1 0

Proposal: Relative Module Imports
by S. Alexander Jacobson 08 May '05

08 May '05

Problem: We need a way to simplify module imports. Problem details: * Hierarchical module names are getting really long (including a functional area, a package name, and a module name). * People typically import multiple modules from areas close to each other in the hierarchical module namespace (especially in the case of intra-package imports). * Long module names are required even for non-exposed modules because a program may contain only one module with a given name (regardless of its visibility). Idea: Allow module relative imports in a manner that does not break any existing code. Proposal: * Use preceding dots to indicate that module name is relative * Use from keyword to specify a different relative base. Example: Dot relative syntax Translation ------------------- ----------- module Text.Space.Foo.M where module Text.Space.Foo.M where import .M2 import Text.Space.Foo.M2 as M2 import ..Bar.Baz import Text.Space.Bar.Baz as Bar.Baz import Data.Set import Data.Set from ...HaXML.XML import .Types import Text.HaXML.XML.Types as Types import .Escape import Text.HaXML.XML.Escape as Escape import .Pretty import Text.HaXML.XML.Pretty as Pretty I believe that the proposed syntax is much more concise and readable than the current equivalent. -Alex- ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com

3 4

Re: [Haskell] Should inet_ntoa Be Pure?
by Axel Simon 08 May '05

08 May '05

On 5/7/05, Dominic Steinitz <dominic.steinitz(a)blueyonder.co.uk> wrote: > > Does anyone know why these are in the IO monad? Aren't they pure functions > > converting between dotted-decimal strings and a 32-bit network byte ordered > > binary value? I guess the answer is no for both: The first one can fail and the second one overwrites a fixed string buffer (yuck!). From the man page: The return value from inet_ntoa() points to a buffer which is overwritten on each call. This buffer is implemented as thread-specific data in multithreaded applications. Hence ntoa needs to be an IO action so that the value is read immediately before the next ntoa call is executed. What you could do is to apply unsafePerformIO to > On Sat, 2005-05-07 at 13:40 +0200, David Sankel wrote: > Below is the relevant source code. [..] > inet_ntoa :: HostAddress -> IO String > inet_ntoa haddr = do > pstr <- c_inet_ntoa haddr > peekCString pstr function which is safe. Both function should probably be deprecated in favour of ntop and pton since only these can also deal with IPv6 addresses. Furthermore ntop can be a pure function as it takes a 46-byte string buffer as argument. Axel.

2 1

Should inet_ntoa Be Pure?
by Dominic Steinitz 07 May '05

07 May '05

Does anyone know why these are in the IO monad? Aren't they pure functions converting between dotted-decimal strings and a 32-bit network byte ordered binary value? Dominic. http://www.haskell.org/ghc/docs/latest/html/libraries/network/Network.Socke… http://www.haskell.org/ghc/docs/latest/html/libraries/network/Network.Socke…

2 1

RE: [Haskell] Proposal: Relative Module Imports
by Simon Marlow 07 May '05

07 May '05

On 03 May 2005 22:13, S. Alexander Jacobson wrote: > Problem: We need a way to simplify module imports. > > Problem details: > > * Hierarchical module names are getting really long (including a > functional area, a package name, and a module name). > > * People typically import multiple modules from areas close to each > other in the hierarchical module namespace (especially in the case of > intra-package imports). > > * Long module names are required even for non-exposed modules because > a program may contain only one module with a given name (regardless of > its visibility). > > Idea: Allow module relative imports in a manner that does not break > any existing code. > > Proposal: > > * Use preceding dots to indicate that module name is relative > * Use from keyword to specify a different relative base. > > Example: > > Dot relative syntax Translation > ------------------- ----------- > module Text.Space.Foo.M where module Text.Space.Foo.M where > import .M2 import Text.Space.Foo.M2 as M2 > import ..Bar.Baz import Text.Space.Bar.Baz as Bar.Baz > import Data.Set import Data.Set > from ...HaXML.XML > import .Types import Text.HaXML.XML.Types as Types > import .Escape import Text.HaXML.XML.Escape as > Escape import .Pretty import Text.HaXML.XML.Pretty > as Pretty > > I believe that the proposed syntax is much more concise and readable > than the current equivalent. I was sure something like this had been suggested before, and in fact several similar schemes have. Here's a couple of starters: http://www.haskell.org/pipermail/libraries/2001-February/000268.html http://www.haskell.org/pipermail/libraries/2001-March/000322.html Why haven't we ever implemented anything like this? A good question, with no really good answer. I think it's a combination of (a) the current situation isn't *really* hurting that much (b) the current situation is *really* easy to describe and implement (c) none of the proposed solutions are obviously the right thing (e.g. the '.' prefixes look a little obscure, IMO). and from my perspective: (d) I hoped that something like grafting would provide a more general solution. Oh, and there was a recent proposal on the libraries list to allow exporting of qualified names, which solves a similar/overlapping problem: http://www.haskell.org/pipermail/libraries/2005-March/003390.html FWIW, I think this proposal ended in a reasonable result. It just needs someone to implement it... Cheers, Simon

2 1

Final Call for Papers: IFM 2005
by Graeme Smith 05 May '05

05 May '05

FINAL CALL FOR PAPERS Fifth International Conference on Integrated Formal Methods (IFM) November 29 - December 2, 2005 Eindhoven, The Netherlands http://www.win.tue.nl/ifm/ SCOPE Applying formal methods may involve the modeling of different aspects of a system that are expressed through different paradigms. This motivates us to research the combination of different viewpoints upon a system, either by the creation of hybrid notations, by extending existing notations, by translating between notations, or by incorporating a wider perspective by innovative use of an existing notation. The integration of formal methods has already yielded noteworthy benefits for systems modeling and software development. Whichever approach is taken, significant issues arise in areas such as semantic integration, the tractability of our notations, the integration of tool support, the integration of proof systems, consistency and completeness. Issues arise equally in our conceptualization of systems at different levels of abstraction and the development of these conceptualizations through the process of refinement. The scope of IFM2005 includes all aspects of integration of different formal notations, paradigms and tools, and also the formal strengthening of informal notations (e.g., UML). The conference also seeks and welcomes contributions in related areas such as: hybrid systems, the embedding of one formalism within another, and the integration of formal methods with informal or semi-formal diagrammatic notations and structuring techniques. SUBMISSIONS Submissions should be original work, not published or submitted elsewhere. Submissions may be up to 20 pages in length and are preferably prepared with LaTeX. Springer Verlag will publish the conference proceedings in the series 'Lecture Notes in Computer Science', hence submissions must be prepared according to the LNCS author instructions (see http://www.springer.de/comp/lncs/authors.html) The first page of the paper should contain an abstract of the paper, a list of keywords, the names, affiliations and emails of the authors. The contact authors should further provide their fax numbers as well as their phone numbers. The format for submitted papers and final versions is PDF or PostScript. For final versions, sources will have to be provided as well (including an RTF file for non-LaTeX papers). A link to the submission web site will be provided on the conference web site (http://www.win.tue.nl/ifm/) IMPORTANT DATES Submission deadline: May 18, 2005 Notification of acceptance: July 13, 2005 Submission of final copy: August 17, 2005 Conference: November 29 - December 2, 2005 INVITED SPEAKERS Patrice Godefroid - Bell Labs (USA) David Parnas - University of Limerick (Ireland), McMaster University (Canada) Doron Peled - University of Warwick (UK) INVITED TUTORIAL Holger Hermanns - Saarland University (Germany) "QoS Modelling and Analysis for Embedded Systems" PROGRAM COMMITTEE Didier Bert, Institute IMAG, Grenoble, France Eerke Boiten, University of Kent, UK Jonathan Bowen, London South Bank University, UK Michael Butler, University of Southampton, UK Paul Curzon, Queen Mary, University of London, UK Jim Davies, University of Oxford, UK John Derrick, University of Sheffield, UK Steve Dunne, University of Teesside, UK Jin Song Dong, National University of Singapore Andy Galloway, University of York, UK Chris George, United Nations University, Macau Wolfgang Grieskamp, Microsoft Research, Redmond, US Henri Habrias, University of Nantes, France Maritta Heisel, University of Magdeburg, Germany Soon-Kyeong Kim, University of Queensland, Australia Michel Lemoine, ONERA, Toulouse, France Shaoying Liu, Hosei University, Tokyo, Japan Dominique Mery, LORIA, France Stephan Merz, LORIA, France Richard Paige, University of York, UK Luigia Petre, Turku Centre for Computer Science, Finland Thomas Santen, Technical University of Berlin, Germany Steve Schneider, University of Surrey, UK Wolfram Schulte, Microsoft Research, Redmond, US Kaisa Sere, Abo Akademi University, Turku, Finland Jane Sinclair, University of Warwick, UK Bill Stoddart, University of Teesside, UK Kenji Taguchi, University of Bradford, UK Helen Treharne, University of Surrey, UK Heike Wehrheim, University of Paderborn, Germany Kirsten Winter, University of Queensland, Australia Jim Woodcock, University of York, UK PROGRAM COMMITTEE CO-CHAIRS Jaco van de Pol, CWI, The Netherlands Judi Romijn, Eindhoven University of Technology, The Netherlands Graeme Smith, University of Queensland, Australia

1 0

2nd Workshop on the Rewriting Calculus
by Horatiu Cirstea 04 May '05

04 May '05

***We apologise if you receive multiple copies of this announcement*** 2nd CALL FOR ABSTRACTS AND PARTICIPATION 2nd Workshop on the Rewriting Calculus 30-31 May, 2005 Ecole Polytechnique, Palaiseau (near Paris), FRANCE, http://rho.loria.fr 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. The purpose of this workshop is to bring together researchers working on rewriting calculus and related topics, and to provide a forum for presenting new ideas and work in progress. It will be an opportunity to present recent and ongoing work, to meet colleagues, and to discuss new ideas and future trends. The previous edition of the workshop was held in Nancy (http://rho.loria.fr/workshop2004.html) The topics of the workshop include, but are not limited to, the following aspects of the rewriting calculus: - types - operational semantics - models - implementation issues - applications - relationship with other rewriting formalisms (lambda-calculus, higher-order rewriting, combination of lambda-calculus and rewriting,etc) The abstracts describing research on the above mentioned area must be in pdf (or standard postscript) format, up to two pages long and should be sent by e-mail to workshop-rho(a)loria.fr. Informal proceedings will be available at the workshop. After the workshop, full versions of selected papers will be published, after standard refereeing, as a volume in ENTCS. The deadline for submission of abstracts is 7 May, 2005. Workshop chairs: -------------------- Maribel Fernandez Horatiu Cirstea Workshop organizer: -------------------- Francois-Regis Sinot There is no registration fee, but please register by sending an email to workshop-rho(a)loria.fr before 15 May, 2005. Important dates: ---------------- Deadline for submissions: 7 May, 2005 Notification of acceptance: 12 May, 2005 Deadline for registration: 15 May, 2005 Workshop: 30-31 May, 2005

1 0

FroCoS 2005: Final cfp - extended submission deadline: May 16, 2005
by Bernhard Gramlich 04 May '05

04 May '05

[Apologies for multiple copies] ---------------------------------------------------------------------------- FroCoS 2005: FINAL CALL FOR PAPERS *** SUBMISSION DEADLINE (EXTENDED): May 16, 2005 *** ---------------------------------------------------------------------------- 5th International Workshop on Frontiers of Combining Systems (FroCoS 2005) Vienna, Austria, September 19-21, 2005 http://www.logic.at/frocos05/ ---------------------------------------------------------------------------- BACKGROUND In various areas of computer science, such as logic, computation, program development and verification, artificial intelligence, and automated reasoning, there is an obvious need for using specialized formalisms and inference mechanisms for special tasks. In order to be usable in practice, these specialized systems must be combined with each other, and they must be integrated into general purpose systems. The development of general techniques and methods for the combination and integration of special formally defined systems, as well as for the analysis and modularization of complex systems has been initiated in many areas. The International Workshop on Frontiers of Combining Systems (FroCoS) traditionally focuses on this type of research questions and activities and aims at promoting progress in the field. The previous FroCoS workshops were held in Munich (1996), Amsterdam (1998), Nancy (2000) and Santa Margherita Ligure (2002). In 2004, FroCoS joined IJCAR 2004, the 2nd International Joint Conference on Automated Reasoning. Like its predecessors, FroCoS 2005 wants to offer a common forum for research activities in the general area of combination, modularization and integration of systems (with emphasis on logic-based ones), and of their practical use. TOPICS Typical topics of interest include (but are not limited to): * combination of logics (e.g., modal logics, logics in AI, ...); * combination of decision procedures, of satisfiability procedures, and of constraint solving techniques (e.g. unification and matching algorithms, general symbolic constraints, numerical constraints); * combinations and modularity in term rewriting; * integration of equational and other theories into deductive systems (e.g. theory resolution, constraint resolution, constraint paramodulation, ...); * combination of deduction systems and computer algebra; * integration of data structures (e.g., sets, multisets, lists) into CLP formalisms and deduction processes; * model/problem analysis and decomposition (e.g. isolating tractable or loosely connected sub-problems, global constraints design, etc.) * hybrid methods for deduction, resolution and constraint propagation (e.g., combinations of local and global, complete and propagation techniques) * hybrid systems in computational linguistics, knowledge representation, natural language semantics, and human computer interaction; * logical modelling of multi-agent systems; * logical aspects of combining and modularizing programs and specifications. INVITED SPEAKERS * Luca de Alfaro (U California, Santa Cruz) * Silvio Ghilardi (U Milano) * Fausto Giunchiglia (U Trento & ITC-IRST) * Eric Monfroy (U Nantes & UTFSM/Chile) SUBMISSIONS The programme committee seeks high-quality submissions that are original and not submitted for publication elsewhere. Submission is electronic in postscript or PDF format. Submitted papers must conform to the Springer LNCS style, preferably using LaTeX2e and the Springer llncs class files. Submission categories include full papers, for work on foundations, applications, implementation techniques, and problem sets (up to 15 pages), as well as system descriptions (up to 8 pages), for describing publicly available systems. The (extended) submission deadline is May 16, 2005 for titles, abstracts, and papers. For further information and submission instructions see the FroCoS 2005 web page: http://www.logic.at/frocos05/. PROCEEDINGS Accepted papers will appear in the proceedings of the conference, published as a volume of the Lecture Notes in Artificial Intelligence (LNAI) series, Springer-Verlag. Proceedings will be available at the time of the conference. IMPORTANT DATES (UPDATED) May 16, 2005: Deadline for electronic submission of papers June 27, 2005: Notification of acceptance/rejection July 14, 2005: Deadline for final versions of accepted papers Sep 19-21, 2005: Conference PROGRAM COMMITTEE * Alessandro Armando (U Genova) * Franz Baader (TU Dresden) * Clark W. Barrett (NYU New York) * Frederic Benhamou (LINA, U Nantes) * Michel Bidoit (LSV, CNRS & ENS Cachan) * Jacques Calmet (U Karlsruhe) * Juergen Giesl (RWTH Aachen) * Bernhard Gramlich (chair) (TU Wien) * Deepak Kapur (UNM Albuquerque) * Maarten Marx (U Amsterdam) * Joachim Niehren (INRIA Futurs, U Lille) * Christophe Ringeissen (LORIA-INRIA Nancy) * Manfred Schmidt-Schauss (U Frankfurt) * Cesare Tinelli (U Iowa) * Ashish Tiwari (SRI Menlo Park) * Frank Wolter (U Liverpool) ORGANIZING COMMITTEE * Aneta Binder * Bernhard Gramlich * Franziska Gusel * Gernot Salzer * Jana Srna PROGRAM COMMITTEE AND CONFERENCE CHAIR Bernhard Gramlich TU Wien, Fakultaet fuer Informatik, Theory and Logic Group Favoritenstr. 9 - E185/2, A-1040 Wien, Austria Email: frocos05(a)logic.at FURTHER INFORMATION FroCoS 2005 web page: http://www.logic.at/frocos05/ FroCoS 2005 submission web page: http://www.logic.at/frocos05/submit/ ----------------------------------------------------------------------------

1 0

announce: wxHaskell 0.9.4
by Daan Leijen 04 May '05

04 May '05

Announcement: wxHaskell version 0.9.4 ---------------------------------------------------------------------- <http://wxhaskell.sourceforge.net> I am pleased to announce a new release of wxHaskell. This is mostly an update to support GHC 6.4 and it does not contain any new features. Binary installers are provided for MacOS X, Linux (RPM), and Windows. Unfortunately, GHCi-6.4 does not work with wxHaskell. For Windows platforms I still recommend GHC 6.2.2 since GHCi-6.2.2 works great with wxHaskell (on Windows). All the best, Daan Leijen. ---------------------------------------------------------------------- wxHaskell is a portable GUI library for Haskell. The goal of the project is to provide an industrial strength portable GUI library, but without the burden of developing (and maintaining) one ourselves. wxHaskell is therefore build on top of wxWidgets -- a comprehensive C++ library that is portable across all major GUI platforms; including GTK, Windows, X11, and MacOS X. Furthermore, it is a mature library (in development since 1992) that supports a wide range of widgets with native look-and-feel, and it has a very active community (ranked among the top 25 most active projects on sourceforge). Since most of the interface is automatically generated from the wxEiffel binding, the current release of wxHaskell already supports about 75% of the wxWindows functionality -- about 2900 methods in 500 classes with 1400 constant definitions. wxHaskell has been build with GHC 6.x on Windows, MacOS X and Unix systems with GTK. A binary distribution is available for Windows, Linux (RPM) and MacOS X. And even if you don't intend to write GUI's yourself, it will be fun to check out the screenshots at <http://wxhaskell.sourceforge.net>. ---------------------------------------------------------------------- Version 0.9.4 ------------- Backward compatible additions: - Adapted the configuration, make files, and install scripts to work with GHC 6.4. - Adapted the wxHaskell C-layer to work with wxWidgets 2.6.0 - Made "Object" an instance of Ord

1 0

ICLP 2005: Extended Deadlines
by ICLP 2005 04 May '05

04 May '05

Call for Papers ------------------------------------------------------------ Twenty first International Conference on Logic Programming ICLP'05 2-5 October, 2005 Sitges (Barcelona) Spain Co-located with the International Conference on Principles and Practice of Constraint Programming (CP'05) ------------------------------------------------------------ http://www.iiia.csic.es/iclp2005/ New abstract submission deadline: May 8th, 2005 New paper submission deadline: May 11th, 2005 [* Please note that ICLP'05 has a doctoral consortium for the first time as well as a special industrial paper session (details below). * Note that ICLP05's dates intersect with a solar eclipse visible in Barcelona ]. The Conference -------------- The 21st International Conference on Logic Programming will be held near Barcelona (Spain) from October 2nd to October 5th, 2005. ICLP'05 will be colocated with the International Conference on Principles and Practice of Constraint Programming (CP'05). Conference scope ---------------- Since the first conference held in Marseilles in 1982, ICLP has been the premier international conference for presenting research in logic programming. Contributions (papers and posters) are sought in all areas of logic programming including but not restricted to: Theory Implementation Semantic Foundations Compilation Formalisms Memory Management Nonmonotonic Reasoning Virtual Machines Knowledge Representation Parallelism Environments Alternative Paradigms Program Analysis Constraint Logic Programming Program Transformation Abductive Logic Programming Validation and Verification Inductive Logic Programming Debugging, Profiling Answer Set Programming Language Issues Applications Concurrency Semantic Web Objects Software Engineering Coordination Web Tools Mobility Internet Agents Higher Order Artificial Intelligence Types Deductive Databases Modes Natural Language Programming Techniques Specific attention will be given to work providing novel integrations of these different areas, and to new applications of logic programming in general. Contributions on applications will be assessed with an emphasis on their impact and synergy with other areas, as opposed to technical maturity. Applications of logic programming to the Semantic Web are especially encouraged. The technical program will include several invited talks and advanced tutorials, in addition to the presentations of the accepted papers and posters. A special session on industrial applications of logic programming is also planned and several workshops will be held in parallel with the conference. For the first time, a doctoral student consortium will be organized as part of ICLP. Invited Speakers ---------------- This year, ICLP will have the following invited speakers: Ian Horrocks, University of Manchester, UK Francesca Rossi, University of Padova, Italy Peter Stuckey, University of Melbourne, Australia Papers ------- Papers must describe original, previously unpublished research, and must not be simultaneously submitted for publication elsewhere. They must be written in English and not exceed 15 pages in Springer LNCS format. The authors are encouraged, although not obliged, to submit their papers already in Springer LNCS format. General information about the Springer LNCS series and the LNCS authors' instructions are available at the Springer LNCS/LNAI home page (http://www.springer.de/comp/lncs/index.html) Papers should express their contribution clearly, both in general and technical terms. It is essential to identify what was accomplished, describe its significance, and explain how the paper compares with and advances previous work. Authors should make every effort to make the technical content understandable to a broad audience. The primary means of submission will be electronic, in pdf format. If electronic submission is not possible, five hard copies should be sent to one of the program co-chairs. More information on the submission procedure will be available at http://www.easychair.org/ICLP2005/submit/ Industrial Papers ----------------- A special session on industrial applications of logic programming is also planned during the conference. Papers accepted in this session will describe innovative applications of logic programming to industrial problems. The application's innovativeness and industrial impact will be the main criteria used for judging the paper. Papers accepted for this session will be published in the proceedings as shorter, (up to) 10 pages papers. Posters ------- Posters provide a forum for presenting work in an informal and interactive setting. They are ideal for discussing current work not yet ready for publication, for PhD thesis summaries and research project overviews. Accepted posters will also get a 10 minute slot for presentation during the conference. Extended abstract (2 pages) of each accepted poster will be published in the proceedings. Posters must be submitted electronically. More information on the submission procedure will be available at http://www.easychair.org/ICLP2005/submit/ Doctoral Student Consortium --------------------------- The Doctoral Consortium will provide an opportunity for students pursuing their doctoral thesis in logic programming and related areas to explore their research interests under the guidance of a panel of distinguished experts in the field. The Doctoral Consortium will also offer invited speakers and discussion groups. The Consortium will allow participants to interact with established researchers and with other students, through presentations, question-answer sessions, panel discussions, and invited presentations. A separate call-for-participation will be issued for the doctoral consortium. About 6 to 8 students will be selected for the consortium. Selected students will also present their research in the poster session. The abstract of the poster will be published in the conference proceedings. Financial support for selected students may be available. Publication ----------- The proceedings of the conference will be published by Springer-Verlag in the LNCS series. The proceedings will include the accepted papers and the abstracts of accepted posters. Sponsoring and prizes --------------------- The conference is sponsored by the Association for Logic Programming. The ALP has funds to assist financially disadvantaged participants. The ALP is planning to sponsor two prizes for ICLP'05: for the best technical paper and for the best application paper. Important dates --------------- POSTERS PAPERS Abstract submission deadline: 8 May Submission deadline: 1 June 11 May Notification of authors: 1 July 24 June Camera-ready copy due: 15 July 15 July Organization ------------ Conference Co-Chairs: Pedro Meseguer (IIIA-CSIC, Spain) Javier Larrosa (Technical University of Catalonia, Spain) Program Co-Chairs: Maurizio Gabbrielli (University of Bologna, Italy) Gopal Gupta (University of Texas at Dallas, USA) Workshop Chair: Hai-Feng Guo (University of Nebraska at Omaha, USA) Doctoral Consortium Chair: Enrico Pontelli (New Mexico State University, USA) Publicity Chair: Felip Manya (IIIA-CSIC, Spain) Program Committee: Roberto Bagnara University of Parma, Italy Maurice Bruynooghe KU Leuven, Belgium Giorgio Delzanno University of Genova, Italy Stefan Decker Digital Enterprise Research Institute, Ireland Thom Fruehwirth University of Ulm, Germany Maurizio Gabbrielli University of Bologna, Italy (Program Co-Chair) Gopal Gupta University of Texas at Dallas, USA (Program Co-Chair) Patricia Hill University of Leeds, UK Joxan Jaffar University of Singapore, Singapore Bharat Jayaraman SUNY Buffalo, USA Javier Larrosa Technical University of Catalonia, Spain (Conference Co-Chair) Michael Leuschel University of Dusseldorf, Germany Massimo Marchiori University of Venice, Italy and W3C, MIT, USA Pedro Meseguer IIIA-CSIC, Spain (Conference Co-Chair) Juan J. Moreno Navarro Technical University of Madrid, Spain Gopalan Nadathur University of Minnesota, USA Ilkka Niemela Helsinki U. of Tech. Finland Catuscia Palamidessi INRIA, France Enrico Pontelli New Mexico State Univeristy, USA I.V. Ramakrishnan SUNY Stony Brook, USA Vitor Santos Costa Federal U. of Rio de Janeiro, Brazil Harald Sondergaard University of Melbourne, Australia Peter Stuckey University of Melbourne, Australia Frank Valencia University of Uppsala, Sweden Contact addresses ----------------- Conference Chairs: Pedro Meseguer Javier Larrosa IIIA-CSIC Dep. LSI, UPC Campus UAB Jordi Girona 1-3 08193 Bellaterra, Spain 08034 Barcelona, Spain Program Co-chairs: iclp05-chairs(a)cs.unibo.it Maurizio Gabbrielli Gopal Gupta Department of Computer Science Department of Computer Sciences MS EC31 University of Bologna The University of Texas at Dallas Mura A. Zamboni 7 2601 N. Floyd Rd 40127 Bologna, Italy Richardson, TX 78050, USA

1 0