- Generics - Haskell.org

PEPM'10 - Call for Papers (Deadline: 6 Oct 09) - Invited Speakers announced
by Andres Loeh 20 Jul '09

20 Jul '09

=============================================================== CALL FOR PAPERS ACM SIGPLAN 2010 Workshop on Partial Evaluation and Program Manipulation (PEPM'10) Madrid, January 18-19, 2010 (Affiliated with POPL'10) http://www.program-transformation.org/PEPM10 =============================================================== INVITED SPEAKERS: * Lennart Augustsson (Standard Chartered Bank, UK) * Jeremy Siek (University of Colorado at Boulder, USA) IMPORTANT DATES: * Paper submission: Tue, October 6, 2009, 23:59, Apia time * Author notification: Thu, October 29, 2009 * Camera-ready papers: Mon, November 9, 2009 To facilitate smooth organization of the review process, authors are asked to submit a short abstract by October 1, 2009. SUBMISSION CATEGORIES: * Regular research papers (max. 10 pages in ACM Proceedings style) * Tool demonstration papers (max. 4 pages plus max. 6 pages appendix) TRAVEL SUPPORT: Students and other attendants in need can apply for a SIGPLAN PAC grant to help cover expenses. For details, see http://www.sigplan.org/PAC.htm. SCOPE: The PEPM Symposium/Workshop series aims to bring together researchers and practitioners working in the areas of program manipulation, partial evaluation, and program generation. PEPM focuses on techniques, theories, tools, and applications of analysis and manipulation of programs. The 2010 PEPM workshop will be based on a broad interpretation of semantics-based program manipulation in a continued effort to expand the scope of PEPM significantly beyond the traditionally covered areas of partial evaluation and specialization and include practical applications of program transformations such as refactoring tools, and practical implementation techniques such as rule-based transformation systems. In addition, it covers manipulation and transformations of program and system representations such as structural and semantic models that occur in the context of model-driven development. In order to reach out to practitioners, there is a separate category of tool demonstration papers. Topics of interest for PEPM'10 include, but are not limited to: * Program and model manipulation techniques such as transformations driven by rules, patterns, or analyses, partial evaluation, specialization, program inversion, program composition, slicing, symbolic execution, refactoring, aspect weaving, decompilation, and obfuscation. * Program analysis techniques that are used to drive program/model manipulation such as abstract interpretation, static analysis, binding-time analysis, dynamic analysis, constraint solving, type systems, automated testing and test case generation. * Analysis and transformation for programs/models with advanced features such as objects, generics, ownership types, aspects, reflection, XML type systems, component frameworks, and middleware. * Techniques that treat programs/models as data objects including meta-programming, generative programming, deep embedded domain-specific languages, program synthesis by sketching and inductive programming, staged computation, and model-driven program generation and transformation. * Application of the above techniques including experimental studies, engineering needed for scalability, and benchmarking. Examples of application domains include legacy program understanding and transformation, DSL implementations, visual languages and end-user programming, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, resource-limited computation, and security. We especially encourage papers that break new ground including descriptions of how program/model manipulation tools can be integrated into realistic software development processes, descriptions of robust tools capable of effectively handling realistic applications, and new areas of application such as rapidly evolving systems, distributed and web-based programming including middleware manipulation, model-driven development, and on-the-fly program adaptation driven by run-time or statistical analysis. PROCEEDINGS: There will be formal proceedings published by ACM Press. In addition to printed proceedings, accepted papers will be included in the ACM Digital Library. Selected papers may later on be invited for a journal special issue dedicated to PEPM'10. SUBMISSION GUIDELINES: Papers should be submitted electronically via the workshop web site. Regular research papers must not exceed 10 pages in ACM Proceedings style. Tool demonstration papers must not exceed 4 pages in ACM Proceedings style, and authors will be expected to present a live demonstration of the described tool at the workshop (tool papers should include an additional appendix of up to 6 extra pages giving the outline, screenshots, examples, etc. to indicate the content of the proposed live demo at the workshop). Authors using Latex to prepare their submissions should use the new improved SIGPLAN proceedings style (sigplanconf.cls). PROGRAM CO-CHAIRS: * John Gallagher (Roskilde University, Denmark, and IMDEA Software, Spain) * Janis Voigtländer (Technische Universität Dresden, Germany) PROGRAM COMMITTEE MEMBERS: * Wei-Ngan Chin (National University of Singapore, Singapore) * Michael Codish (Ben-Gurion University of the Negev, Israel) * Jim Cordy (Queen's University, Canada) * Nate Foster (University of Pennsylvania, USA) * Haifeng Guo (University of Nebraska at Omaha, USA) * Patricia Johann (University of Strathclyde, UK) * Oleg Kiselyov (FNMOC, USA) * Günter Kniesel (University of Bonn, Germany) * Viktor Kuncak (Ecole Polytechnique Fédérale de Lausanne, Switzerland) * Yanhong Annie Liu (State University of New York at Stony Brook, USA) * Andres Löh (Utrecht University, Netherlands) * Jan Midtgaard (Roskilde University, Denmark) * David Monniaux (National Center for Scientific Research (CNRS) and VERIMAG laboratory, France) * Akimasa Morihata (University of Tokyo, Japan) * Alberto Pettorossi (Università di Roma Tor Vergata, Italy) * João Saraiva (Universidade do Minho, Portugal) * Ganesh Sittampalam (Credit Suisse, UK) * Fausto Spoto (Università di Verona, Italy) * Harald Søndergaard (University of Melbourne, Australia) * Walid Taha (Rice University, USA)

