May 2005 - Haskell - Haskell.org

Haskell-mode 2.0
by Stefan Monnier 02 Feb '09

02 Feb '09

I have recently taken over maintainership of Haskell-mode, and after making a bunch of changes, I figured it would be a good idea to make a new release. You can find this new release at: http://www-perso.iro.umontreal.ca/~monnier/elisp/ If you think it should also be found at http://www.haskell.org/haskell-mode/, then please tell John Peterson to get back to me (my email to him seem to go straight to the bitbucket. John?). This release has several changes that have all been only lightly tested, especially w.r.t compatibility with various Emacsen. See appended the NEWS file that describes some of the notewirthy changes. Stefan Changes since 1.45: * keybindings C-c <char> have been replaced by C-c C-<char> so as not to collide with minor modes. * The following modules are now automatically activated without having to add anything to haskell-mode-hook: haskell-font-lock (just turn on global-font-lock-mode). haskell-decl-scan (just bind `imenu' to some key). * In recent Emacsen, haskell-doc hooks into eldoc-mode. * haskell-hugs and haskell-ghci are superceded by inf-haskell. * Indentation rules have been improved when using layout inside parens/braces. * Symbols like -> and \ can be displayed as actual arrows and lambdas. See haskell-font-lock-symbols. * Tweaks to the font-lock settings. Among other things paren-matching with things like \(x,y) should work correctly now. * New maintainer <monnier(a)gnu.org>.

3 6

Mixing monadic and non-monadic functions
by Sean E. Russell 17 Sep '05

17 Sep '05

Hello, I posted this question to comp.lang.functional, and someone suggested that I try this group instead. I'm struggling with monads. Well, not monads themselves, but mixing them with non-monadic functions. Here's my base case: someFunc :: String -> IO [a] ... ax <- someFunc a bx <- someFunc b assertBool "fail" $ length ax == length bx I don't like the assignments; the typing is redundant, if I have a lot of asserts like this, and the "variables" are temporary. What I'd much rather have is: ... assertBool "fail" $ (length $ someFunc a) == (length $ someFunc b) which is more readable, to my eye. The only solution which has been suggested that may work is liberal use of the liftM variants, but this gets *really* tedious and obtuse. Is there an elegant way to do what I want to do, or am I stuck with procedural-style assignments and bunches of temp vars? Thanks! -- ### SER ### Deutsch|Esperanto|Francaise|Linux|XML|Java|Ruby|Aikido ### http://www.germane-software.com/~ser jabber.com:ser ICQ:83578737 ### GPG: http://www.germane-software.com/~ser/Security/ser_public.gpg

23 37

ICFP 2005 - Final Call for Papers
by Benjamin C. Pierce 28 Jul '05

28 Jul '05

