- Haskell - Haskell.org

Ranged Sets version 0.0.3
by Paul Johnson 22 Nov '06

22 Nov '06

The Ranged Sets library version 0.0.3 is now available, after a long hiatus. The CVS version on Sourceforge is now no longer used. Instead you can find a Darcs repository at http://ranged-sets.sourceforge.net/Ranged/ From the Changes.txt file: Version 0.0.3 ------------- Removed support for infinite sets. They sometimes still work, but generally are more trouble than they are worth. There is no simple set of rules for client applications to guarantee termination. Replaced the "deriving" clause for the Range type with instance declarations. Empty ranges created with different bounds will now test as equal. All empty ranges now compare as less than all non-empty ranges. "show" returns a string such as "3.5 < x <= 4.6", or "x < 23". Removed "maybeRange". Changed "rangeIntersection" to return a "Range" instead of a "Maybe Range". If the intersection is empty then it returns an empty range instead of Nothing. Renamed "rangeEmpty" to "rangeIsEmpty" for consistency with "rSetIsEmpty" Added "emptyRange" and "fullRange"

1 0

Weird field name mangling.
by Arthur van Leeuwen 22 Nov '06

22 Nov '06

L.S., consider the following code: > module TestZ where > > import Data.Generics > > data TestZ = TestZ { testz :: Int } > deriving (Show, Read, Eq, Typeable, Data) > > main = print $ constrFields . toConstr $ TestZ { testz = 2 } I would expect this to output ["testz"]. Instead it outputs ["testzz"], using GHCi 6.4.1. Why is that z doubled? Doei, Arthur. -- /\ / | arthurvl(a)cs.uu.nl | Work like you don't need the money /__\ / | A friend is someone with whom | Love like you have never been hurt / \/__ | you can dare to be yourself | Dance like there's nobody watching

1 0

Haskell Weekly News: November 22, 2006
by dons＠cse.unsw.edu.au 22 Nov '06

22 Nov '06

