- Haskell - Haskell.org

Two Lectureships in Nottingham
by Graham Hutton 07 Feb '08

07 Feb '08

Dear all, We are advertising two new Lectureships (Assistant Professorships) in Computer Science at the University of Nottingham in England. Applications in the area of functional programming are particularly welcome. Further details are available from: http://jobs.nottingham.ac.uk/vacancies.aspx?cat=160#j2797 The closing date for applications is 22nd Feburary 2008 Best wishes, Graham Hutton +-----------------------------------------------------------------+ | Dr Graham Hutton Email : gmh(a)cs.nott.ac.uk | | School of Computer Science | | University of Nottingham Web : www.cs.nott.ac.uk/~gmh | | Jubilee Campus, Wollaton Road | | Nottingham NG8 1BB, UK Phone : +44 (0)115 951 4220 | +-----------------------------------------------------------------+ This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Re: Typing unification algorithm for parameterized types using GADTs?
by oleg＠okmij.org 07 Feb '08

07 Feb '08

Ki Yung Ahn posed a problem of first-order syntactic unification over GADTs. There posted code seem to exhibit two problems: one deals with kind equality, and the other with unification. Let's start with the latter. You have chosen to represent substitutions as functions from terms to terms. That's OK. However, the following lines seems weird: > unify (t1 :-> t2) (t1' :-> t2') = unify t1 t1' . unify t2 t2' We wish to unify two composite (constructed terms) whose head is :->. Unification of t1 t1' gives a substitution, and so does the unification of t2 and t2'. Now we should prove that the results are compatible, that is, if the domains of both substitutions overlap, the common variables are associated with unifyable values. But the composition is the wrong operation here: the composition is a total operation. So, if we unify (X :-> X) (term1 :-> term2) where X is a free variable and term1 is distinct from term2, we are successful? Indeed, unify X term1 succeeds, so is unify X term2. The composition is total. The result can't be right. The line has to be re-written as follows > unify (t1 :-> t2) (t1' :-> t2') = > let s = unify t1 t1' in s `compose` unify (s t2) (s t2') where > compose s1 s2 t = loop t > where > s = s1 . s2 > loop t = let t1 = s t in if t1 == t then t else loop t1 The fixpoint assures the substitution is idempotent, as behooves to the result of unify. Now, the type of unify is also a bit wrong: > unify :: (Show v,Ord v) => Ty v k -> Ty v k -> Ty v k -> Ty v k It should be > unify :: (Show v,Ord v) => Ty v k -> Ty v k -> Ty v k' -> Ty v k' Finally, we come to the issue of kind equality. In > data Ty v k where > TyA :: Ty v (k1 :~> k2) -> Ty v k1 -> Ty v k2 k1 is an existentially quantified type variable. When we wish to compare (TyA t1l t1r) with (TyA t2l t2r), we first have to prove that the kind of t1r is the same as t2r. Both kinds are existentially quantified, there is no reason they must always be equal. So, we have to use intensional equality. > data Star = Star deriving (Show,Eq) -- the kind * > data k1 :~> k2 = k1 :~> k2 deriving (Show,Eq) Well, deriving Eq is not useful here: we can't actually compare Star with (k1 :~> k2) because they have different types. So, we need an intensional representation of kinds, with a useful comparison function. We should also re-write > TyC :: v -> k -> Ty v k to use that representation. The final code follows. {-# OPTIONS -fglasgow-exts #-} import List infixr :~> -- kind arrow -- term algebra of kinds data Star data k1 :~> k2 -- A representation of kinds data K k where KStar :: K Star KArr :: K k1 -> K k2 -> K (k1 :~> k2) infixr :-> -- type arrow data Ty v k where TyV :: v -> Ty v Star -- all type vars are of kind *. (:->) :: Ty v Star -> Ty v Star -> Ty v Star TyC :: v -> K k -> Ty v k TyA :: Ty v (k1 :~> k2) -> Ty v k1 -> Ty v k2 -- Kind equality data EQ a b where Refl :: EQ a a -- compare two kinds. Return either Nothing or the witness of their -- equality keq:: K k1 -> K k2 -> Maybe (EQ k1 k2) keq KStar KStar = Just Refl keq (KArr k1l k1r) (KArr k2l k2r) = keq' (keq k1l k2l) (keq k1r k2r) keq _ _ = Nothing keq' :: Maybe (EQ k1l k2l) -> Maybe (EQ k1r k2r) -> Maybe (EQ (k1l :~> k1r) (k2l :~> k2r)) keq' (Just Refl) (Just Refl) = Just Refl keq' _ _ = Nothing -- inverse of the above keqa :: Maybe (EQ (k1l :~> k1r) (k2l :~> k2r)) -> Maybe (EQ k1r k2r) keqa (Just Refl) = Just Refl keqa _ = Nothing -- compare two types for their kinds. tykeq :: Ty v k1 -> Ty v k2 -> Maybe (EQ k1 k2) tykeq (TyV _) (TyV _) = Just Refl tykeq (_ :-> _) (_ :-> _) = Just Refl tykeq (TyC _ k1) (TyC _ k2) = keq k1 k2 tykeq (TyA t1 _) (TyA t1' _) = keqa (tykeq t1 t1') -- term equality instance Eq v => Eq (Ty v k) where TyV v1 == TyV v2 = v1 == v2 (t1l :-> t1r) == (t2l :-> t2r) = t1l == t2l && t1r == t2r TyC v1 _ == TyC v2 _ = v1 == v2 (TyA t1l t1r) == (TyA t2l t2r) = teq'' (tykeq t1r t2r) t1r t2r && teq'' (tykeq t1l t2l) t1l t2l _ == _ = False teq'' :: Eq v => Maybe (EQ k1 k2) -> Ty v k1 -> Ty v k2 -> Bool teq'' (Just Refl) t1 t2 = t1 == t2 teq'' _ _ _ = False list = TyC "List" (KArr KStar KStar) nil_t = TyA list (TyV "a") -- the `List a' type nil'_t = TyA list (TyV "b") -- the `List b' type cons_t = TyV "b" :-> TyA list (TyV "b") :-> TyA list (TyV "b") instance Show v => Show (Ty v k) where show (TyV v) = show v show (t1 :-> t2) = "("++show t1++"->"++show t2++")" show (TyC v _) = show v show (TyA t1 t2) = "("++show t1++" "++show t2++")" occurs :: Eq v => v -> Ty v k -> Bool occurs x (TyV y) = x == y occurs x (t1:->t2) = occurs x t1 || occurs x t2 occurs _ (TyC _ _) = False occurs x (TyA t1 t2) = occurs x t1 || occurs x t2 -- A substitution on types can be written as follows: type Subst v k = Ty v k -> Ty v k substt :: Eq v => (v,Ty v Star) -> Subst v k substt (x,t1) t@(TyV y) | x == y = t1 | otherwise = t substt p (t1 :-> t2) = substt p t1 :-> substt p t2 substt _ t@(TyC _ _) = t substt p (TyA t1 t2) = substt p t1`TyA`substt p t2 compose s1 s2 t = loop t where s = s1 . s2 loop t = let t1 = s t in if t1 == t then t else loop t1 unify_gen :: (Show v,Ord v) => Maybe (EQ k1 k2) -> Ty v k1 -> Ty v k2 -> Subst v k' unify_gen (Just Refl) t1 t2 = unify t1 t2 unify_gen _ _ _ = error "incompat kinds" unify :: (Show v,Ord v) => Ty v k -> Ty v k -> Subst v k' unify t1@(TyV x) t2@(TyV y) | x == y = id | x <= y = substt (x,t2) | otherwise = substt (y,t1) unify (TyV x) t | occurs x t = error(show x++" occurs in " ++show t) | otherwise = substt (x,t) unify t1 t@(TyV _) = unify t t1 unify (t1 :-> t2) (t1' :-> t2') = let s = unify t1 t1' in s `compose` unify (s t2) (s t2') unify (TyC a _) (TyC b _) | a == b = id | otherwise = error(show a++" is not " ++show b) unify (TyA t1 t2) (TyA t1' t2') = let s = unify_gen (tykeq t2 t2') t2 t2' tn1 = s t1 tn1' = s t1' in s `compose` unify_gen (tykeq tn1 tn1') tn1 tn1' unify t1 t2 = error(show t1++" is not " ++show t2) test1 = unify nil_t nil_t $ nil_t test2 = unify nil_t cons_t $ nil_t test3 = let s = unify nil_t nil'_t in (s nil_t, s nil'_t) test4 = let t1 = (TyV "a" :-> TyV "b") t2 = (TyV "b" :-> TyC "unit" KStar) s = unify t1 t2 in (s t1, s t2) -- (("unit"->"unit"),("unit"->"unit")) -- Indeed, both types are the same

2 1

Typing unification algorithm for parameterized types using GADTs?
by Ahn, Ki Yung 07 Feb '08

07 Feb '08

I was writing a type inference algorithm for let-polymorphic type system with parametrized types. (That is, the type system as type constructors such as `Maybe'.) Things work out nicely except for one equation in the unification function. I will illustrate my problem with the definitions and examples that you can actually run. You will need -XGADTs and -XTypeOperators to run this as a literate Haskell script in ghc 6.8.2. FYI, my problematic unification function appears at the end. This is not that long article (about 150 lines), anyway. > import List First, we define the kind as follows: > infixr :~> -- kind arrow > > data Star = Star deriving (Show,Eq) -- the kind * > data k1 :~> k2 = k1 :~> k2 deriving (Show,Eq) Next, we define the type as GADTs indexed with kinds, > infixr :-> -- type arrow > > data Ty v k where > TyV :: v -> Ty v Star -- all type vars are of kind *. > (:->) :: Ty v Star -> Ty v Star -> Ty v Star > TyC :: v -> k -> Ty v k > TyA :: Ty v (k1 :~> k2) -> Ty v k1 -> Ty v k2 Note that, we only allow type variables to be of kind * (abbr. for Star). For example, we define the parametrized type List as follows: > list = TyC "List" (Star :~> Star) So, we can give `nil' (empty list) the type TyA list (TyV "a") -- the `List a' type and `cons' the type TyV "a" :-> TyA list (TyV "a") :-> TyA list (TyV "a") We also define an instance for Show class, since deriving does not support GATDs. > instance Show v => Show (Ty v k) where > show (TyV v) = show v > show (t1 :-> t2) = "("++show t1++"->"++show t2++")" > show (TyC v _) = show v > show (TyA t1 t2) = "("++show t1++" "++show t2++")" Then, we can write some functions. An occurs check on types can be written as follows: > occurs :: Eq v => v -> Ty v k -> Bool > occurs x (TyV y) = x == y > occurs x (t1:->t2) = occurs x t1 || occurs x t2 > occurs _ (TyC _ _) = False > occurs x (TyA t1 t2) = occurs x t1 || occurs x t2 A substitution on types can be written as follows: > substt :: Eq v => (v,Ty v Star) -> Ty v k -> Ty v k > substt (x,t1) t@(TyV y) | x == y = t1 > | otherwise = t > substt p (t1 :-> t2) = substt p t1 :-> substt p t2 > substt _ t@(TyC _ _) = t > substt p (TyA t1 t2) = substt p t1`TyA`substt p t2 Recall that we only have type variables of kind *. So, we only need to substitute a variable to a type of kind *. Finally, we try writing a unification function as follows: > unify :: (Show v,Ord v) => Ty v k -> Ty v k -> Ty v k -> Ty v k > unify t1@(TyV x) t2@(TyV y) | x == y = id > | x <= y = substt (x,t2) > | otherwise = substt (y,t1) > unify (TyV x) t | occurs x t = error(show x++" occurs in " > ++show t) > | otherwise = substt (x,t) > unify t1 t@(TyV _) = unify t t1 > unify (t1 :-> t2) (t1' :-> t2') = unify t1 t1' . unify t2 t2' > unify (TyC a _) (TyC b _) | a == b = id > | otherwise = error(show a++" is not " > ++show b) > unify (TyA t1 t2) (TyA t1' t2') = unify t1 t1' . unify t2 t2' > unify t1 t2 = error(show t1++" is not " > ++show t2) I think I may be able to make it go through by changing the representation of unification to a data structure such as list of substitution pairs. But, just out of curiosity, what kind of an operator should I define to combine the result of two unifications (unify t1 t1') (unify t2 t2') properly in this setting? -- Ahn, Ki Yung <kya(a)pdx.edu>

2 1

ANN: hpodder 1.1.0
by John Goerzen 07 Feb '08

07 Feb '08

I'm pleased to announce version 1.1.0 of hpodder, the podcast downloader. Get it from http://software.complete.org/hpodder The new features in hpodder 1.1.0 include: * New support for configurable renaming of incoming episodes to standard extensions. The previous feature was hard-coded for certain data types. * New support for using file -i (or a user-configurable program) to determine the actual type of a file to deal with servers that don't send correct MIME types in their feeds. Enable this support by default. * New support for user-configurable post-processing commands that do things such as tagging. * New support for conditional running of post-processing commands based on content type. * Documented --debug. * New support for GUID tags to reduce occurances of duplicate downloads. Thanks to Jason Creighton for the patch to support this. This version is compatible with GHC 6.8.x and MissingH 1.0.x. -- John

1 0

ANN: IOSpec 0.2
by Wouter Swierstra 05 Feb '08

05 Feb '08

I'm pleased to announce the latest version of the IOSpec library. The IOSpec library contains a pure specification of several functions in the IO monad. You can use these specifications to test, debug, and reason about impure code. You can find more information, examples, and documentation on the homepage: * http://www.cs.nott.ac.uk/~wss/repos/IOSpec/ * Some new features include: * New specifications of STM; * Composable specifications; * Several new schedulers; * Lots of new examples, including a QuickChecked distributed Sudoku solver; * Complete rewrite of most of the pure virtual machine. Homepage: http://www.cs.nott.ac.uk/~wss/repos/IOSpec/ Haddock: http://www.cs.nott.ac.uk/~wss/repos/IOSpec/dist/doc/html/IOSpec/ Source: http://www.cs.nott.ac.uk/~wss/repos/IOSpec/dist/IOSpec-0.2.tar.gz darcs: darcs get http://www.cs.nott.ac.uk/~wss/repos/IOSpec/ Thanks to David Waern for his work on Haddock 2.0, without which I probably never would have released this version. Feedback, comments, and suggestions are very welcome! Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

1st call for participation AFP 2008, The Netherlands
by Peter Achten 04 Feb '08

04 Feb '08

1ST CALL FOR PARTICIPATION 6TH INTERNATIONAL SUMMER SCHOOL ON ADVANCED FUNCTIONAL PROGRAMMING 2008 (AFP ’08) RADBOUD UNIVERSITY NIJMEGEN AND UTRECHT UNIVERSITY, THE NETHERLANDS MAY 19-24, 2008 http://www.st.cs.ru.nl/AFP_TFP_2008/ AFP is a series of international summer schools which aims to bring computer scientists, in particular young researchers and programmers, up to date with the latest advances in practical advanced functional programming. Functional programming emphasizes the evaluation of expressions rather than the execution of commands. We focus on functional programming techniques in “programming in the real world” and bridge the gap between results presented at programming conferences and material from textbooks on functional programming. In this school you will receive in depth lectures about advanced functional programming techniques, taught by experts in the field. Lectures are accompanied by practical problems to be solved by the students at the school. AFP 2008 is hosted by the Radboud University Nijmegen, and Utrecht University, The Netherlands, and will be held in the rural setting of Center Parcs “Het Heijderbos”, Heijen (in the vicinity of Nijmegen), The Netherlands. AFP 2008 is co-located with the 9th Symposium on Trends in Functional Programming (TFP’08), which is held after AFP’08. PROGRAM INFORMATION The following speakers will give the lectures (in alphabetic order): Umut Acar (Toyota Technological Institute, University of Chicago, US) Richard Bird (University of Oxford, UK) Olivier Danvy (University of Aarhus, DK) Johan Jeuring (Utrecht University, NL) Mark Jones (Portland State University, US) Ulf Norell (Chalmers University, SE) Simon Peyton Jones (Microsoft Research, UK) Rinus Plasmeijer (Radboud University Nijmegen, NL) During the summer school, all participants receive printed lecture notes. Participants are expected to have a notebook, in order to be able to participate with the practical problems. After the summer school, all lecture notes will be revised, reviewed, and published in the LNCS series of Springer. All registered participants receive a copy of these lecture notes. VENUE INFORMATION AFP (and TFP) is held in The Netherlands, at Center Parcs “Het Heijderbos” which is a holiday resort in the woodlands near the city of Nijmegen. We accomodate participants in DeLuxe Cottages, each of which has three separate bed-rooms, shared bathroom, toilet, kitchen, and terrace. Cottages will be shared by three participants. If you wish to reduce costs, you can choose to share a bedroom. The summer school and symposium will take place in the business center of the venue. Breakfast, lunch and diner is included within the limits of the venue. The resort features, amongst others, a sub-tropical swimming pool (free for participants), restaurants, shops, water sports lake, midget golf court, squash court, and outdoor and indoor tennis courts. Nijmegen is considered to be the oldest city of the Netherlands, being approximately 2000 years old. Nijmegen is located at the east border of the Netherlands, near Germany. Nijmegen can be reached easily from several airports such as Schiphol airport, Eindhoven airport, and Düsseldorf airport, as well as by train and car. Conveniently close to Center Parcs “Het Heijderbos” you will find airport Weeze in Germany. The venue Center Parcs “Het Heijderbos” can be reached from Nijmegen by train to Boxmeer (25 minutes). From there you will need to order a taxi. The venue can also be reached by car: parking is free for participants of AFP and TFP. SUMMER SCHOOL FEES AFP 2008 includes accommodation, conference, breakfast – lunch – diner, speakers, and proceedings costs. The early registration fee is € 995; the late registration fee is € 1095. Please note that if you require financial support, you can apply for a grant (see below). GRANT INFORMATION We have taken great care to reduce the registration cost as much as possible. We can grant a subsidy for a limited number of PhD student participants for whom the costs are still too high. In order to apply for this subsidy, you need to send (by surface mail or e-mail) a request for subsidy which contains your personal information, affiliation, a description of your current status, project description, a motivation why you should receive the grant, and a recommendation from your PhD supervisor. This letter should arrive before april 7 2008 to: Rinus Plasmeijer Radboud University Nijmegen Toernooiveld 1 6525ED Nijmegen rinus(a)cs.ru.nl You will receive a notification whether your request has been granted before april 14 2008. REGISTRATION INFORMATION Early registration opens at march 1 2008. Late registration opens at april 15 2008. Registration closes at may 5 2008. We can not guarantee accommodation in case you wish to register later than may 5 2008. IMPORTANT DATES (ALL 2008) Early Registration Opens: March 1 Early Registration Deadline: April 14 Late Registration Opens: April 15 Late Registration Deadline: May 5 AFP Summer School: May 19-24 ORGANIZATION Programme Chair: Rinus Plasmeijer, Pieter Koopman, Radboud University Nijmegen, NL Doaitse Swierstra, Utrecht University, NL Arrangements: Peter Achten, Simone Meeuwsen, Radboud University Nijmegen, NL E-mail: afp_tfp_2008(a)cs.ru.nl

1 0

Call for papers ICTAC 2008
by tase08 02 Feb '08

02 Feb '08

[Apoligies for multiple copies] CALL FOR PAPERS 5th International Colloquium on Theoretical Aspects of Computing (ICTAC 2008) ============================================================================ = 1-3 September 2008 The Marmara, Istanbul, Turkey (Tutorials & Workshops 30-31 August 2008, Sabanci University, Istanbul) <http://www.ictac.net/ictac08> http://www.ictac.net/ictac08 The ICTAC series, founded by the United Nations University's International Institute of Software Technology (UNU-IIST), brings together practitioners and researchers from academia, industry and government to present research and to exchange ideas and experience addressing challenges in both theoretical aspects of computing and in the exploitation of theory through methods and tools for system development. A further aim is to promote cooperation in research and education between participants and institutions from developing and industrial countries, as in the United Nations University's mandate. The previous four ICTAC events were held in Guiyang, China (2004), Hanoi, Vietnam (2005), Tunis, Tunisia (2006) and Macau (2007). In 2008, topics include, but are not limited to: - software specification, refinement, verification and testing - model checking and theorem proving - software architectures - coordination and feature interaction - integration of theories, formal and engineering methods and tools - models of concurrency, security, and mobility - parallel, distributed, and internet-based (grid) computing - real-time, embedded and hybrid systems - automata theory and formal languages - principles and semantics of languages - logics and their applications - type and category theory in computer science - case studies, theories, tools and experiments of verified systems - service-oriented architectures: models and development methods - domain modelling and domain-specific technology: examples, frameworks and experience We particularly welcome submissions for a special track on Tool Support for Formal Methods of System Development: from the foundations of tools, through their design to application and evaluation. Paper Submissions ----------------- Submissions to the conference must not have been published or be concurrently considered for publication elsewhere. All submissions will be judged on the basis of originality, contribution to the field, technical and presentation quality, and relevance to the conference. Papers should be in English and should not exceed 15 pages LNCS format (see <http://www.springer.de/comp/lncs/authors.html> http://www.springer.de/comp/lncs/authors.html for details). Submission constitutes a commitment to attend and present a paper, if accepted. Proceedings of the previous ICTAC colloquia were published by Springer in the LNCS series. We plan to do the same this year. Submission Procedure: Further information and instructions can be found at the conference website <http://www.ictac.net/ictac08> http://www.ictac.net/ictac08 Tutorials & Workshops: We welcome proposals for tutorials and workshops relevant to the ICTAC themes to take place on 30-31 August 2008. Proposers should contact the Organising Chair ( <mailto:yenigun@sabanciuniv.edu> yenigun(a)sabanciuniv.edu) The closing date for workshop proposals is 7 April 2008, with notification on 30 April 2008. The closing date for tutorial proposals is 9 June 2008, with notification on 30 June 2008. Important Dates --------------- Papers: Submission: 11 April 2008 Notification of acceptance: 19 May 2008 Final copy for proceedings: 2 June 2008 ICTAC 2008: 1-3 September 2008 Workshops: Submission: 7 April 2008 Notification of acceptance: 30 April 2008 ICTAC 2008 Workshops & Tutorials: 30-31 August 2008 Tutorials: Submission: 9 June 2008 Notification of acceptance: 30 June 2008 ICTAC 2008 Workshops & Tutorials: 30-31 August 2008 Chairs & Contacts ----------------- General Chair: Mike Reed, UNU-IIST Organising Chair: Husnu Yenigun ( <mailto:yenigun@sabanciuniv.edu> yenigun(a)sabanciuniv.edu) Sabanci University, Istanbul Programme Chairs: John Fitzgerald, Newcastle University, UK ( <mailto:John.Fitzgerald@ncl.ac.uk> John.Fitzgerald(a)ncl.ac.uk) Anne Haxthausen, Technical University of Denmark ( <mailto:ah@imm.dtu.dk> ah(a)imm.dtu.dk) Publicity Chair: Jeremy Bryans, Newcastle University, UK Steering Committee: John Fitzgerald, UK; Martin Leucker, Germany; Zhiming Liu (Chair), UNU-IIST, Macao; Tobias Nipkow, Germany; Augusto Sampaio, Brazil; Natarajan Shankar, USA; Jim Woodcock, UK

1 0

WinHugs Code/ Integration with Jaskell Shell
by Gottfried F. Zojer 01 Feb '08

01 Feb '08

Hallo to all, Tried to find it through Google.Maybe I missed it? Is anyone aware if it is possible to glue together winhugs and the Jaskell Shell (http://jaskell.codehaus.org/Jaskell+Shell) or also the Jython Shell ( http://code.google.com/p/jythonconsole/ ) Thanks in advance for any feedback Rgds Gottfried http://www.5152.eu/

2 1

Second Call for Papers TFP 2008, The Netherlands
by Peter Achten 01 Feb '08

01 Feb '08

2ND CALL FOR PAPERS TRENDS IN FUNCTIONAL PROGRAMMING 2008 RADBOUD UNIVERSITY NIJMEGEN, THE NETHERLANDS MAY 26-28, 2008 INVITED SPEAKER: PROF. HENK BARENDREGT http://www.st.cs.ru.nl/AFP_TFP_2008/ The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming languages, focusing on providing a broad view of current and future trends in Functional Programming. It aspires to be a lively environment for presenting the latest research results through acceptance by extended abstracts and full papers. A formal post-symposium refereeing process selects the best articles presented at the symposium for publication in a high-profile volume. TFP 2008 is hosted by the Radboud University Nijmegen, The Netherlands, and will be held in the rural setting of Center Parcs “Het Heijderbos”, Heijen (in the vicinity of Nijmegen), The Netherlands. TFP 2008 is co-located with the 6th Int’l. Summer School on Advanced Functional Programming (AFP’08), which is held immediately before TFP’08. SCOPE OF THE SYMPOSIUM The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research: leading-edge, previously unpublished research. Position: on what new trends should or should not be. Project: descriptions of recently started new projects. Evaluation: what lessons can be drawn from a finished project. Overview: summarizing work with respect to a trendy subject. Articles must be original and not submitted for simultaneous publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or more experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Contributions on the following subject areas are particularly welcomed: * Dependently Typed Functional Programming * Validation and Verification of Functional Programs * Debugging for Functional Languages * Functional Programming and Security * Functional Programming and Mobility * Functional Programming to Animate/Prototype/Implement Systems from Formal or Semi-Formal Specifications * Functional Languages for Telecommunications Applications * Functional Languages for Embedded Systems * Functional Programming Applied to Global Computing * Functional GRIDs * Functional Programming Ideas in Imperative or Object-Oriented Settings (and the converse) * Interoperability with Imperative Programming Languages * Novel Memory Management Techniques * Parallel/Concurrent Functional Languages * Program Transformation Techniques * Empirical Performance Studies * Abstract/Virtual Machines and Compilers for Functional Languages * New Implementation Strategies * Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2008 program chairs, Peter Achten and Pieter Koopman, at afp_tfp_2008(a)cs.ru.nl. SUBMISSION AND DRAFT PROCEEDINGS Acceptance of articles for presentation at the symposium is based on the review of full papers (15 pages) and extended abstracts (at least 3 pages) by the program committee. TFP encourages PhD students to submit papers. PhD students may request the program committee to provide extensive feedback on their full papers at the time of submission. Full papers describing work accepted for presentation must be completed before the symposium for publication in the draft proceedings and on-line. Further details can be found at the TFP 2008 website http://www.st.cs.ru.nl/AFP_TFP_2008/. POST-SYMPOSIUM REFEREEING AND PUBLICATION In addition to the draft symposium proceedings, we continue the TFP tradition of publishing a high-quality subset of contributions in the Intellect series on Trends in Functional Programming. IMPORTANT DATES (ALL 2008) Paper Submission: March 3 Notification of Acceptance: March 31 Early Registration Deadline: April 14 Late Registration Deadline: May 5 Camera Ready Symposium: May 5 TFP Symposium: May 26-28 Post Symposium Paper Submission: June 20 Notification of Acceptance: September 7 Camera Ready Revised Paper: September 21 PROGRAMME COMMITTEE Peter Achten (co-chair) Radboud Univ. Nijmegen, NL Andrew Butterfield Trinity College, IE Manuel Chakravarty Univ. of New South Wales, AU John Clements Cal Poly State Univ., USA Matthias Felleisen Northeastern Univ., USA Jurriaan Hage Utrecht Univ., NL Michael Hanus Christian-Albrechts Univ. zu Kiel, DE Ralf Hinze Univ. of Oxford, UK Graham Hutton Univ. of Nottingham, UK Johan Jeuring Utrecht Univ., NL Pieter Koopman (co-chair) Radboud Univ. Nijmegen, NL Shriram Krishnamurthi Brown Univ., USA Hans-Wolfgang Loidl Ludwig-Maximilians Univ.München, DE Rita Loogen Philipps-Univ. Marburg, DE Greg Michaelson Heriot-Watt Univ., UK Marco T. Morazán (symp. chair) Seton Hall Univ., USA Sven-Bodo Scholz Univ. of Hertfordshire, UK Ulrik Schultz Univ. of Southern Denmark, DK Clara Segura Univ. Complutense de Madrid, ES Olin Shivers Northeastern Univ., USA Phil Trinder Heriot-Watt Univ., UK Varmo Vene Univ. of Tartu, EE Viktória Zsók Eötvös Loránd Univ., HU ORGANIZATION Symposium Chair: Marco T. Morazán, Seton Hall University, USA Programme Chair: Peter Achten, Pieter Koopman, Radboud University Nijmegen, NL Treasurer: Greg Michaelson, Heriot-Watt University, UK

1 0

Announce: CC-delcont 0.2
by Dan Doel 01 Feb '08

01 Feb '08

Hello all, After much distraction and laziness on my part (my apologies), I have finally gotten around to putting together a new release of the delimited continuations library CC-delcont. It is now available on hackage. Relevant changes include: * Now builds in GHC-6.8.x * Builds with -Wall (and the code was cleaned up to make as little noise as possible) (Thanks to gwern for the above) Also included is a new module, Control.Monad.CC.Cursor, which provides some functions for reifying traversals into cursors that can be passed around and manipulated. It's still in its infancy, but I hope to eventually include generalized zippers and such. GHC 6.8 or greater is required to build, and haddock 2.0 or greater is required to generate the documentation. Links: * hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/CC-delcont-0.2 * darcs: http://code.haskell.org/~dolio/CC-delcont/ * a brief tutorial: http://haskell.org/haskellwiki/Library/CC-delcont (I've not had too much feedback on this, so if anyone has trouble following some sections, or has ideas on how to better explain delimited continuations, changes are welcome.) Once again, if you discover any bugs, or have any suggestions, don't hesitate to let me know. -- Dan Doel

1 0