NEWS: * submission and formatting instructions are now available * the dates of the author response period have changed slightly --------- International Conference on Functional Programming (ICFP 2005) Call for Papers September 26-28, 2005 Tallinn, Estonia Submission deadline: 13 April, 2005 Submission instructions: http://www.cis.upenn.edu/~bcpierce/icfp05 ICFP 2005 seeks original papers on the art and science of functional programming. Submissions are invited on all topics ranging from principles to practice, from foundations to features, from abstraction to application. The scope includes all languages that encourage functional programming, including both purely applicative and imperative languages, as well as languages with objects and concurrency. Particular topics of interest include: * Applications and domain-specific languages: Systems programming, scientific and numerical computing, symbolic computing and artificial intelligence, databases, graphical user interfaces, multimedia programming, application scripting, system administration, distributed-systems and web programming, XML processing, security. * Foundations: Formal semantics, lambda calculus, type theory, monads, continuations, control, state, effects. * Design: Algorithms and data structures, modules and type systems, concurrency and distribution, components and composition, relations to object-oriented and logic programming. * Implementation: Abstract machines, compile-time and run-time optimization, just-in-time compilers, memory management. Interfaces to foreign functions, services, components and low-level machine resources. * Transformation and analysis: Abstract interpretation, partial evaluation, program transformation. * Software-development techniques for functional programming: Design patterns, specification, verification, validation, debugging, test generation, tracing and profiling. * Practice and experience: Functional programming in education and industry. * Functional pearls: Elegant, instructive examples of functional programming. Papers in the last three categories need not necessarily report original research results; they may instead, for example, report practical experience that will be useful to others, re-usable programming idioms, or elegant new ways of approaching a problem. A special issue of the Journal of Functional Programming will highlight selected papers from the meeting. Submission instructions are available here: http://www.cis.upenn.edu/~bcpierce/icfp05 Important Dates: Submission deadline: 13 April, 2005, at 6PM (in Philadelphia) On-line response to reviews: 19-21 May, 2005 Author notification: 3 June, 2005 Camera-ready copy: 10 July, 2005 Organizers: Conference Chair: Olivier Danvy (BRICS, University of Aarhus) Program Chair: Benjamin Pierce (University of Pennsylvania) Program Committee: Mariangiola Dezani (Universita di Torino) Mary Fernandez (AT&T Labs) Matthew Flatt (University of Utah) Cedric Fournet (Microsoft Research) Jacques Garrigue (Kyoto University) Jason Hickey (California Institute of Technology) John Hughes (Chalmers University) Johan Jeuring (Utrecht University) Frank Pfenning (Carnegie Mellon University) Benjamin Pierce (University of Pennsylvania) Andrew Pitts (University of Cambridge) Norman Ramsey (Harvard University) Manuel Serrano (INRIA Sophia Antipolis) Peter Thiemann (Universitat Freiburg) Jan Vitek (Purdue University)

2 1

WS-FM 2004 Call For Participation
by Mario Bravetti 20 Jul '05

20 Jul '05

---------------------------------------------------------------------- We apologize if you receive multiple copies of this announcement. ---------------------------------------------------------------------- ====================================================================== 1st International Workshop on Web Services and Formal Methods (WS-FM 2004) February 23-24, 2004, Pisa, Italy Workshop affiliated to COORDINATION 2004, February 24-27, 2004 WS-FM 2004 homepage: http://www.cs.unibo.it/~lucchi/ws-fm04/ ====================================================================== - The technical program is available at: http://www.cs.unibo.it/~lucchi/ws-fm04/ - Information about registration, travel and accomodation can be found at the COORDINATION 2004 web site: http://www.di.unipi.it/Coordination2004/ If you intend to participate, we recommend you to register and book the hotel as soon as possible. The Coordination 2004 Organizing Committee informed us that hotels are going to be fully booked in short time.

1 1

WS-FM 2005 2nd Call For Papers (submission deadline extended to may 6)
by Mario Bravetti 24 Jun '05

24 Jun '05