--------------------------------------------------------------------------- Haskell Weekly News http://haskell.org/haskellwiki/HWN Issue 50 - November 22, 2006 --------------------------------------------------------------------------- Welcome to issue 50 of HWN, a weekly newsletter covering developments in the Haskell community. This week a new release of the Haskell XML Toolbox, and details for the inaugural Haskell Hackathon are announced. And the HWN half century of issues is on the board! Announcements * Haskell XML Toolbox 7.0. Uwe Schmidt [1]released a new version of the [2]Haskell XML Toolbox. New in 7.0 is a module for XSLT transformation. The XSLT module implements most of the XSLT standard. The development of the XSLT module is done by Tim Walkenhost in his master thesis, describing the design of the transformer (and the limitations) is included in the distribution. HXT 7.0 works with ghc-6.4 and ghc-6.6. [3]A tutorial is available in the Haskell wiki. 1. http://article.gmane.org/gmane.comp.lang.haskell.general/14487 2. http://www.fh-wedel.de/~si/HXmlToolbox/index.html 3. http://www.haskell.org/haskellwiki/HXT * Hac: Haskell Hackathon 2007. The Hac organisers [4]announced that the inaugural Haskell Hackathon, [5]Hac 2007, will be held at Oxford University Computing Laboratory, January 10-12, 2007. The plan is to hack on Haskell infrastructure, tools, libraries and compilers. To attend please register, and get ready to hack those lambdas! 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14489 5. http://haskell.org/haskellwiki/Hac_2007 * System.FilePath 0.11. Neil Mitchell [6]announced the release of [7]System.FilePath 0.11, a library for manipulating FilePath's correctly on both Posix and Windows. 6. http://article.gmane.org/gmane.comp.lang.haskell.general/14485 7. http://www-users.cs.york.ac.uk/~ndm/projects/libraries.php#filepath * Darcs release candidate. Tommy Pettersson [8]announced it's time for a new darcs release candidate, 1.0.9rc2. There will probably be yet another release candidate (rc3) before final 1.0.9. Get testing! 8. http://article.gmane.org/gmane.comp.version-control.darcs.devel/5010 * Safe library 0.1. Neil Mitchell [9]announced the release of [10]Safe library, 0.1. People often have a problem with pattern match errors, and the only helpful message they get is: 'pattern match error'. The Safe library hopes to eliminate some of the frustration this causes by providing versions of these partial functions with more helpful error messages. 9. http://article.gmane.org/gmane.comp.lang.haskell.general/14475 10. http://www-users.cs.york.ac.uk/~ndm/projects/libraries.php#safe * LocH, located errors 0.1. Don Stewart [11]announced the release of LocH, a small Haskell module providing source location-specific error messages and debugging strings for Haskell code. It uses the compiler-expanded 'assert' token, rather than cpp or m4, to provide a lightweight approach to generating source locations. No preprocessor is required. More information is available at [12]the LocH site, including [13]API documentation. 11. http://article.gmane.org/gmane.comp.lang.haskell.general/14475 12. http://www.cse.unsw.edu.au/~dons/loch.html 13. http://www.cse.unsw.edu.au/~dons/loch/Debug-Trace-Location.html * Starting your own Haskell project. Jason Dagit and Don Stewart [14]expanded on the document describing how best to [15]set up a new Haskell project, leading to the creation of [16]mkcabal,a new tool for setting up cabalised Haskell projects. 14. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/16689/focus=16689 15. http://haskell.org/haskellwiki/How_to_write_a_Haskell_program 16. http://article.gmane.org/gmane.comp.lang.haskell.cabal.devel/269 Haskell' This section covers the [17]Haskell' standardisation process. * [18]Defaults * [19]Pattern guards and where clauses 17. http://hackage.haskell.org/trac/haskell-prime 18. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1907/focus=1907 19. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1904/focus=1904 Libraries This week's proposals and extensions to the [20]standard libraries. * [21]Add parsing (and some other changes) to the time package 20. http://haskell.org/haskellwiki/Library_submissions 21. http://article.gmane.org/gmane.comp.lang.haskell.libraries/5706 Discussion * New Arrows tutorial. Tim Newsham [22]wrote a small arrows tutorial, and is looking for feedback. 22. http://www.thenewsh.com/~newsham/x/arrow.txt * Yhc.Core backends for Haskell/Javascript/C. Neil Mitchell [23]asked about the direction the Yhc Core backends should take. 23. http://article.gmane.org/gmane.comp.lang.haskell.yhc/460 * The Burrows Wheeler Transformation. Jon Fairbairn [24]proposed a game to find the most elegant implementation of the Burrows Wheeler transformation and its inverse. 24. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/16650/focus=16650 * More fusion. Claus Reinke [25]described a method for avoiding the O(n) overhead of cons in strict ByteStrings. Some alternative strategies were also suggested. 25. http://thread.gmane.org/gmane.comp.lang.haskell.glasgow.user/11267/focus=11… * Extending TypeEq: topEq for types. Nicolas Frisby [26]described a solution to an interesting type problem using TypeEq, Oleg followed up with an alternate solution 26. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/16638/focus=16638 * Debugging by the rules. Don Stewart [27]described an idea to use rewrite rules to change mysterious failing functions to more useful variants. More details on using rewrite rules for various ticks have been [28]collected on the wiki. 27. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/16577/focus=16577 28. http://www.haskell.org/haskellwiki/Playing_by_the_rules * Generalising zip. Jason Dagit [29]wondered about a generalisation of zip to encode functions like isPrefixOf 29. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/16626/focus=16626 * Heterogeneous collections. Valentin Gjorgjioski [30]asked about techniques for heterogeneous data in Haskell. Several solutions were suggested, and a [31]new wiki page collects the details. 30. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/16653/focus=16653 31. http://haskell.org/haskellwiki/Heterogenous_collections Blog noise [32]Haskell news from the blogosphere. * [33]The Maybe type in Java * [34]Erlang User Conference * [35]The Missing LINQ * [36]APLAS 06 * [37]The New Lambda Expressions Feature in C# 3.0 * [38]Edit Graphs * [39]A search engine (core) written in Haskell * [40]Vim indentation mode for Haskell * [41]Haskell Transactional Cache * [42]Haskell support added to Google Code Search * [43]The type system of ECMA Eiffel (modelled in Haskell) * [44]Diff in Haskell * [45]Computers were invented to keep track of boring things * [46]Lazy lists as iterators * [47]Library use in the Common Lisp community * [48]Local and global side effects with monad transformers * [49]Eratosthenes sieve * [50]Lazy streams for Lua * [51]Language design * [52]Overlap function in Haskell for rectangles 32. http://planet.haskell.org/ 33. http://blog.tmorris.net/maybe-in-java 34. http://www.process-one.net/index.php/en/comments/erlang_user_conference_200… 35. http://eamon.nerbonne.org/2006/11/gwc-missing-linq.html 36. http://blog.tmorris.net/aplas-06/ 37. http://www.developer.com/net/csharp/article.php/3598381 38. http://alangloria.blogspot.com/2006/11/edit-graphs-im-currently-hacking.html 39. http://haskell-web.blogspot.com/2006/11/search-engine-written-in-haskell.ht… 40. http://koweycode.blogspot.com/2006/11/haskell-vim-indentation.html 41. http://haskell-web.blogspot.com/2006/11/transactional-cache-for-haskell.html 42. http://groups.google.com/group/Google-Code-Search/browse_thread/thread/a1f8… 43. http://teameiffel.blogspot.com/2006/11/type-system-of-ecma-eiffel.html 44. http://alangloria.blogspot.com/2006/11/okay.html 45. http://dynamic.ropine.com/yesh/article/computers-were-invented-to-keep-trac… 46. http://community.livejournal.com/evan_tech/206250.html 47. http://sigkill.dk/blog/archives/240-Library-use-in-the-Common-Lisp-communit… 48. http://sigfpe.blogspot.com/2006/09/local-and-global-side-effects-with.html 49. http://kenta.blogspot.com/2006/11/eratosthenes-sieve.html 50. http://salimma.livejournal.com/72850.html 51. http://jlouisramblings.blogspot.com/2006/11/on-language-design.html 52. http://sancho-ex.livejournal.com/7056.html Quotes of the Week * Larry Wall: People who succeed in brushing up on Haskell do so by brushing up lazily. * xerox: [dons] then again, bots themselves are simple. [xerox] '...they are just a morphism in the category of IRC channels together with an endomapping ...' * Dave Love: Presumably people with the taste to program in Haskell will use Emacs anyway. * Baughn: I know I always have trouble explaining what the weather is like without involving foldr somehow. * Korollary: Darcs is free of chemical toxins of big pharma. It's made using all natural herbs and other woo. It's good for you. Cheers. * Pseudonym: A 'newbie', in Haskell, is someone who hasn't yet implemented a compiler. They've only written a monad tutorial. * astrolabe: I guess missile launching would have to be in IO * dons: Java's type system is unsuitable for young children, the elderly or infirm of constitution * earthy: The Haskell standard Prelude is ... a treasure trove. But it does require breaking your mind and reassembling the pieces to unlock the trove. * emu: Hijack the stack and take this compiler to Fun-land! * norpan: The comonad of the No monad is the Yes monad? * robreim: I'm in your base hacking all your lambdas * shapr: I was chatting with someone who writes Haskell and at some point they said they're not an academic, and I said that too. And then there was what I perceived to be a small disbelieving silence... * simonpj: Maybe if I had an Oleg implant I could express all this in the type system * skew: [On the subject of strictness] There is a sequet incantation. * ski: Please talk to your son or daughter about parametric polymorphism * wadler: The way we can tell it's C# instead of Haskell is because it's nine lines instead of two. Code Watch * Wed Nov 8 09:14:52 PST 2006. Alexey Rodriguez. [53]Addition of PAPI to the RTS. [54]PAPI is a library that supports use of the performance counters built into most CPUs for measuring things like cache misses and branch mispredictions. Alexey Rodriguez has added support for PAPI to the RTS, so we can take measurements of any of the CPU performance counters during the run of a Haskell program, and we even separate out results for the GC from results for the mutator. 53. http://article.gmane.org/gmane.comp.lang.haskell.cvs.ghc/17864 54. http://icl.cs.utk.edu/papi/ About the Haskell Weekly News Each week, new editions are posted to [55]the Haskell mailing list as well as to [56]the Haskell Sequence and [57]Planet Haskell. [58]RSS is also available, and headlines appear on [59]haskell.org. Headlines are available as PDF. The Haskell Weekly News is also [60]available in Spanish translation. To help create new editions of this newsletter, please see the [61]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn 55. http://www.haskell.org/mailman/listinfo/haskell 56. http://sequence.complete.org/ 57. http://planet.haskell.org/ 58. http://sequence.complete.org/node/feed 59. http://haskell.org/ 60. http://haskell.org/haskellwiki/HWN/es 61. http://haskell.org/haskellwiki/HWN

