- Haskell - Haskell.org

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 02 Nov '03

02 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

Re: GHC and Kinds
by Steffen Mazanek 30 Oct '03

30 Oct '03

Hello, > It means that Kinds are represented by Types. > > Admittedly, Kinds only use a small fragment of what Types can represent, > namely Arrow, and type constructor applications. So * is represented by > a TyConApp with a TyCon that is called typeCon. > > The really annoying thing about Kinds is that there's occasionally a bit > of sub-kinding. In particular > > error :: forall a. String -> a > > We want to allow > error "foo" :: Int# I have subkinding in my calculus as well, but in a completely different context. For instance, the kind of Either is + -> + -> * because Either is covariant in its arguments. But the kind of Either is also x -> x -> * (x=invariance). So we have + -> + -> * as the most specific kind of Either. Note, that the kind arrow in my system is contravariant as well. I think, that is a nice analogy to the type system. For example, let tau_1:(x -> *) -> *, tau_2:(+ -> *) -> *. Then tau_1 is usable whenever tau_2 is in operation. So from (+ -> *) <: (x -> *) it follows in my system, that (x -> *) -> * <: (+ -> *) -> *. Unfortunately I have to decide two contexts of the kind arrow. To understand this, consider my definition of kinds: Def.: Kinds are inductively defined as follows: * is a kind if kappa1 and kappa2 are kinds, then kappa1 -> kappa2 is a kind if kappa is a kind, then + -> kappa, - -> kappa, x -> kappa and alpha -> kappa alpha is a so-called kind variable, that can be instantiated by +, - or x (not by arbitrary kinds!). Further on, we have the convention, that * -> kappa has to be seen as x -> kappa. What do we mean by the term kind variable? A type tau may have the kind (alpha->beta->*)->alpha->beta->*. If one applies this type, e.g., to the arrow type constructor one gaines (tau (->)): - -> + -> *. So information about variances is propagated. This allows for subtyping in a convenient manner. > so the kind of 'a' can't be *, nor # (the kind of unboxed types). It's > an "open" kind, written "?"; both * and # are sub-kinds of ?. I have read about this issue in the sources of the GHC. I try to understand... > You should nevertheless be able to encode your kind system in the same > way as GHC does. This is a pity, because my kind system allows for a really nice type inference algorithm, that can deal with higher-kinded types properly. I hope, that I can transfer it to the GHC. I will write a short section for the commentary as soon as I completely understand the GHC kind system. > But I have been thinking that it's over-kill to use Types for Kinds, and > leads to no real saving. I think so, too, because the system from "Typing Haskell in Haskell" is very easy to understand and extend. Another advantage is, that it is closer to the Haskell report. > I may well split the two types in the future. This would be great. Thank you for the informations, Steffen Mazanek

1 0

DrIFT 2.0.1
by John Meacham 29 Oct '03

29 Oct '03

I know it has been a while, but DrIFT 2.0.1 is out. http://repetae.net/john/computer/haskell/DrIFT/ some improvments are: DrIFT-2.0.1: * fixed many warnings in generated code * support for strict fields in constructors * support for infix constructors * added help messages and categorization to rules * small isLiterate fix (TODO use nhcs deliterizer) * prints debug info in comment in chaseImports * code cleanups * integrated some changes from Strafunski-DrIFT 1.7 * autoconf/automake improvements -- --------------------------------------------------------------------------- John Meacham - California Institute of Technology, Alum. - john(a)foo.net ---------------------------------------------------------------------------

1 0

literate comments
by Steffen Mazanek 28 Oct '03

28 Oct '03

Hello, in the Haskell report the latex code environment is mentioned: http://www.haskell.org/onlinereport/literate.html Would it make sense, to add a xml like code environment as well, e.g., <code>...</code>? Ciao, Steffen

5 5

[Cfp] Workshop on Practical Aspects of High-level Parallel Programming (PAPP 2004)
by F. Loulergue 27 Oct '03

27 Oct '03