====================================================================== 2nd International Workshop on Web Services and Formal Methods (WS-FM 2005) 1-3 September 2005, Versailles, France http://cs.unibo.it/WS-FM05 Co-located with EPEW'05 2nd European Performance Evaluation Workshop ====================================================================== SCOPE Web Services technology aims at providing standard mechanisms for describing the interface and the services available on the web, as well as protocols for locating such services and invoking them (e.g. WSDL, UDDI, SOAP). Innovations are moving towards two main directions: The first one tends to the definition of new standards that support the specification of complex services out of simpler ones (the so called Web Service orchestration and choreography). Several proposals have been already set up: BPML, XLANG and BizTalk, WSFL, WS-BPEL, WS-CDL, etc... The second approach consists of the design of new (meta-)Web Services to be exploited at run-time by other Web Services: e.g. managing the cooperation of Web Services or acting as dynamic registry services. Formal methods, which privide formal machinery for representing and analysing the behavior of communicating concurrent/distributed systems, may potentially play a fundamental role in the development of such innovations. First of all they may help in understanding the basic mechanisms (in terms of semantics) which characterize different orchestration and choreography languages and to focus on the essence of new features that are needed. Secondly they may provide a formal basis for reasoning about Web Service semantics (behaviour and equivalence): e.g. for realizing registry services where retrieval is based on the meaning of a service and not just a Web Service name. Thirdly also studies on formal coordination paradigms can be exploited for developing mechanisms for complex run-time Web Service coordination. Finally, given the importance of critical application areas for Web Services like E-commerce, the development of the Web Service technology can certainly take advantage from formal analisys of security properties and performance in concurrency theory. The aim of the workshop is to bring together researchers working on Web Services and Formal Methods in order to activate a fruitful collaboration in this direction of research. This, potentially, could also have a great impact on the current standardization phase of Web Service technologies. LIST OF TOPICS The topics of interest include, but are not limited to: - Protocols and standards for WS (SOAP, WSDL, UDDI, etc... ) - Languages and descripion methodologies for Coreography/Orchestration/Workflow (BPML, XLANG and BizTalk, WSFL, WS-BPEL, WS-CDL, YAWL, etc... ) - Coordination techniques for WS (transactions, agreement, coordination services, etc...) - Semantics-based dynamic WS discovery services (based on Semantic Web/Ontology techniques or other semantic theories) - Security, Performance Evaluation and Quality of Service of WS - Semi-structured data and XML related technologies - Comparisons with different related technologies/approaches SUBMISSIONS Submissions must be original and should not have been published previously or be under consideration for publication while being evaluated for this workshop. Papers are to be prepared in LNCS format and must not exceed 15 pages. Accepted original papers will be published in the workshop proceedings. It is planned to publish the proceedings in the Springer Lecture Notes in Computer Science (LNCS) series ( www.springeronline.com/lncs ). As done for the previous WS-FM'04 workshop, we intend to publish a journal special issue inviting full versions of papers selected among those presented at the workshop. IMPORTANT DATES May 6, 2005: Submission deadline (EXTENDED) June 10, 2005: Notification of acceptance June 20, 2005: Camera ready September 1-3, 2005: Workshop dates PROGRAM CO-CHAIRS Mario Bravetti and Gianluigi Zavattaro PROGRAM COMMITTEE: Marco Aiello University of Trento, Italy Jean-Pierre Banatre University of Rennes1 and INRIA, France Boualem Benatallah University of New South Wales, Australia Karthik Bhargavan Microsoft research Cambridge, UK Manfred Broy Technische Universitat Munchen, Germany Roberto Bruni University of Pisa, Italy Michael Butler University of Southampton, UK Fabio Casati HP Labs, USA Rocco De Nicola University of Florence, Italy Schahram Dustdar Wien University of Technology, Austria Gianluigi Ferrari University of Pisa, Italy Jose Luiz Fiadeiro University of Leicester, UK Peter Furniss Choreology Ltd, UK Stephanie Gnesi CNR Pisa, Italy Reiko Heckel University of Leicester, UK Nickolas Kavantzas Oracle Co., USA Leila Kloul Université de Versailles, France Mark Little Arjuna Technologies Limited, UK Natalia López University Complutense of Madrid, Spain Roberto Lucchi University of Bologna, Italy Jeff Magee Imperial College London, UK Fabio Martinelli CNR Pisa, Italy Shin Nakajima National Institute of Informatics and JST, Japan Manuel Nunez University Complutense of Madrid, Spain Fernando Pelayo University of Castilla-La Mancha, Albacete, Spain Marco Pistore University of Trento, Italy Wolfgang Reisig Humboldt University, Berlin, Germany Vladimiro Sassone University of Sussex, UK Frank Van Breugel York University, Toronto, Canada Friedrich Vogt Technical University of Hamburg-Harburg, Germany

1 1

SOS 2005: Call for Papers
by sos2005＠mcs.le.ac.uk 22 Jun '05

22 Jun '05

