November 2003 - Haskell

access to fields in nested records
by Serge D. Mechveliani 05 Nov '03

05 Nov '03

Dear Haskellers, My question is about a nice way to provide a getting/setting access to the nested record fields. Example: --------------------------------------------------------------- data House = House {houseNo :: Int, diningRoom :: DiningRoom } deriving (Show) data DiningRoom = DRoom {square :: Int, height :: Int, numOfWindows :: Int, diningTable :: DTable } deriving (Show) data DTable = DTable {tableSquare :: Int, diningPlaces :: Int } deriving (Show) -- example: r1 = DRoom {square = 50, height = 300, numOfWindows = 1, diningTable = dt } where dt = DTable {tableSquare = 16, diningPlaces = 12 } --------------------------------------------------------------- Question 1: how to change a field in a record? I see the following way. For example, setSquare :: DiningRoom -> Int -> DiningRoom setSquare r n = DRoom {square = n, height = height r, numOfWindows = numOfWindows r, diningTable = diningTable r } Example of usage: setSquare r1 (square r2) for r1, r2 :: DiningRoom Has indeed one to program the above functions, like setSquare, for all the records, or there exist some Haskell annotations, or standard library function for such purpose, which allow to skip extra remaining fields in the data, like these three fields in DiningRoom ? Question 2: how to get/update a field in a nested record? For example, dtableSquareFromRoom :: DiningRoom -> Int dtableSquareFromHouse :: House -> Int dtableSquareFromRoom = tableSquare . diningTable dtableSquareFromHouse = dtableSquareFromRoom . diningRoom setDTableSquareToHouse :: House -> Int -> House setDTableSquareToHouse h n = House { houseNo = houseNo h, diningRoom = setDTableSquareToRoom (diningRoom h) n } where setDTableSquareToRoom r n = ... Has indeed one to program such functions for each path to a field in the record nesting hierarchy? I see the main difficulty in a great number of functions to use for the same field access from different structures. I try to improve this by adding classes with get_ and set_ versions of operations for the record fields: class HouseLike a where get_houseNo :: a -> Int get_diningRoom :: a -> DiningRoom set_houseNo :: a -> Int -> a set_diningRoom :: a -> DiningRoom -> a ... Now, defining the instances, say, for get_dtableSquare, set_dtableSquare, makes it a unique function pair to use for getting/setting of the corresponding field starting from House or DiningRoom or DiningTable. Is this all a reasonable design for a Haskell user program? Thank you in advance for the respond. Please, add mechvel(a)botik.ru to the reply list. ------------------ Serge Mechhveliani mechvel(a)botik.ru

2 1

AW: Boilerplate revisited
by Markus.Schnell＠infineon.com 05 Nov '03

05 Nov '03

> > data Foo = Foo Int String > > and you're looking for Ints and transforming them, it will > also recurse > into the strings and look at every character, because it > doesn't know that Hm. That could be. I think the problem is that segment is > data Segemnt = Comp [Segment] Attributes and 'everywhere (mkT f) seg' would also jump into the attributes, which is waisted effort. -- Markus

1 0

darcs 0.9.13 rpms available
by Jens Petersen 05 Nov '03

05 Nov '03

I rpm-packaged darcs[1] 0.9.13 for Linux/ix86. You can get the srpm and binary rpms from: http://haskell.org/~petersen/rpms/darcs/ Enjoy, -Jens Footnotes: [1] http://abridgegame.org/darcs/

1 0

Re: Data types basics
by Thomas L. Bevan 05 Nov '03

05 Nov '03

In Haskell, data types and contructors must be designated by names whose first letter is capitalised. So, > data currency = ... is illegal. Instead use, > data Currency = Dollar Double | Pound Double | Zloty Double | Euro Double Above are four data constructors and they can be used to contruct a datum of the type Currency. They can be exploited in functions through pattern matching as follows, > toDollar :: Currency -> Currency > toDollar (Pound d) = Dollar ( d / 2 ) > toDollar (Euro d) = Dollar ( d / 1.01 ) > ... I think, to answer your last question, that they are functions, however they can only be defined using a much more limited syntax. I'm sure someone else can give a fuller answer here. Tom

1 0

ANN: Haskell tools from the Programatica project
by Thomas Hallgren 05 Nov '03

05 Nov '03