1 0

ANNOUNCE: Haskell Hackathon, Hac 07
by dons＠cse.unsw.edu.au 21 Nov '06

21 Nov '06

------------------------------------------------------------------------ Hac 2007 The 2007 Haskell Hackathon January 10-12, 2007 Oxford University Computing Laboratory http://haskell.org/haskellwiki/Hac_2007 ------------------------------------------------------------------------ Following the success of the GHC Hackathon at ICFP, we are pleased to announce the inaugural Haskell Hackathon, Hac 2007! The event will be held over 3 days, January 10-12 2007, at the Oxford University Computing Laboratory, in the UK. The plan is to hack on Haskell infrastructure, tools, libraries and compilers. To attend please register, and get ready to hack those lambdas! Code to hack on: * Hackage * Cabal * Porting foreign libraries * Porting compilers * Bug squashing * Performance improvements to compilers * You decide! Registration: We ask that you register you interest. Follow the instructions on the registration page: http://haskell.org/haskellwiki/Hac_2007/Registration Numbers for the hackathon are limited to 20, due to room size constraints. Should space be available after the registration period ends, additional attendees may register on a first-come first-served basis. Important dates: Registration deadline: December 6th, 2006 Confirmation: December 10th, 2006 Hackathon: January 10-12, 2007 Organisers: Duncan Coutts Ian Lynagh Don Stewart