1 0

ANNOUNCE: regular-0.1
by José Pedro Magalhães 03 Jul '09

03 Jul '09

regular: Generic programming with fixed points for regular datatypes ==================================================================== Many generic programs require information about the recursive positions of a datatype. Examples include the generic fold, generic rewriting, and the Zipper data structure. This approach provides a fixed point view on data which allows these definitions for regular datatypes. It can be seen as a simplification of the Multirec library, which provides similar functionality but for families of (possibly mutually recursive) datatypes. This library is the underlying generic representation mechanism in the paper: Thomas van Noort, Alexey Rodriguez, Stefan Holdermans, Johan Jeuring, Bastiaan Heeren. A Lightweight Approach to Datatype-Generic Rewriting. In Ralf Hinze and Don Syme, editors, Proceedings of the ACM SIGPLAN Workshop on Generic Programming, WGP 2008, Victoria, BC, Canada, September 20, 2008, pages 13–24. ACM Press, 2008. More information is available on the webpage: http://www.cs.uu.nl/wiki/bin/view/GenericProgramming/Regular Features -------- * A simple library with a fixed point view * Includes detailed examples, such as the generic fold * Forms the basis for a generic rewriting library: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/rewriting * In its current form, this library does not support nested datatypes. Support to access parameters of a datatype is limited. Requirements ------------ * GHC 6.10.1 or later * Cabal 1.2.1 or later Download -------- With cabal-install: cabal install regular Get the package: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/regular Get the source: svn checkout https://subversion.cs.uu.nl/repos/project.dgp-haskell.libraries/regular/ Bugs & Support -------------- Report issues, request features, or just discuss the library with the authors, maintainers, and other interested persons at: http://www.haskell.org/mailman/listinfo/generics -------------- José Pedro Magalhães Universiteit Utrecht

1 0

Re: [Haskell] Data.Generics.gzip3 anyone?
by José Pedro Magalhães 05 Jun '09

05 Jun '09