Hi, For those who are curious about what we have been up to in the Programatica project (perhaps because you who saw the demo at the Haskell Workshop this year, or read the demo abstract), we now have a web page where you can * find out more about what the tools can be used for, * download binary snapshot of our command-line tools and graphical Haskell browser, * find out how to access the Programatica Tools CVS repository, * browse the source code on-line. The location of the web page is: http://www.cse.ogi.edu/~hallgren/Programatica/ Note that this is work in progress, we welcome feedback. Also, while the tools we provide might contain some functionality useful to Haskell programmers, it should also be possible to reuse our source code (which has a lot in common with a Haskell compiler front-end) to build other Haskell tools. In fact, it has already been reused in the Haskell refactoring project at the University of Kent. -- Thomas Hallgren The Programatica Project http://www.cse.ogi.edu/PacSoft/projects/programatica/

1 0

Boilerplate revisited
by Markus.Schnell＠infineon.com 04 Nov '03

04 Nov '03

Perhaps some remember the question I posted about avoiding boilerplate some time ago: (http://haskell.org/pipermail/haskell/2003-August/012479.html) After some experimentation I employed Hal's DynamicMap as well as the Generics library. This worked fine for a while, but after I started using my program on bigger problems it soon turned out that the program spent more than 40% (!) of its memory on the lookupDM operation and most of its time on stypeOf. This was not acceptable and so I switched back to my original solution (albeit somewhat easier implemented), which is... ...using lots of boilerplate. The memory usage drops to roughly 2% for lookupDM. For those interested, the approach is described below. Instead of coding the boilerplate by hand, I wrote a function for automatic generation, making it more robust and extensible. There's also room for improvement, but I needed a quick, working solution, not a perfect one. The alert reader may have noticed that I didn't mention Generics again. First I was using a map function like this > segmap f s = everywhere (mkT f) s planning to explore some of the visiting strategies. But this resulted in spending a lot of time in the segmap function, while using a self-written map on the structure was much faster. I didn't keep records, though. Perhaps the boilerplate people (Ralf Lämmel, Simon PJ) have already looked at performance issues? If you stayed with me, thank you for your time. Markus === Approach Description === Four modules are of interest: Defs - attribute definitions Attribute - setter/getter/helper functions MyTypeable - boilerplate DynamicMap - an interface to finite map Here are the prototypical implementations: module Defs where data Gender = Masc | Fem | Neutr deriving (Eq, Show) data Accented = Accented deriving (Eq, Show) data Focused = Focused deriving (Eq, Show) ... module Attribute ( Gender , gender, accented, focused , ggender, isAccented, isFocused ) where import Defs import MyTypeable import DynamicMap ... -- Segment is the manipulated structure, containing the attributes sattr :: (MyTypeable a) => a -> Segment -> Segment sattr a s = s { attrs = sattrW a (attrs s) } sattrW :: (MyTypeable a) => a -> Attrs -> Attrs sattrW x = (flip addToDM) x gattr :: (MyTypeable a) => Segment -> Maybe a gattr = gattrW . attrs gattrW :: (MyTypeable a) => Attrs -> Maybe a gattrW = lookupDM type GetAttr a = Segment -> Maybe a type SetAttr a = a -> Segment -> Segment ggender = gattr :: GetAttr Gender gender = sattr :: SetAttr Gender accented = sattr Accented focused = sattr Focused isAccented, isFocused :: Segment -> Bool isAccented = isJust . (gattr::GetAttr Accented) isFocused = isJust . (gattr::GetAttr Focused) ... module DynamicMap ( ... ) where -- shamelessly building on Hal Daumé's module import Data.FiniteMap import MyTypeable newtype DynamicMap = DM { unDM :: FiniteMap TypeRep TypeWrapper } -- ignoring some obvious stuff (emptyDM, ...) addToDM :: (MyTypeable a) => DynamicMap -> a -> DynamicMap addToDM (DM dm) a = DM $ addToFM dm (typeOf a) (toDyn a) lookupDM :: MyTypeable a => DynamicMap -> Maybe a lookupDM (DM dm) :: Maybe a = case lookupFM dm (typeOf (undefined :: a)) of Nothing -> Nothing Just x -> fromDyn x module MyTypeable where import Defs type TypeRep = Int class MyTypeable a where typeOf :: a -> TypeRep toDyn :: a -> TypeWrapper fromDyn :: TypeWrapper -> Maybe a -- === Start Of Automatic Generated Code ======================================= -- put in here automatic generated code -- === End Of Automatic Generated Code ======================================== -- The following generates the wrappers for the types. This is a very -- straightforward implementation, no need for optimization encountered. -- Call gentmp and put it in the "automatic generated code" section. gentmp = writeFile "tmp.txt" (generateTypeWrappers typesToWrap) typesToWrap = [ "Gender", "Accented", "Focused" ] generateTypeWrappers = generateTypeWrappers' "" "" 0 generateTypeWrappers' :: String -- TypeWrapper accu -> String -- Instances accu -> Int -- current instance -> [String] -- list of types -> String -- code string generateTypeWrappers' tpa ia n [] = "data TypeWrapper = StandInForEasierAutomaticGeneration\n" ++ tpa ++ "\n\n" ++ ia generateTypeWrappers' tpa ia n (x:xs) = generateTypeWrappers' (tpa ++ wrap n x) (ia ++ inst n x) (n + 1) xs -- make one wrap wrap n x = " | T" ++ show n ++ " " ++ x ++ "\n" -- make one instance inst n x = "instance MyTypeable " ++ x ++ " where\n" ++ " typeOf _ = " ++ show n ++ "\n" ++ " toDyn = T" ++ show n ++ "\n" ++ " fromDyn (T" ++ show n ++ " x) = Just x\n" ++ " fromDyn _ = Nothing\n\n\n"

2 1

WRLA 2004 - Second call for papers
by alberto＠sip.ucm.es 03 Nov '03

03 Nov '03

[[ -- Apologies for multiple copies of this message -- ]] + + + + + WRLA'04 + + + + + SECOND CALL FOR PAPERS + + + + + WRLA'04 + + + + + +----------------------------------------------------------+ | | | 5th International Workshop on | | Rewriting Logic and its Applications | | | | W R L A 2004 | | | | Barcelona, Spain, March 27-28, 2004 | | | | http://www.fdi.ucm.es/wrla2004 | +----------------------------------------------------------+ The workshop will be held in conjunction with ETAPS 2004 7th European Joint Conferences on Theory and Practice of Software March 27 - April 4, 2004 http://www.lsi.upc.es/etaps04 IMPORTANT DATES November 24, 2003 Deadline for submission January 15, 2004 Notification of acceptance February 18, 2004 Final version in electronic form March 27-28, 2004 Workshop in Barcelona AIMS AND SCOPE Rewriting logic (RL) is a natural model of computation and an expressive semantic framework for concurrency, parallelism, communication and interaction. It can be used for specifying a wide range of systems and languages in various application fields. It also has good properties as a metalogical framework for representing logics. In recent years, several languages based on RL (ASF+SDF, CafeOBJ, ELAN, Maude) have been designed and implemented. The aim of the workshop is to bring together researchers with a common interest in RL and its applications, and to give them the opportunity to present their recent works, discuss future research directions, and exchange ideas. The topics of the workshop comprise, but are not limited to, * foundations and models of RL; * languages based on RL, including implementation issues; * RL as a logical framework; * RL as a semantic framework, including applications of RL to - object-oriented systems, - concurrent and/or parallel systems, - interactive, distributed, open ended and mobile systems, - specification of languages and systems; * extensions of RL, including - real-time and probabilistic extensions, - tile logic, - rewriting approaches to behavioral specifications; * verification techniques for RL specifications, including - equational and coherence methods, and - verification of properties expressed in modal and temporal logics; * comparisons of RL with existing formalisms having analogous aims, including - rho-calculus, - structural operational semantics, - concurrency calculi, - dynamic algebras. PAST EVENTS Previous WRLA workshops have been organized in - Asilomar, California, September 3-6, 1996, - Pont-a-Mousson, France, September 1-4, 1998, - Kanazawa, Japan, September 18-20, 2000, - Pisa, Italy, September 19-21, 2002. The proceedings of the WRLA workshops have been published as volumes 4, 15, 36, and 71 in the Elsevier ENTCS series, available at http://www.elsevier.nl/locate/entcs Selected papers from WRLA'96 have been published in a special issue of Theoretical Computer Science, Volume 285(2), 2002. LOCATION WRLA 2004 will be held in Barcelona, Spain in March 27-28, 2004. It is a satellite workshop of ETAPS 2004, the European Joint Conferences on Theory and Practice of Software. For venue, registration and suggested accommodation see the ETAPS 2004 web page http://www.lsi.upc.es/etaps04 For information about Barcelona, see among others the city web page http://www.bcn.es/english/ihome.htm PROGRAM COMMITTEE David Basin ETH Zurich Manuel Clavel Universidad Complutense de Madrid Steven Eker SRI International, Menlo Park Kokichi Futatsugi JAIST, Tatsunokuchi Fabio Gadducci Universita di Pisa Alexander Knapp LMU, Muenchen Claude Kirchner INRIA Lorraine & LORIA, Nancy Salvador Lucas Universidad Politecnica de Valencia Narciso Marti-Oliet Universidad Complutense de Madrid (Chair) Jose Meseguer University of Illinois at Urbana-Champaign Ugo Montanari Universita di Pisa Pierre-Etienne Moreau INRIA Lorraine & LORIA, Nancy Grigore Rosu University of Illinois at Urbana-Champaign Carolyn Talcott SRI International, Menlo Park SUBMISSIONS Submissions will be evaluated by the Program Committee for inclusion in the proceedings, which will be available at the time of the workshop and are expected to be published in the Elsevier ENTCS series. Papers must contain original contributions, be clearly written, and include appropriate reference to and comparison with related work. They must be unpublished and not submitted simultaneously for publication elsewhere. Papers (of at most 15 pages) should be submitted electronically, preferably as PDF files, to the workshop email address wrla2004(a)sip.ucm.es providing also a text-only abstract, and detailed contact information of the corresponding author. The final program of the workshop will also include system demonstrations and two invited presentations by Gilles Dowek Ecole Polytechnique & INRIA, Palaiseau Mario Rodriguez-Artalejo Universidad Complutense de Madrid Based on the quality and interest of the accepted papers, the program committee will study the possibility of preparing a special issue of a scientific journal in the field. ORGANIZING COMMITTEE Narciso Marti-Oliet, Manuel Clavel, and Alberto Verdejo Departamento de Sistemas Informaticos y Programacion Universidad Complutense de Madrid, Spain CONTACT INFORMATION For more information, please contact the organizers wrla2004(a)sip.ucm.es or visit the workshop web page http://www.fdi.ucm.es/wrla2004 IMPORTANT DATES November 24, 2003 Deadline for submission January 15, 2004 Notification of acceptance February 18, 2004 Final version in electronic form March 27-28, 2004 Workshop in Barcelona + + + + + WRLA'04 + + + + + SECOND CALL FOR PAPERS + + + + + WRLA'04 + + + + +

1 0

REMINDER - Contributions to HC&A Report (November 2003 edition)
by Alain Cremieux 03 Nov '03

03 Nov '03

Category : Applications, Groups, and Individuals Subcategory : Individual Haskellers and their projects I work in a company making software for payrolling, which is a incredibly complex subject in France. I'd like to use Haskell in my everyday's work, but up to now it's only been a personal hobby ("passion" woul be more accurate). I am convinced that embedded languages ("DSEL") have strong applications in software-making companies. Of course Haskell is one of the best language for that; but if there are many fascinating papers (resulting from hard work & deep insights) on the subject, practical reusable code lacks. Most projects are unfinished, and when code exists it is in "as is" state, and never reusable without much work. So as a start I am trying to implement How to write a financial contract <http://research.microsoft.com/Users/simonpj/Papers/financial-contracts/pj-e…>, a chapter in "The Fun of Programming" by Simon Peyton Jones & Jean-Marc Eber. This article details the full analysis (the hard part) of an embedded language application. A deriving implementation should provide several solutions, depending on design decisions (for instance a "shallow" embedding and a "deep" embedding), simplifications rules leading to a (moderately) optimised interpreter and a code generator (C-- is my target language). And the code should work (calculate the value of several common financial options). Two other key papers for this work are Compiling Embedded Languages <http://www.conal.net/papers/jfp-saig/>, by Conal Elliott, Sigbjorn Finne and Oege de Moor, and Programming Graphics Processors Functionally <http://www.conal.net/papers/Vertigo/> (Vertigo) by Conal Elliott. Any advice and/or discussion would be welcome. Alain Crémieux

1 0