======================================================================== ==== Workshop on Practical Aspects of High-level Parallel Programming (PAPP 2004) http://f.loulergue.free.fr/PAPP2004 part of The International Conference on Computational Science http://www.cyfronet.krakow.pl/iccs2004/ June 7-9, 2004, Kraków, Poland Aims and scope Many applications of computing require performance levels attainable only on parallel architectures. Such systems are now readily available as their price/performance ratio continues to improve. The rapid development of affordable hardware for parallel computing makes the need to develop high-quality parallel software increasingly urgent. Sequential programming has long benefited from high-level programming techniques and tools that have made today's immense range of software economically viable. Two decades of research into high-level parallel programming (algorithmic skeletons, parallel extensions of functional languages, such as Haskell and ML, or parallel logic and constraint programming, parallel execution of declarative programs such SQL queries, etc.) has produced methods and tools that improve the price/performance ratio of parallel software, and broaden the range of target applications. Several emerging domains, such as Grid Computing, are currently raising new issues. GRIDs offer tremendous computing power. Nevertheless, this power is far from being effectively exploited. In addition to technical problems related to portability and access, Grid computing needs new programming paradigms. The PAPP workshop focuses on practical aspects of high-level parallel programming: design, implementation and optimization of high-level programming languages and tools (performance predictors working on high-level parallel/grid source code, visualisations of abstract behaviour, automatic hotspot detectors, high-level GRID resource managers, compilers, automatic generators, etc.), applications in all fields of high-performance computing, benchmarks and experiments. Research on high-level grid programming is particularly relevant. Topics We welcome submission of original, unpublished papers in English on topics including: - high-level programming models and tools for GRID computing - high-level parallel language design, implementation and optimisation - functional, logic, constraint programming for parallel, distributed and Grid systems - algorithmic skeletons and high level parallel libraries - generative (e.g. template-based) programming with algorithmic skeletons and high level parallel libraries - applications in all fields of high-performance computing (using high-level tools) - benchmarks, experiments using such languages and tools Paper submission and publication Prospective authors are invited to submit full papers in English presenting original research. Submitted papers must be unpublished and not submitted for publication elsewhere. Papers will go through a rigorous reviewing process. Each paper will be reviewed by at least two referees. The accepted papers will be published in the Springer-Verlag LNCS series, as part of the ICCS proceedings. Papers (PDF file) should be sent to loulergue(a)univ-paris12.fr with subject "[PAPP Workshop] Submission" no later than Monday 8 December 2003. We invite you to submit a full paper of 6 to 10 pages (A4), describing new and original results. The submitted paper must be formatted according to the rule of Lecture Notes in Computer Science (LNCS). Submission implies the willingness of at least one of the authors to register and present the paper. An early email with your intention to submit a paper would be greatly appreciated (especially if you have doubts about the relevance of your paper). Important Dates December 8, 2003 (FIRM DEADLINE) Full paper due January 9, 2004 Notification Februray 10, 2004 Camera-ready paper due Programme committee Rob Bisseling (Univ. of Utrecht, The Netherlands) Matthieu Exbrayat (Univ. of Orléans, France) Clemens Grelck (Univ. of Lübeck, Germany) Kevin Hammond (Univ. of St. Andrews, UK) Zhenjiang Hu (Univ. of Tokyo, Japan) Frédéric Loulergue (Univ. Paris Val de Marne, France) Quentin Miller (Miller Research Ltd., UK) Susanna Pelagatti (Univ. of Pisa, Italy) Alexander Tiskin (Univ. of Warwick, UK) Chair and Organizer Dr. Frédéric LOULERGUE Laboratory of Algorithms, Complexity and Logic (LACL) University of Paris Val de Marne 61, avenue du Général de Gaulle F-94010 CRÉTEIL - FRANCE loulergue(a)univ-paris12.fr ======================================================================== ====

1 0

REMINDER - Contributions to HC&A Report (November 2003 edition)
by C.Reinke 27 Oct '03

27 Oct '03