Hello, Would there be interest in having this function added to the SYB library? Thanks, Pedro On Tue, Jun 2, 2009 at 00:40, Ralf Laemmel <rlaemmel(a)gmail.com> wrote: > > Thank you! What I have in mind is three way merging - you have two > > revisions based on the same original value, and you need to decide > whether > > they can be merged automatically or they need to be merged by a user. > You > > only have a real conflict when both revisions differ from the original > and > > from each other. > > Here is the completed exercise. > For comparison, the two args versions are shown up-front. > There is gzipWithM3 needed for gzip3, and gzip3 itself. > I also made it so that the top-level gzip functions have the > appropriate polymorphism. > Say same type for the args rather than independent polymorphism. > > {-# LANGUAGE RankNTypes #-} > > import Prelude hiding (GT) > import Data.Generics > > -- As originally defined: Twin map for transformation > > gzipWithT2 :: GenericQ (GenericT) -> GenericQ (GenericT) > gzipWithT2 f x y = case gmapAccumT perkid funs y of > ([], c) -> c > _ -> error "gzipWithT2" > where > perkid a d = (tail a, unGT (head a) d) > funs = gmapQ (\k -> GT (f k)) x > > > -- As originally defined: Twin map for transformation > > gzipWithM2 :: Monad m => GenericQ (GenericM m) -> GenericQ (GenericM m) > gzipWithM2 f x y = case gmapAccumM perkid funs y of > ([], c) -> c > _ -> error "gzipWithM" > where > perkid a d = (tail a, unGM (head a) d) > funs = gmapQ (\k -> GM (f k)) x > > > -- As originally defined: generic zip > > gzip2 :: > (forall x. Data x => x -> x -> Maybe x) > -> (forall x. Data x => x -> x -> Maybe x) > > gzip2 f = gzip2' f' > where > f' :: GenericQ (GenericM Maybe) > f' x y = cast x >>= \x' -> f x' y > gzip2' :: GenericQ (GenericM Maybe) -> GenericQ (GenericM Maybe) > gzip2' f x y = > f x y > `orElse` > if toConstr x == toConstr y > then gzipWithM2 (gzip2' f) x y > else Nothing > > > -- For three args now > > gzipWithT3 :: > GenericQ (GenericQ (GenericT)) > -> GenericQ (GenericQ (GenericT)) > gzipWithT3 f x y z = > case gmapAccumT perkid funs z of > ([], c) -> c > _ -> error "gzipWithT3" > where > perkid a d = (tail a, unGT (head a) d) > funs = case gmapAccumQ perkid' funs' y of > ([], q) -> q > _ -> error "gzipWithT3" > where > perkid' a d = (tail a, unGQ (head a) d) > funs' = gmapQ (\k -> (GQ (\k' -> GT (f k k')))) x > > gzipWithM3 :: Monad m > => GenericQ (GenericQ (GenericM m)) > -> GenericQ (GenericQ (GenericM m)) > gzipWithM3 f x y z = > case gmapAccumM perkid funs z of > ([], c) -> c > _ -> error "gzipWithM3" > where > perkid a d = (tail a, unGM (head a) d) > funs = case gmapAccumQ perkid' funs' y of > ([], q) -> q > _ -> error "gzipWithM3" > where > perkid' a d = (tail a, unGQ (head a) d) > funs' = gmapQ (\k -> (GQ (\k' -> GM (f k k')))) x > > gzip3 :: > (forall x. Data x => x -> x -> x -> Maybe x) > -> (forall x. Data x => x -> x -> x -> Maybe x) > > gzip3 f = gzip3' f' > where > f' :: GenericQ (GenericQ (GenericM Maybe)) > f' x y z = cast x >>= \x' -> cast y >>= \y' -> f x' y' z > gzip3' :: > GenericQ (GenericQ (GenericM Maybe)) > -> GenericQ (GenericQ (GenericM Maybe)) > gzip3' f x y z = > f x y z > `orElse` > if and [toConstr x == toConstr y, toConstr y == toConstr z] > then gzipWithM3 (gzip3' f) x y z > else Nothing > _______________________________________________ > Haskell mailing list > Haskell(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell >

2 1

Re: [Haskell] Data.Generics.gzip3 anyone?
by David Fox 03 Jun '09

03 Jun '09

On Tue, Jun 2, 2009 at 1:13 PM, David Fox <ddssff(a)gmail.com> wrote: > On Mon, Jun 1, 2009 at 3:40 PM, Ralf Laemmel <rlaemmel(a)gmail.com> wrote: > >> > Thank you! What I have in mind is three way merging - you have two >> > revisions based on the same original value, and you need to decide >> whether >> > they can be merged automatically or they need to be merged by a user. >> You >> > only have a real conflict when both revisions differ from the original >> and >> > from each other. >> >> Here is the completed exercise. >> For comparison, the two args versions are shown up-front. >> There is gzipWithM3 needed for gzip3, and gzip3 itself. >> I also made it so that the top-level gzip functions have the >> appropriate polymorphism. >> Say same type for the args rather than independent polymorphism. >> >> {-# LANGUAGE RankNTypes #-} >> >> import Prelude hiding (GT) >> import Data.Generics >> >> -- As originally defined: Twin map for transformation >> >> gzipWithT2 :: GenericQ (GenericT) -> GenericQ (GenericT) >> gzipWithT2 f x y = case gmapAccumT perkid funs y of >> ([], c) -> c >> _ -> error "gzipWithT2" >> where >> perkid a d = (tail a, unGT (head a) d) >> funs = gmapQ (\k -> GT (f k)) x >> >> >> -- As originally defined: Twin map for transformation >> >> gzipWithM2 :: Monad m => GenericQ (GenericM m) -> GenericQ (GenericM m) >> gzipWithM2 f x y = case gmapAccumM perkid funs y of >> ([], c) -> c >> _ -> error "gzipWithM" >> where >> perkid a d = (tail a, unGM (head a) d) >> funs = gmapQ (\k -> GM (f k)) x >> >> >> -- As originally defined: generic zip >> >> gzip2 :: >> (forall x. Data x => x -> x -> Maybe x) >> -> (forall x. Data x => x -> x -> Maybe x) >> >> gzip2 f = gzip2' f' >> where >> f' :: GenericQ (GenericM Maybe) >> f' x y = cast x >>= \x' -> f x' y >> gzip2' :: GenericQ (GenericM Maybe) -> GenericQ (GenericM Maybe) >> gzip2' f x y = >> f x y >> `orElse` >> if toConstr x == toConstr y >> then gzipWithM2 (gzip2' f) x y >> else Nothing >> >> >> -- For three args now >> >> gzipWithT3 :: >> GenericQ (GenericQ (GenericT)) >> -> GenericQ (GenericQ (GenericT)) >> gzipWithT3 f x y z = >> case gmapAccumT perkid funs z of >> ([], c) -> c >> _ -> error "gzipWithT3" >> where >> perkid a d = (tail a, unGT (head a) d) >> funs = case gmapAccumQ perkid' funs' y of >> ([], q) -> q >> _ -> error "gzipWithT3" >> where >> perkid' a d = (tail a, unGQ (head a) d) >> funs' = gmapQ (\k -> (GQ (\k' -> GT (f k k')))) x >> >> gzipWithM3 :: Monad m >> => GenericQ (GenericQ (GenericM m)) >> -> GenericQ (GenericQ (GenericM m)) >> gzipWithM3 f x y z = >> case gmapAccumM perkid funs z of >> ([], c) -> c >> _ -> error "gzipWithM3" >> where >> perkid a d = (tail a, unGM (head a) d) >> funs = case gmapAccumQ perkid' funs' y of >> ([], q) -> q >> _ -> error "gzipWithM3" >> where >> perkid' a d = (tail a, unGQ (head a) d) >> funs' = gmapQ (\k -> (GQ (\k' -> GM (f k k')))) x >> >> gzip3 :: >> (forall x. Data x => x -> x -> x -> Maybe x) >> -> (forall x. Data x => x -> x -> x -> Maybe x) >> >> gzip3 f = gzip3' f' >> where >> f' :: GenericQ (GenericQ (GenericM Maybe)) >> f' x y z = cast x >>= \x' -> cast y >>= \y' -> f x' y' z >> gzip3' :: >> GenericQ (GenericQ (GenericM Maybe)) >> -> GenericQ (GenericQ (GenericM Maybe)) >> gzip3' f x y z = >> f x y z >> `orElse` >> if and [toConstr x == toConstr y, toConstr y == toConstr z] >> then gzipWithM3 (gzip3' f) x y z >> else Nothing >> > > Ok, what I initially thought would work is not. I tried to do the three > way merge as follows: > > combine3 :: (Data a) => a -> a -> a -> Maybe a > combine3 original left right = > gzip3 f original left right > where > f :: forall a. (Data a) => a -> a -> a -> Maybe a > f original left right > | geq original left = Just right > | geq original right = Just left > | geq left right = Just left > | otherwise = Nothing > > However, what happens is that we usually reach the otherwise clause when > processing the top level of the data structure, so you get nothing. What > really needs to happen is that it traverses down into the data structure and > finds out that f is able to merge all the more primitive pieces of the data > structure, in which case it combines those merged parts to yield a merged > whole. I'm not quite sure how to fit this operation into the generic > framework. > Oh, I got it. I have to remove the "f x y z `orElse`" from the definition of gzip3.

1 1

Fwd: [Haskell] Data.Generics.gzip3 anyone?
by David Fox 02 Jun '09

02 Jun '09

---------- Forwarded message ---------- From: David Fox <ddssff(a)gmail.com> Date: Tue, Jun 2, 2009 at 1:13 PM Subject: Re: [Haskell] Data.Generics.gzip3 anyone? To: Ralf Laemmel <rlaemmel(a)gmail.com> Cc: haskell(a)haskell.org On Mon, Jun 1, 2009 at 3:40 PM, Ralf Laemmel <rlaemmel(a)gmail.com> wrote: > > Thank you! What I have in mind is three way merging - you have two > > revisions based on the same original value, and you need to decide > whether > > they can be merged automatically or they need to be merged by a user. > You > > only have a real conflict when both revisions differ from the original > and > > from each other. > > Here is the completed exercise. > For comparison, the two args versions are shown up-front. > There is gzipWithM3 needed for gzip3, and gzip3 itself. > I also made it so that the top-level gzip functions have the > appropriate polymorphism. > Say same type for the args rather than independent polymorphism. > > {-# LANGUAGE RankNTypes #-} > > import Prelude hiding (GT) > import Data.Generics > > -- As originally defined: Twin map for transformation > > gzipWithT2 :: GenericQ (GenericT) -> GenericQ (GenericT) > gzipWithT2 f x y = case gmapAccumT perkid funs y of > ([], c) -> c > _ -> error "gzipWithT2" > where > perkid a d = (tail a, unGT (head a) d) > funs = gmapQ (\k -> GT (f k)) x > > > -- As originally defined: Twin map for transformation > > gzipWithM2 :: Monad m => GenericQ (GenericM m) -> GenericQ (GenericM m) > gzipWithM2 f x y = case gmapAccumM perkid funs y of > ([], c) -> c > _ -> error "gzipWithM" > where > perkid a d = (tail a, unGM (head a) d) > funs = gmapQ (\k -> GM (f k)) x > > > -- As originally defined: generic zip > > gzip2 :: > (forall x. Data x => x -> x -> Maybe x) > -> (forall x. Data x => x -> x -> Maybe x) > > gzip2 f = gzip2' f' > where > f' :: GenericQ (GenericM Maybe) > f' x y = cast x >>= \x' -> f x' y > gzip2' :: GenericQ (GenericM Maybe) -> GenericQ (GenericM Maybe) > gzip2' f x y = > f x y > `orElse` > if toConstr x == toConstr y > then gzipWithM2 (gzip2' f) x y > else Nothing > > > -- For three args now > > gzipWithT3 :: > GenericQ (GenericQ (GenericT)) > -> GenericQ (GenericQ (GenericT)) > gzipWithT3 f x y z = > case gmapAccumT perkid funs z of > ([], c) -> c > _ -> error "gzipWithT3" > where > perkid a d = (tail a, unGT (head a) d) > funs = case gmapAccumQ perkid' funs' y of > ([], q) -> q > _ -> error "gzipWithT3" > where > perkid' a d = (tail a, unGQ (head a) d) > funs' = gmapQ (\k -> (GQ (\k' -> GT (f k k')))) x > > gzipWithM3 :: Monad m > => GenericQ (GenericQ (GenericM m)) > -> GenericQ (GenericQ (GenericM m)) > gzipWithM3 f x y z = > case gmapAccumM perkid funs z of > ([], c) -> c > _ -> error "gzipWithM3" > where > perkid a d = (tail a, unGM (head a) d) > funs = case gmapAccumQ perkid' funs' y of > ([], q) -> q > _ -> error "gzipWithM3" > where > perkid' a d = (tail a, unGQ (head a) d) > funs' = gmapQ (\k -> (GQ (\k' -> GM (f k k')))) x > > gzip3 :: > (forall x. Data x => x -> x -> x -> Maybe x) > -> (forall x. Data x => x -> x -> x -> Maybe x) > > gzip3 f = gzip3' f' > where > f' :: GenericQ (GenericQ (GenericM Maybe)) > f' x y z = cast x >>= \x' -> cast y >>= \y' -> f x' y' z > gzip3' :: > GenericQ (GenericQ (GenericM Maybe)) > -> GenericQ (GenericQ (GenericM Maybe)) > gzip3' f x y z = > f x y z > `orElse` > if and [toConstr x == toConstr y, toConstr y == toConstr z] > then gzipWithM3 (gzip3' f) x y z > else Nothing > Ok, what I initially thought would work is not. I tried to do the three way merge as follows: combine3 :: (Data a) => a -> a -> a -> Maybe a combine3 original left right = gzip3 f original left right where f :: forall a. (Data a) => a -> a -> a -> Maybe a f original left right | geq original left = Just right | geq original right = Just left | geq left right = Just left | otherwise = Nothing However, what happens is that we usually reach the otherwise clause when processing the top level of the data structure, so you get nothing. What really needs to happen is that it traverses down into the data structure and finds out that f is able to merge all the more primitive pieces of the data structure, in which case it combines those merged parts to yield a merged whole. I'm not quite sure how to fit this operation into the generic framework.

1 0

[ANN] multirec-binary
by Sebastiaan Visser 25 May '09

25 May '09

Hello all, MultiRec[1,2] is a great library for generic programming for families of possibly mutual recursive data types. Creating new generic functions might take some effort but the use of these functions is very straightforward. The multirec-binary[3] packages allows generic derivation of Data.Binary instances using the MultiRec library. Just try something like this: > import Data.Binary > import Generics.MultiRec.Base > import Generics.MultiRec.Binary > > instance Binary MyType where > put = gput MyFamily > get = gget MyFamily Have fun, -- Sebastiaan Visser [1] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/multirec-0.3 [2] http://www.cs.uu.nl/research/techreps/repo/CS-2008/2008-019.pdf [3] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/multirec-binary

1 0

MultiRec generic producer.
by Sebastiaan Visser 25 May '09

25 May '09

Hey guys, While playing around with MultiRec most things are pretty straightforward and most usage can be derived from the examples. The only thing that seems tricky to do, and of which I cannot find any examples, are generic producers. Any examples of generic producers that take no values as input but do produce values as output? E.g. generic parsers (read), binary get, arbitrary? I have some `SingleRec' producers that are fairly trivial to port except for the `Tag' case. Any clues? Thanks, -- Sebastiaan Visser

2 3

Complex Traversal Methods
by William Pearson 04 Mar '09

04 Mar '09

I have recently been thinking about traversing procedural graphs (e.g. L-systems and possible game state graphs), and have needed to develop ways of traversing them beyond doing stuff to everything (due to cycles and potentially being infinite). This may have been covered already, if so I would be interested in references. I thought the shape of the methods I developed might be of use to the generic community. The types of thing the idea might be useful for is something like giving karma to all of a certain persons friends and also their friends, but only once, in a social networking site. Basically it involves transforming the data type to another that has the information you need and then automatically deconstructing the data type after you have traversed the structure. What I think makes it more interesting is I decided that the functions to construct and deconstruct should be a data structure, and you can have functions to compose them so you could have a traversal controller to avoid loops and one to only go down two steps and add them together so the construction and deconstruction are done in the right order*, so you can combine them together. Some basic examples of the way I am going to code stuff I use for my procedural graphs can be found on my blog http://vrrm.wordpress.com/2009/03/03/unbounded-graphs2/. If I have some spare time, I'll have a look at a way to do this for Generics. Will Pearson * The loop avoidance would add make the data a tuple with a bool and didn't do anything if the Bool had been set to true. The depth controller would make the data a tuple with an Int that got incremented as you go down recursion levels which you then checked to see if it was above 2, in which case you could halt recursion.

1 0

ANNOUNCE: Extensible and Modular Generics for the Masses: emgm-0.3
by Sean Leather 03 Mar '09

03 Mar '09

============================================== Extensible and Modular Generics for the Masses ============================================== Extensible and Modular Generics for the Masses (EMGM) is a library for generic programming in Haskell using type classes and a sum-of-products view. ------- Updates ------- emgm-0.3 is the third major release, and it arrives a little over a month after emgm-0.2. Deriving is now greatly improved! Due to recent reports from users, we realized the current implementation just wasn't going to cut it. EMGM already supports a wide range of datatypes, so why not make the deriving code support just as many. Hopefully, it works well for you. Please let us know if your datatype is not supported. There are several new functions in the EMGM family. These include: cast (a type-safe, configurable, generic cast) and everywhere and everywhere' (functions similar to those of the same name in SYB that apply a transformation everywhere a certain type is found). ------- Changes ------- Changes from emgm-0.2 include: * Improved deriving can now handle datatype collections like this one: http://www.haskell.org/pipermail/generics/2009-February/000429.html * cast function > cast :: Rep (Map a) b => a -> b * everywhere and everywhere' > everywhere :: Rep (Everywhere a) b => (a -> a) -> b -> b > everywhere' :: Rep (Everywhere' a) b => (a -> a) -> b -> b They both perform transformations on a-values in a b-value. The former does them bottom-up, the latter top-down. The names come from similar functions in SYB that use rank-2 types. Note the difference. > everywhere :: (forall a. Data a => a -> a) -> forall a. Data a => a -> a > everywhere' :: (forall a. Data a => a -> a) -> forall a. Data a => a -> a ------------ Known Issues ------------ Due to a problem with the template-haskell package and Cabal, you cannot cabal-install the emgm package with GHC 6.8. However, take heart! EMGM works very well with GHC 6.8. You merely have to download the tar.gz package from Hackage yourself, build it, and install it. Since it doesn't require any dependencies beyond what comes with GHC, installation is a breeze! ------------------- General Information ------------------- Visit the home page: http://www.cs.uu.nl/wiki/GenericProgramming/EMGM ---------------- General Features ---------------- The primary features of EMGM include: * Datatype-generic programming using sum-of-product views * Large collection of ready-to-use generic functions * Included support for standard datatypes: lists, Maybe, tuples * Easy to add support for new datatypes * Type classes make writing new functions straightforward in a structurally inductive style * Generic functions are extensible with ad-hoc cases for arbitrary datatypes * Good performance of generic functions The features of this distribution include: * The API is thoroughly documented with Haddock * Fully tested with QuickCheck and HUnit * Program coverage ensures that all useful code has been touched by tests * Tested on both Mac and Windows systems ------------ Requirements ------------ EMGM has the following requirements: * GHC 6.8.1 - It has been tested with versions 6.8.3 and 6.10.1 * Cabal library 1.2.1 - It has been tested with versions 1.2.4.0 and 1.6.0.1. ----------------- Download & Source ----------------- Use caball-install: cabal install emgm Get the package: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/emgm Check out the current source with Subversion: svn checkout https://svn.cs.uu.nl:12443/repos/dgp-haskell/EMGM/trunk Or view it online: https://svn.cs.uu.nl:12443/viewvc/dgp-haskell/EMGM/trunk/ -------- Examples -------- Check out the examples: https://svn.cs.uu.nl:12443/viewvc/dgp-haskell/EMGM/trunk/examples/ -------------- Bugs & Support -------------- Report issues or request features: http://code.google.com/p/emgm/issues/list Discuss EMGM with the authors, maintainers, and other interested persons: http://www.haskell.org/mailman/listinfo/generics ------- Credits ------- The research for EMGM originated with Ralf Hinze. It was extended with work by Bruno Oliveira and Andres Löh. More details of the library functionality were explored by Alexey Rodriguez. We are very grateful to all of these people for the foundation on which this library was built. The current authors and maintainers of EMGM are: * Sean Leather * José Pedro Magalhães * Alexey Rodriguez * Andres Löh

1 0

EMGM: deriving instances
by Antoine Latter 19 Feb '09

19 Feb '09

Hello, This is listed as the mailing list for EMGM on its website: http://www.cs.uu.nl/wiki/GenericProgramming/EMGM I'm not sure if I'm using the template Haskell deriving properly for EMGM instances - I doesn't work for me for: + Data declarations which contain type synonyms + Data declarations which contain a Bool I get errors like: >>>>> Exception when trying to run compile-time code: Error! Unsupported constant type: Bool Code: EMGM.derive 'A <<<<< I get a similar error if my data type uses a 'String' instead of a Bool, but the error for the String goes away if I use [Char] instead. Is this expected behavior? If I'm just running into the limits of what EMGM template-Haskell deriving can do, that's okay. I just didn't see these limitations described anywhere. Thanks, Antoine --- I'm using GHC 6.10, with emgm-0.2 from hackage. Here's the sample program I'm working with: >>>>> {-# LANGUAGE TemplateHaskell , MultiParamTypeClasses , FlexibleContexts , FlexibleInstances , OverlappingInstances , UndecidableInstances #-} import qualified Generics.EMGM as EMGM data MyData a = MkMyData { name :: [Char] -- , flag :: Bool -- , otherName :: String , fa :: A a , fb :: B a } data A a = MkA Int Bool a data B a = MkB Char a $(EMGM.derive ''MyData) $(EMGM.derive ''A) $(EMGM.derive ''B) <<<<<

2 3