1 0

ANNOUNCE: Haskell XML Toolbox Version 7.0
by Uwe Schmidt 21 Nov '06

21 Nov '06

Haskell XML Toolbox 7.0 I would like to announce a new version of the Haskell XML Toolbox. New in 7.0 is a module for XSLT transformation. The XSLT module implements most of the XSLT standard. Only a few features are missing. The development of the XSLT module is done by Tim Walkenhost in his master thesis. The master thesis, describing the design of the transformer (and the limitations) is included in the distribution. HXT 7.0 works with ghc-6.4 and ghc-6.6 A tutorial is availiable in the Haskell wiki: http://www.haskell.org/haskellwiki/HXT More information and download: http://www.fh-wedel.de/~si/HXmlToolbox/index.html Please email comments, bugs, etc. to hxmltoolbox(a)fh-wedel.de Uwe -- University of Applied Sciences, Wedel, Germany http://www.fh-wedel.de/~si/index.html

2 1

ANN: System.FilePath 0.11
by Neil Mitchell 20 Nov '06

20 Nov '06

Hi ANNOUNCEMENT: I am hereby announcing System.FilePath 0.11, which hopefully is pretty close to final now. This library manipulates FilePath's correctly on both Posix and Windows. http://www-users.cs.york.ac.uk/~ndm/projects/libraries.php#filepath (Includes a darcs repo, a .tar.gz, haddock documentation etc) CHANGES: I made some changes in response to comments by Simon Marlow: Removed addFileName, renamed the path splitting to searchPath, renamed shortPath to makeRelative. I did not follow two of his suggestions: removing isDirectory/asDirectory, removing splitPath. (I note these so it is easy to see which suggestions/point are outstanding easily) I also fixed some of the documentation (thanks to Evan) and added a few more properties. All in all, not much changed. COMPATABILITY: If you import System.FilePath.Version_0_10 then nothing will have changed. If you import System.FilePath.Version_0_11 then you'll get the new version. The original Version_0_09 will also continue to work unmodified. Hopefully no one will have any compatability issues. DISCUSSION: We seem to be getting towards the stage where most people who want a FilePath library in a similar spirit to this are reasonably happy with this one. Unless anyone comes up with anything too big, I'm going to propose this for the base library in a few days. Can everyone with an opinion on that issue please hold off for a few days. Thanks Neil