First Call for Papers: Structural Operational Semantics 2005 A Satellite Workshop of ICALP 2005 July 10, 2005, Lisbon, Portugal http://www.cs.le.ac.uk/events/SOS2005 Aim: Structural operational semantics (SOS) provides a framework for giving operational semantics to programming and specification languages. A growing number of programming languages from commercial and academic spheres have been given usable semantic descriptions by means of structural operational semantics. Because of its intuitive appeal and flexibility, structural operational semantics has found considerable application in the study of the semantics of concurrent processes. Moreover, it is becoming a viable alternative to denotational semantics in the static analysis of programs, and in proving compiler correctness. Recently, structural operational semantics has been successfully applied as a formal tool to establish results that hold for classes of process description languages. This has allowed for the generalization of well-known results in the field of process algebra, and for the development of a meta-theory for process calculi based on the realization that many of the results in this field only depend upon general semantic properties of language constructs. This workshop aims at being a forum for researchers, students and practitioners interested in new developments, and directions for future investigation, in the field of structural operational semantics. One of the specific goals of the workshop is to establish synergies between the concurrency and programming language communities working on the theory and practice of SOS. Moreover, it aims at widening the knowledge of SOS among postgraduate students and young researchers from the U.K. and abroad. Specific topics of interest include (but are not limited to): * programming languages * process algebras * higher-order formalisms * rule formats for operational specifications * meaning of operational specifications * comparisons between denotational, axiomatic and SOS * compositionality of modal logics with respect to operational specifications * congruence with respect to behavioural equivalences * conservative extensions * derivation of proof rules from operational specifications * software tools that automate, or are based on, SOS. Papers reporting on applications of SOS to software engineering and other areas of computer science are welcome. History: The first SOS Workshop took place on 30th of August 2004 in London as one of the satellite workshops of CONCUR 2004. Over 30 participants attended the workshop. PAPER SUBMISSION: We solicit unpublished papers reporting on original research on the general theme of SOS. Prospective authors are invited to submit their work in two stages: Firstly, the title and abstract of the paper, together with the details of the author(s), should be emailed to sos2005 AT mcs.le.ac.uk by: Friday, 13 May 2005. Secondly, a pdf file with their full paper, whose length normally should not exceed 15 pages, should be sent by email to sos2005 AT mcs.le.ac.uk by: Monday, 23 May 2005. The email message with the full paper should also include, in plain text, contact information for the author(s), the title and abstract of the submission. Authors will be notified of acceptance by Monday, 13 June 2005. Submissions from the PC members are allowed. Proceedings: Preliminary proceedings containing the abstracts of the talks will be published as a Technical Report of the Department of Computer Science of Leicester University, and will be available at the meeting. The final proceedings of the workshop will appear as a volume in the ENTCS series. If the quality and quantity of the papers accepted for the workshop warrant it, submissions will be invited for a special issue of an archival journal devoted to full versions of selected papers. IMPORTANT DATES: * Submission of abstract: Friday, 13 May 2005 * Submission of full paper: Monday, 23 May 2005 * Notification: Monday, 13 June 2005 * Final version: Friday, 24 June 2005 * Workshop: Sunday, 10 July 2005. PROGRAMME COMMITTEE: Luca Aceto (BRICS, Aalborg, DK) Wan Fokkink (Amsterdam, NL) Rob van Glabbeek (NICTA, AU) Matthew Hennessy (Sussex, UK) Ralf Laemmel (CWI, NL) Peter Mosses (Swansea, UK, co-chair) David Sands (Chalmers, SE) Alex Simpson (Edinburgh, UK) Simone Tini (Insubria, I) Irek Ulidowski (Leicester, UK, co-chair) Erik de Vink (Eindhoven, NL) INVITED SPEAKERS: Jan Friso Groote Jose Meseguer CONTACT: sos2005 AT mcs.le.ac.uk WORKSHOP ORGANISERS: Peter D. Mosses Department of Computer Science University of Wales Swansea Singleton Park Swansea, SA2 8PP United Kingdom Irek Ulidowski Department of Computer Science University of Leicester University Road Leicester, LE1 7RH United Kingdom