Dear Haskeller, *you* are still envited to let the Haskell community know what you've been doing with Haskell recently! Remember, in spite of its printable formats, this is still basically an email survey: - just hit the reply button now, and take a few minutes to compose your contribution about your own recent Haskell work and play (ASCII-format is fine, LaTeX is fine - please do not send HTML..). - if you know of someone else doing interesting stuff with Haskell (perhaps even at work?-), who is not yet confirmed on our topics and contributors list below, let them know about this survey, and encourage them to contribute (please cc me, so that I know what contributions to expect) As you can see from the topics and contributors page for our Haskell Communities & Activities Reports, at: http://www.haskell.org/communities/topics.html both confirmations from well-known contributors and offers from new contributors are still a bit sparse at this stage, although we're making progress (I'm delighted to see that most contributors send their text with their confirmation - thanks!-). ----------------------------------------------------------------- Haskell Communities and Activities Report (November 2003 edition) http://www.haskell.org/communities/ Could everybody send in their individual reports ** by the end of THIS week ** ? Please?-) ----------------------------------------------------------------- Thanks, Claus (current editor) -- Haskell Communities and Activities Report (November 2003 edition) Contributions are due in by the end of THIS week! http://www.haskell.org/communities/

1 0

Call for papers: Fourth International Workshop on Reduction Strategies in Rewriting and Programming (WRS'04)
by Sergio Antoy 27 Oct '03

27 Oct '03

=============================================================== We apologize for multiple copies of this call for participation =============================================================== ******************************** * * * WRS'04 CALL FOR PAPERS * * * ******************************** http://www-i2.informatik.rwth-aachen.de/WRS04/ The Fourth International Workshop on Reduction Strategies in Rewriting and Programming (WRS'04) will be held on June, 2, 2003, in Aachen, Germany, as a part of the Federated Conference on Rewriting, Deduction, and Programming (RDP'04). IMPORTANT DATES: March 17, 2004 Deadline for electronic submission of papers April 14, 2004 Notification of acceptance of papers May 2, 2004 Deadline for final versions of accepted papers June 2, 2004 Workshop TOPICS include, but are not restricted to: * theoretical foundations for the definition and semantic description of reduction strategies * strategies in different frameworks (term rewriting, graph rewriting, infinitary rewriting, lambda calculi, higher order rewriting, conditional rewriting, rewriting with built-ins, narrowing, constraint solving, etc.) and their application in (equational, functional, functional-logic) programming (languages) * properties of reduction strategies / computations under strategies (e.g., completeness, computability, decidability, complexity, optimality, (hyper-)normalization, cofinality, fairness, perpetuality, context-freeness, neededness, laziness, eagerness, strictness) * interrelations, combinations and applications of reduction under different strategies (e.g., evaluation mechanisms in programming languages, equivalence conditions for fundamental properties like termination and confluence, applications in modularity analysis, connections between strategies of different frameworks, etc.) * program analysis and other semantics-based optimization techniques dealing with reduction strategies * rewrite systems / tools / implementations with flexible / programmable strategies as essential concept / ingredient * specification of reduction strategies in (real) languages * tutorials and systems related to evaluation strategies INVITED TALKS will be given by: * Olivier Danvy (University of Aarhus, Denmark), Normalization by Evaluation * Jan Willem Klop (Vrije Universiteit Amsterdam, The Netherlands), Reduction Cycles PROGRAM COMMITTEE: Sergio Antoy Portland (USA) (co-chair) Roberto Di Cosmo Paris VII (France) Juergen Giesl Aachen (Germany) Bernhard Gramlich Wien (Austria) Salvador Lucas Valencia (Spain) Aart Middeldorp Innsbruck (Austria) Jaco van de Pol Amsterdam (The Netherlands) Pierre Rety Orleans (France) Amr Sabry Bloomington (USA) Yoshihito Toyama Sendai (Japan) (co-chair) SUBMISSIONS: We solicit papers on all aspects of reduction strategies in rewriting and programming. Submissions should describe unpublished work, except for survey papers which are explicitly welcome, too. Submissions should not exceed 10 pages (however, survey papers may be longer) and be sent in PostScript or PDF format to the PC co-chairs at wrs04(a)redstar.cs.pdx.edu by March 17, 2004. The use of the style file available from the RDP workshop style page is encouraged. The call-for papers is also available in PDF format. Submissions should include the title, authors' names, affiliations, addresses, and e-mail. Selection of papers by the PC will be based on originality, significance, and correctness. Final versions will be due by May 2, 2004. PUBLICATION: Accepted papers will be included in the preliminary workshop proceedings that will be available at the workshop. The final workshop proceedings will be published in Elsevier's Electronic Notes in Theoretical Computer Science (ENTCS) series. For further questions please contact the program co-chairs: Sergio Antoy and Yoshihito Toyama at wrs04(a)redstar.cs.pdx.edu.

1 0