1 0

UTP'07 at IFM: Unifying Theories of Programming
by Jeremy.Gibbons＠comlab.ox.ac.uk 20 Nov '06

20 Nov '06

First call for papers UTP'07 at IFM: Unifying Theories of Programming Organised as a special session of IFM 2007, the Sixth International Conference on Integrated Formal Methods IFM 2007 will be held at St Anne's College, Oxford, UK, from the 2nd to the 6th of July, 2007 http://www.ifm2007.org This special session follows the successful First International Symposium on Unifying Theories of Programming, UTP'06, and aims to reaffirm the significance of the ongoing UTP project, to encourage efforts to advance it by providing a focus for the sharing of results by those already actively contributing, and to raise awareness of the benefits of unifying theoretical frameworks among the wider computer science and software engineering communities. Technical contributions are invited on the UTP themes of abstraction, refinement, choice, termination, feasibility, concurrency and communication, as well as related issues. These themes include, but are not limited to, linkage of theories, algebraic descriptions, healthiness conditions, normal forms, incorporation of probabilistic programming, timed calculi, and object-based descriptions. The deadline for paper submission is 29th January 2007. The submission mechanism - via the website - will allow authors to indicate that the paper should be considered for the UTP special session. Session co-chairs: Phil Brooke University of Teesside, UK Yifeng Chen University of Durham, UK

1 0

Re: Type-class overloaded functions: second-order typeclass programming with backtracking
by oleg＠pobox.com 19 Nov '06

19 Nov '06

Sorry, forgor the precise URLs http://pobox.com/~oleg/ftp/Haskell/poly2.hs http://pobox.com/~oleg/ftp/Haskell/poly2.txt

1 0

Type-class overloaded functions: second-order typeclass programming with backtracking
by oleg＠pobox.com 19 Nov '06

19 Nov '06