2 1

ANNOUNCE: The jhc Haskell compiler.
by John Meacham 02 Jun '05

02 Jun '05

See what I've been doing :) This document as html is available at http://repetae.net/john/computer/jhc/jhc.html and the main jhc page with links to the darcs repo is at http://repetae.net/john/computer/jhc/ = Jhc = Jhc is a compiler for Haskell that aims to produce very efficient code as well as explore novel compilation techniques in an attempt to make them practical. One thing jhc does not aim to be is a toy or proof-of-concept compiler. A lot of the techniques have already had proof-of-concept implementations and jhc aims to determine how to bring them to a full-scale Haskell compiler. (or die trying) Although jhc is not ready for general use, I think some of its ideas or code might be useful to other people so I am deciding to release it in this state. == Jhc Bullet Points == * Full support for Haskell 98, The FFI and some extensions. (modulo some bugs being worked on and some libraries that need to be filled out) * Produces 100% portable ISO C. The same C file can compile on machines of different byte order or bit-width without trouble. * No pre-written runtime. other than 20 lines of boilerplate all code is generated from the Grin intermediate code and subject to all code simplifying and dead code elimination transformations. As a result, jhc currently produces the smallest binaries of any Haskell compiler. (main = putStrLn "Hello, World!" compiles to 6,568 bytes vs 177,120 bytes for GHC 6.4) * No garbage collector. A variant of Region Inference is in the works. * Compilation by transformation with 2 general intermediate languages. * First Intermediate language based on Henk, Pure Type Systems and the Lambda cube. This is similar enough to GHCs core that many optimizations may be implemented in the same way. * Second Intermediate language is based on Boquist's graph reduction language. This allows all unknown jumps to be compiled out leaving standard case statements and function calls as the only form of flow control. Combined with jhc's use of region inference, this means jhc can compile to most any standard imperative architecture/language/virtual machine directly without special support for a stack or tail-calls. * Novel type class implementation not based on dictionary passing with many attractive properties. This implementation is possible due to the whole-program analysis phase and the use of the lambda-cube rather than System F as the base for the functional intermediate language. * Intermediate language and back-end suitable for directly compiling any language that can be embedded in the full lambda cube, making things like a compiler for cayenne much more direct. There is no type erasure phase, types are erased for the simple reason that values do not depend on them via the standard dead-code elimination pass. * A very modern design, it using rank-n polymorphism, monad transformers, generic programing, and existential types to make the code very concise and clear and improve code reuseability. (since jhc was written in pieces over 5 years, some at times when I just started using Haskell, the code quality actually varies a lot across the whole project) * All indirect jumps are transformed away, jhc's final code is very similar to hand-written imperitive code, using only branches and static function calls. A simple basic-blocks analysis is enough to transform tail-calls into loops. * Full transparent support for mutually recursive modules. == More in depth == === Type Classes === One of the most novel things about jhc is its implementation of type classes which differs significantly from the standard dictionary passing approach used by other Haskell compilers. Jhc's unique approach is made possible by 2 other design choices, the use of a pure type system with no distinction between types and values and its use of whole-program analysis. The basic idea is that instead of passing a dictionary, a case statement directly scrutinizes the type parameter of a function and calls the appropriate overloaded routine directly. This has a number of interesting properties * The number of extra hidden parameters is the number of free type variables in a functions signature rather than the number of class constraints. So (Ord a, Show a, Num a) => a -> a will only pass a single extra parameter for the type of a rather than 3 dictionaries. * 2 indirections, first one to look up the dictionary, then one to call the function pointed to in the dictionary are replaced by a single case of an algebraic data type and calls to statically known functions. This is exactly the transformation that the GRIN points-to analysis does, but much sooner and with much better optimization potential. Calls to statically known functions are MUCH more efficient. * Standard case coalescing optimizations have a dramatically enhanced effect when dealing with overloaded functions. imagine the code snipped (x*(y + z)/z) :: a . Each of the calls to the polymorphic functions *, +, and / will expand to a case statement on 'a', since all case statements are trivially examining the same value, they are coalesced into a single one. With dictionary passing, we would have to look up the appropriate entry in the Num hidden parameter, the Floating hidden parameter, then look up each of *, +, and / individually. Under jhc's scheme all of that is statically transformed into a single case on a normal algebraic type. This optimization is a HUGE win. Jhc's ability to do this comes from the fact that it is statically evident from that case statement that the type fully determines every polymorphic function on that type, a property that is lost in the dictionary passing approach since as far as the compiler is concerned, arbitrary functions may be being passed in the dictionaries, it does not know that they come in specific correlated sets. * Functional Dependencies actually lead to run-time savings. each functional dependency transforms into a case statement which may be omitted. * Although a whole-world analysis is needed to generate full versions of type class methods, this is actually rarely needed in practice, as it is often the case the compiler is able to statically prove only a certain subset of types are needed at any given point and is able to generate specialized versions on the spot. This is implemented in a manner very similar to GHC's rules. * Advanced compile-time and run-time specializations are possible via pragmas. (see below) === E === E is a pure type system based on Henk and the lambda-cube. An important property of E is that there is no distinction between types and values, this is important for jhc's implementation of type classes. === Grin === Grin is basically a first-order monadic functional language. It is very similar to the Graph Reduction Intermediate Language as defined by Boquist but has a few notable changes. * It is typed. * It has multiple return values as a primitive (unboxed tuples) * My target is higher level C or C-- rather than RISC code, so some transformations are less important as the C compiler can be assumed to take care of them. * The terminology and syntax borrows from Haskell's current implementation of monads and 'do' notation. Most of the transformations mentioned in Boquist's thesis have been implemented, however certain intermediate states in Boquist's scheme are actually invalid in the strongly typed Grin of jhc so need to be combined or modified. A whole lot can be learned from the Grin data type and Grin is fully defined by the following infixr 1 :->, :>>= data Lam = Val :-> Exp deriving(Eq,Ord,Show) data Exp = Exp :>>= !Lam | App Atom [Val] -- ^ this handles applications of functions and built-ins | Prim Primitive [Val] | Case Val [Lam] | Return { expValue :: Val } | Store { expValue :: Val } | Fetch { expAddress :: Val } | Update { expAddress :: Val, expValue :: Val } | Error String Ty -- ^ abort with an error message, non recoverably. | Cast Val Ty -- ^ reinterpret Val as a different type, also used to box\/unbox lifted types deriving(Eq,Show,Ord) data Val = NodeC !Tag [Val] | NodeV !Var [Val] | Tag !Tag | Const Val -- ^ pointer to constant data, only Lit, Tag, and NodeC may be children | Lit !Number Ty | Var !Var Ty | Tup [Val] | ValPrim APrim deriving(Eq,Show,Ord) data Ty = TyTag -- ^ a lone tag | TyPtr Ty -- ^ pointer to a heap location which contains its argument | TyNode -- ^ a whole tagged node | Ty Atom -- ^ a basic type | TyTup [Ty] -- ^ unboxed list of values | TyUnknown -- ^ an unknown possibly undefined type, All of these must be eliminated by code generation deriving(Eq,Ord) === Extensions === Jhc implements several extensions to Haskell 98 ==== Standard Extensions ==== * The FFI is almost fully supported except for calling Haskell code from C. * Hierarchical module names are supported as described in the addendum. The search algorithm is somewhat different than GHC though, Control.Monad.Identity will be searched for as Control/Monad/Identity.hs, Control/Monad.Identity.hs and Control.Monad.Identity.hs, giving you a bit more freedom in laying out your directory structure. * Empty data declarations with no constructors are supported * Liberalized type synonyms are supported (type synonyms may appear anywhere a type may appear) * INLINE, SPECIALIZE pragmas * unsafePerformIO, unsafeInterleaveIO are provided. ==== New Extensions ==== * Magic underscore. Using underscore in an expression expands to bottom with an error message giving the current file and line number. This is useful because it is common practice nowadays to use undefined as a witness for a type. Relatively easy errors to make using this scheme lead to an unhelpful "error: Prelude.undefined" with no indication of where the error actually is. By using the alternate <code>(_ :: Int)</code> rather than <code>(undefined :: Int)</code> you will get an informative run-time error message as well as save some space. The magic underscore is also useful as a placeholder for code you mean to fill in later. * foreign primitive, all primitives are brought into scope with a foreign primitive declaration (barring a few numeric operators) , these can also be used to gain access to C constants, obviating much of the need for a preprocessor such as hsc2hs and allowing portable C code to be generated by jhc. * ERROR_ANNOTATE pragma. This is a generalization of GHCs assert magic. A function which is given an ERROR_ANNOTATE pragma will be replaced with an alternate version that takes the functions use site as an argument. This allows error messages to be in terms of where said function was used. The alternate function is named <code>[function]_err_ann__</code> and must be in the same module as the original function. Jhc does no checking to ensure both functions have the same effect, it is up to the user to ensure that. An example is <pre> head :: [a] -> a head (x:xs) = x head [] = error "head - empty list" {-# ERROR_ANNOTATE head #-} head_err_ann__ :: String -> [a] -> a head_err_ann__ pos (x:xs) = x head_err_ann__ pos [] = error $ pos ++ ": head - empty list" -- Now, a call to head on an empty list will produce an error message like -- "Main.hs:23: head - empty list" </pre> * SUPERSPECIALIZE pragma. This pragma has the same affect as the SPECIALIZE pragma, but in addition to doing compile-time specialization, SUPERSPECIALIZE performs run-time specialization. A superspecialized function will perform a single check against the type it is called with and depending on the single test, call a specialized version of the function. This can be a huge win when working with overloaded numeric types, imagine a matrix-multiply routine, if the type cannot be determined at compile-time then we would normally be forced to fall back to generic version which may have hundreds of additions and multiplications, each of which must test what type its argument are. If we SUPERSPECIALIZE the multiply routine instead, a single run-time test will be performed and the much much more efficient specialized routine will be used, even if it could not be proven at compile time. * MULTISPECIALIZE pragma. This is equivalent to calling SPECIALIZE against every possible type. It's main cost is compile time and memory usage. It should be used only sparingly as it can lead to quadratic rule explosion in the total number of types in the transitive closure of all imported modules in the worst case. * MULTISUPERSPECIALIZE pragma. This is equivalent to calling SUPERSPECIALIZE against every possible type. If not careful, this can result in massive code bloat but might be a big win in certain cases. == The story of jhc == When I first started to learn Haskell in 1999, I decided I needed a project. Haskell was my first (modern) functional language and I was seduced by its robust strong type system and efficiency gains. After writing a toy ray-tracer (my usual first project in a new language) it was clear I needed to try something somewhat more challenging and jhc was born. My reasoning was simple, by writing a Haskell compiler in Haskell I will double my language learning speed since I will not only have to learn how to program in it by forcing myself to complete a non-trivial project, but also its subtle semantics and dark corners since I actually needed to implement it correctly. Writing a compiler is also doubly efficient to begin with, since if you self-compile improvements not only give you a better optimizer, but also speed up your self-compiled compiler. All in all I figure I was making very good use of my time. For some reason, when I explain my reasoning to other people they look at me like I am crazy, but I can detect no flaw in my logic. In any case, I worked on jhc on and off for a while, the project got boosts a few times, such as when hatchet was released and I used it to replace my front end. Recently, with my purchase of a faster machine actually beefy enough to run jhc and the realization I was getting good optimizations from my implementation of type classes combined with the small binary size of produced files I decided to make a push for jhc to become a usable compiler. == All is not well in jhc-land == There are still substantial issues which need to be overcome before jhc can be used for general Haskell programing * It doesn't scale. Basically since jhc compiles the entire standard library along with your code, even moderately complex programs can be beyond its grasp * It takes ridiculous amounts of memory and CPU. A gigabyte of RAM usage is not unheard of. * There are still some major bugs * It leaks memory. The Region inference algorithm is still in the tweaking stage and programs are known to leak memory. for short running programs, this does not seem to be an issue, but anything expected to perform a lot of reductions will probably run out of heap. * it is not done * Arrays are very slow at the moment. * only about 70% of nofib compiles at the moment. * That said, I am releasing it because people might find the ideas interesting or be able to learn from or borrow of the code. * Horrible error messages. A few programmer errors (and some non-errors) cause the compiler to quit with an 'error' or pattern match failure. == References == * Boquist Thesis * Henk paper * Pure Type Systems type checking paper * CPR analysis. * Strictness analysis w/ HORN clauses * Typing Haskell in Haskell * Hatchet -- John Meacham - ⑆repetae.net⑆john⑈

5 5

HaskellForge
by Gour 01 Jun '05

01 Jun '05

Dear Haskellers, I'd like to suggest one idea which is going on in my mind for quite some time... Recently the project where I am offering some help (gtk2hs) had to move part of its web site from SourceForge to haskell.org since SF site has some limits which we were not able to overcome. So, why not form HaskellForge and thereby form powerful Haskell alliance, ie. common site which can host many/most present Haskell projects offering appropriate web & other (eg. darcs) services? If we take a look on new HCAR, we can see that many Haskell projects are scattered all around, so it would be nice to have them on one place. Ruby (which is not so long around, at least in the Western part) has RubyForge site which at the moment hosts 653 projects with 2159 registered users. Then there is also, Ruby Application Archive (RAA) with 1190 projects. Haskell community is a very friendly one and has lot of brain-power on disposal. Why not add some (more) organizational skills to make it even more friendlier place? Any comment? Sincerely, Gour -- Registered Linux User | #278493 GPG Public Key | 8C44EDCD

12 20

Should inet_ntoa Be Pure?
by Dominic Steinitz 01 Jun '05

01 Jun '05

> Axel Simon 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 > > That doesn't mean that it should be in the IO monad; using Maybe > would suffice. Agreed. Perhaps I wasn't clear enough in my original question. There appears to be no intrinsic reason why they should be in the IO monad. > > > > Hence ntoa needs to be an IO action so that the value is read > > immediately before the next ntoa call is executed. > > That shouldn't be an issue so long as the buffer contents are > converted to a Haskell String before the function is called again > within the same thread. > > However, I wouldn't rely upon all implementations of inet_ntoa() being > thread-safe. > > What you could do is to apply unsafePerformIO to > > [snip] > > Or you could just re-implement the functions in Haskell. > > Apart from the re-entrancy issues with inet_ntoa(), many > implementations of inet_addr() have misfeatures, e.g. allowing octets > to be expressed in octal or hex, or allowing numbers outside of the > 0-255 range (in which case, the top bits overflow into the next > octet). Perhaps better would be: inet_addr' :: (Octet,Octet,Octet,Octet) -> HostAddress inet_ntoa' :: HostAddress -> (Octet,Octet,Octet,Octet) I see Peter Simons has already written something: http://cryp.to/hsdns/docs/Network.IP.Address.html#v%3Aha2tpl Dominic.

8 16

Discrete event simulation
by Bruno Martínez Aguerre 01 Jun '05

01 Jun '05

Hi. I'm wondering if there is work done about discrete event simulation in functional languages, and more specifically, Haskell DSLs. Any pointers? Regards, Bruno Martínez Conectese mas rapido y ahorre hasta un 50% Tel. 0909.2030 => $0,15 IVA incluido el minuto ______________________________________________________ http://www.internet.com.uy - En Uruguay somos internet Conectese mas rapido y ahorre hasta un 50% Tel. 0909.2030 => $0,15 IVA incluido el minuto ______________________________________________________ http://www.internet.com.uy - En Uruguay somos internet

4 4