We demonstrate functions polymorphic over classes of types. Each instance of such (2-polymorphic) function uses ordinary 1-polymorphic methods, to generically process values of many types, members of that 2-instance type class. The typeclass constraints are thus manipulated as first-class entities. We also show how to write typeclass instances with back-tracking: if one instance does not apply, the typechecker will chose the `next' instance -- in the precise meaning of `next'. The code only uses stable Haskell extensions (undecidable and overlapping instances) and is tested with GHC 6.4.1. Our running example is a function whose type (modulo the constraint) is approx_eq :: a -> b -> Bool It applies to values of any two types. If both arguments are of the same type and are Fractionals, the function checks if the values are the same within given tolerance, 0.5. We test the values of other numeric types for equality give or take 1. For a class of other types supporting equality, we test the values with the Eq's (==) operation. For all other types, including the cases when the two arguments are of different types, approx_eq returns False. The complete code for this article is available at http://pobox.com/~oleg/ftp/ The first inspiration for this message comes from generic programming. In approaches like SYB1 or Smash, the functions that process (sub)terms of specific types must be monomorphic. In SYB1, for example, that requirement comes from the fact that TypeRep only supports monomorphic types (see also note in Data.Dynamic documentation). One would like, for example, to traverse a term and apply a polymorphic numeric function to all subterms that are members of the class Num -- without the need to monomorphise the function. The second inspiration comes from Haskell-Cafe requests for a function that does something for any Fractional and does something else for a Num and something else entirely for a value whose type in in the class Ord. The common solution to those problems is to monomorphise -- enumerate all needed types. That leads to a notable amount of boilerplate. We'd like to process all Num values, for example, with one polymorphic function -- without manually instantiating this function for each Num type. Another drawback of the common solution is the need to enumerate Num and Fractional classes again should we need another function that does something for Fractionals and something else for Nums. We show how to eliminate that redundancy. We offer a way to describe classes of types in a _concise_ way, using unions and class differences. These classes of types may be either closed or open (extensible). After that set up, we can write arbitrarily many functions overloaded over these type classes. An instance of our function for a specific type class may use polymophic functions to generically process all members of that type class. Our functions are hence second-order polymorphic. Again, the class membership has to be described -- but only once and for all. Furthermore, we offer quite an expressive notation and the opportunity of augmenting a class at a later time. For our running example, we define the following type classes: > type Fractionals = Float :*: Double :*: HNil > type Nums = Int :*: Integer :*: AllOf Fractionals :*: HNil > type Ords = Bool :*: Char :*: AllOf Nums :*: HNil > type Eqs = AllOf (TypeCl OpenEqs) :*: AllOfBut Ords Fractionals :*: HNil > data OpenEqs > instance TypeCls OpenEqs () HTrue -- others can be added in the future In particular, Eqs specifies the class of all of Ords except Fractionals, plus the open OpenEqs. The latter currently includes (), with more types can be added at any point. We excluded Fractionals from Eqs just because we can -- and to hint that exact equality on Fractionals is unreliable. Incidentally, while the following naive definition does not type type Russel = AllOfBut () Russel :*: HNil because type synonyms can't be recursive, a more elaborated variant does work, with the expected result. Thus when we say type _class_ (rather than type _set_), we really mean it. Our implementation is a rather trivial extension of the Apply class of HList. class Apply f a r | f a -> r where apply :: f -> a -> r; apply = undefined Our 2-polymorphic functions (and their 1-polymorphic specializations) are all instances of the Apply class. They are all identified by labels (singlular datatypes) for the reasons to be explained shortly. Regular typeclasses match on types; to match on a type class, we need a guard: a type function that decides the membership. We also need the ability to `backtrack' and select another instances should the guard fail. Let us start with an example: a simple 2-polymorphic function "a -> Bool" that returns True if its argument is a member of the type class Eqs as defined above. It returns False for any other type. We start by defining the label for our function: > data IsAnEq = IsAnEq Next we define a pair of matching instances. The first isntance, of a typeclass > class GFN n f a pred | n f a -> pred specifies the guard for the instantiation number `n' of the 2-polymorphic function named `f' when applied to an argument of the type 'a'. The guard itself is a label, which, when Apply'ed to 'a' yields either HTrue or HFalse. Again, we shall see soon why we need so many labels. > instance GFN Z IsAnEq a (Member Eqs) > instance Apply (GFnA Z IsAnEq) a Bool where > apply _ _ = True We are saying here that the instantiation number Z of the function named IsAnEq has the guard (Member Eqs) -- which tests the class membership of the type 'a' in Eqs. Should this guard succeed, we `apply' (GFnA Z IsAnEq) to the argument to get the desired result -- in this case, True. The second instance is the catch-all, it applies when the guard (Member Eqs) fails: > -- the default instance > instance TypeCast pred Otherwise => GFN n IsAnEq a pred > instance Apply (GFnA n IsAnEq) a Bool where > apply _ _ = False where the Otherwise membership predicate always succeeds. We now write > test1 = [apply (GFn IsAnEq) (), apply (GFn IsAnEq) (1.0::Double), > apply (GFn IsAnEq) 'a'] which evaluetes to [True,False,True]. Recall that we explictly excluded Fractionals from Eqs. Suppose that we wish to extend the above function to pairs, that is, given a pair (x,y) it should return True if both 'x' and 'y' are in Eqs. The simplest way is to extend the type class Eqs accordingly, given that we specifically made it open. We choose a different approach however, to illustrate that the function IsAnEq is itself extensible, and can be recursively applied. We add the following pair of instances: > instance GFN (S Z) IsAnEq (x,y) Otherwise > instance (Apply (GFn IsAnEq) x Bool, > Apply (GFn IsAnEq) y Bool) > => Apply (GFnA (S Z) IsAnEq) (x,y) Bool where > apply (GFnA f) (x,y) = apply (GFn f) x && apply (GFn f) y We wedge this instance `between' the existing two. > test2 = [apply (GFn IsAnEq) (True,'a'), > apply (GFn IsAnEq) (1.0::Double,True)] > -- [True, False] Let us move to the main example: the approximate equality: test the Fractionals with the tolerance 0.5, test other Nums with the tolerance 1, and test Eqs with the exact equality. For the values of all other types (including the case when the values to compare have different types), the result is False. The order of guard tests obviously matters as all of Fractionals are also Nums. If we want to discriminate Fractionals, we should test for them first. > data ApproxEq = ApproxEq -- define the label > data PairOf t -- lift membership to pairs > instance Apply t x r => Apply (PairOf t) (x,x) r > instance TypeCast r HFalse => Apply (PairOf t) x r > > instance GFN Z ApproxEq (x,x) (PairOf (Member Fractionals)) > instance (Fractional x, Ord x) => > Apply (GFnA Z ApproxEq) (x,x) Bool where > apply _ (x,y) = abs (x - y) < 0.5 > > instance GFN (S Z) ApproxEq (x,x) (PairOf (Member Nums)) > instance (Num x, Ord x) => > Apply (GFnA (S Z) ApproxEq) (x,x) Bool where > apply _ (x,y) = abs (x - y) < 2 > > instance GFN (S (S Z)) ApproxEq (x,x) (PairOf (Member Eqs)) > instance (Eq x) => > Apply (GFnA (S (S Z)) ApproxEq) (x,x) Bool where > apply _ (x,y) = x == y -- recursion over pairs skipped... > -- The default instance > instance TypeCast pred Otherwise => GFN n ApproxEq a pred > instance Apply (GFnA n ApproxEq) a Bool where > apply _ _ = False > > -- A convenient abbreviation > approx_eq x y = apply (GFn ApproxEq) (x,y) *Poly2> :t approx_eq approx_eq :: (Apply (GFn ApproxEq) (a, b) r) => a -> b -> r > test3 = [approx_eq (1.0::Double) (1.5::Double), > approx_eq (1.0::Float) (1.1::Float), > approx_eq (1::Integer) (2::Integer), > approx_eq (1::Int) True, > approx_eq (Just ()) [], > approx_eq ((2::Integer),(2::Integer)) ((1::Integer),(2::Integer)), > approx_eq ((1::Integer),(2::Integer)) ((1::Integer),(2::Integer)) ] > -- [False,True,True,False,False,True,True] Now why we need so many labels and why we have to separate the guard and the real computation across two different typeclasses? First of all, why can't we write something like the following (as in `Smash your bolierplate') and so use real functions rather than labels? approx_eq2 x y = sapply (scons (undefined::PairOf (Member Fractionals)) eqfrac (scons (undefined::PairOf (Member Nums)) eqnum (scons (undefined::PairOf (Member Eqs)) (uncurry (==)) snil))) (x,y) False where eqfrac (x,y) = abs (x - y) < 0.5 eqnum (x,y) = abs (x-y) < 2 If we do that and write > testeq2 = approx_eq2 (1.0::Double) (1.5::Double) we get a type error, `Ambiguous Eq b constraint'. Indeed, the use of (==) in the code above gives rise to an Eq b constraint. That 'b' is not directly related to the type of the arguments to approx_eq2 -- the function (==) will be applied only if the guard `PairOf (Member Eqs)' succeeds. Thus we have no direct way to instantiate the type 'b' in general, and so the constraint 'Eq b' is left hanging, eventually leading to a type error. Second, why can't we define the guard and the corresponding computation within the same instance? For example, we could have declared a typeclass > class GFN n f a pred b | n f a -> pred, n f a -> b where > gfn :: n -> f -> a -> b Instances of GFN define a 2-polymorphic function as a set of clauses. The clauses are `numbered' via the 'n' parameter, which is of a kind numeral (Z, S Z, etc). Pred is the guard, and the numering establishes the order, so we can find the `next' instance if the guard, applied to the argument 'a', fails (that is, `Apply guard a HFalse' is derivable). Alas, to find the guard `pred', we have to select the corresponding instance. We replace a failure with the sequence of successes, selecting one instance after another, until we find the one with the succeeding guard. Those instances may come with the constraints; as we select one instance after another, the constrains accumulate (forming the conjunction). But these constraints may be contradictory. The two failing approaches show the complication we have to struggle with. A 2-polymorphic function is defined by cases where each case is, in general, a 1-polymorphic function. Each 1-polymorphic function comes with a set of constraints. We must make sure that our 2-polymorphic function makes a _disjoint_ union of those constraints rather than an intersection. Thus, unless we have committed to a particular 1-polymorphic case (the guard succeeded), we must not evaluate the corresponding constraints. Our solution has this property. We notice in the ApproxEq cases above that none of the GFN instances have any instance constraints. The corresponding Apply instances do have constraints -- which, fortunately, only take effect when the guard succeeded and the instance is selected. The name of the game is to delay the imposition of constraint. We take advantage of the fact that a label such as ApproxEq _stands_ for a set of constraints but does not have any actual constraints. We play on the difference between the notation and denotation. The need to spread the guard and the corresponding computation across two instances is less satisfying. Fortunately, the type system watches for the consistency between the two, that is, the guard admitting no more types that can be used in the real computation. It seems appropriate to end this message with xxx lines of implementation. The complete code with more examples is available at the URL given above. newtype GFn f = GFn f newtype GFnA n f = GFnA f newtype GFnTest n f flag = GFnTest f instance (GFN Z f a pred, Apply pred a flag, Apply (GFnTest Z f flag) a b) => Apply (GFn f) a b where apply (GFn f) a = apply ((GFnTest f)::GFnTest Z f flag) a instance Apply (GFnA n f) a b -- guard succeeded => Apply (GFnTest n f HTrue) a b where apply (GFnTest f) a = apply ((GFnA f) :: GFnA n f) a instance (GFN (S n) f a pred, Apply pred a flag, -- else chose the next inst Apply (GFnTest (S n) f flag) a b) => Apply (GFnTest n f HFalse) a b where apply (GFnTest f) a = apply ((GFnTest f)::GFnTest (S n) f flag) a

1 0

I18N, external strings
by Johannes Waldmann 17 Nov '06

17 Nov '06

What methods and tools are there for i18n of Haskell programs? (I.e. I want output in several languages, with the language configurable at runtime, and I want to add languages without recompilation.) a typical source text (for my application) is here http://141.57.11.163/cgi-bin/cvsweb/tool/src/Graph/Circle/Plain.hs?rev=1.2 it contains (German) text strings all over the place. In Java/Eclipse, I would "Source -> Externalize Strings" and this replaces each string by something like Messages.getString("Foobar.0") where Messages is a global variable (constructed at program start from reading a properties file) In Haskell, I see at least two problems: a) reading the file is in IO b) there are no "global variables". implicit parameters perhaps? c) when I'm trying to be clever, I use "deriving Show/Read" or similar. then i18n should rename the constructors/accessors? I rather not. http://141.57.11.163/cgi-bin/cvsweb/tool/src/Grammatik/Type.hs.drift?rev=1.6 Best regards, -- -- Johannes Waldmann -- Tel/Fax (0341) 3076 6479/80 -- ---- http://www.imn.htwk-leipzig.de/~waldmann/ -------

4 3