- Generics - Haskell.org

ANNOUNCE: syb-0.2
by José Pedro Magalhães 09 Apr '10

09 Apr '10

syb: Scrap Your Boilerplate! ================================================================================ Scrap Your Boilerplate (SYB) is a library for generic programming in Haskell. It is supported since the GHC >= 6.0 implementation of Haskell. Using this approach, you can write generic functions such as traversal schemes (e.g., everywhere and everything), as well as generic read, generic show and generic equality (i.e., gread, gshow, and geq). This approach is based on just a few primitives for type-safe cast and processing constructor applications. It was originally developed by Ralf Lämmel and Simon Peyton Jones. Since then, many people have contributed with research relating to SYB or its applications. More information is available on the webpage: http://www.cs.uu.nl/wiki/GenericProgramming/SYB What's new ---------- The biggest improvements from version 0.1 are: * Reintegration of the testsuite; * Introduction of the Generics.SYB.* module hierarchy (as synonyms for their Data.Generics.* counterparts); * Adding gshows :: Data a => a -> ShowS (more efficient than gshow); * Adding gmapAccumA :: forall b d a. (Data d, Applicative a) => (forall e. Data e => b -> e -> (b, a e)) -> b -> d -> (b, a d) ; * Adding ext1B :: (Data a, Typeable1 t) => a -> (forall b. Data b => (t b)) -> a ; * Introduction of two new generic producers ('empty' and 'constrs'). The former produces an empty value of a given datatype, while the latter produces a list of values of a datatype, each using a different constructor. Features -------- * Easy generic programming with combinators * GHC can derive Data and Typeable instances for your datatypes * Comes with many useful generic functions Requirements ------------ * GHC 6.10.1 or later * Cabal 1.6 or later Download -------- Get the package: http://hackage.haskell.org/package/syb Get the source: darcs get http://code.haskell.org/syb/ Bugs & Support -------------- Please report issues or request features at the bug tracker: http://code.google.com/p/scrapyourboilerplate/issues/list For discussion about the library with the authors, maintainers, and other interested persons use the mailing list: http://www.haskell.org/mailman/listinfo/generics

1 0

syb-0.2 release candidate
by José Pedro Magalhães 07 Apr '10

07 Apr '10

Fellow generic programmers, I finally managed to prepare a new release of SYB. Since this is a widely used library I decided to share a "preview" version here before putting it up on Hackage. There is nothing major in this version: basically, the testsuite was reintegrated and I added some basic generic producers. Please let me know if something goes wrong with this new version: http://code.haskell.org/syb/syb-0.2-rc1.tar.gz The draft announcement follows: syb: Scrap Your Boilerplate! > > ================================================================================ > > Scrap Your Boilerplate (SYB) is a library for generic programming in > Haskell. It > is supported in the GHC >= 6.0 implementation of Haskell. Using this > approach, > you can write generic functions such as traversal schemes (e.g., everywhere > and > everything), as well as generic read, generic show and generic equality > (i.e., > gread, gshow, and geq). This approach is based on just a few primitives for > > type-safe cast and processing constructor applications. > > It was originally developed by Ralf Lämmel and Simon Peyton Jones. Since > then, > many people have contributed with research relating to SYB or its > applications. > > More information is available on the webpage: > http://www.cs.uu.nl/wiki/GenericProgramming/SYB > > > What's new > ---------- > > The biggest improvements from version 0.1 are: > * The reintegration of the testsuite; > * The introduction of two new generic producers ('empty' and > 'constrs'). The former produces an empty value of a given datatype, > while > the latter produces a list of values of a datatype, each using a > different > constructor. > > > Features > -------- > > * Easy generic programming with combinators > > * GHC can derive Data and Typeable instances for your datatypes > > * Comes with many useful generic functions > > > Requirements > ------------ > > * GHC 6.10.1 or later > * Cabal 1.2.1 or later > > > Download > -------- > > With cabal-install: > > cabal install syb > > Get the package: > > http://hackage.haskell.org/package/syb > > Get the source: > > darcs get http://code.haskell.org/syb/ > > > Bugs & Support > -------------- > > Please report issues or request features at the bug tracker: > > http://code.google.com/p/scrapyourboilerplate/issues/list > > For discussion about the library with the authors, maintainers, and other > interested persons use the mailing list: > > http://www.haskell.org/mailman/listinfo/generics > Thanks, Pedro

3 2

Rewriting libraries
by Ozgur Akgun 04 Apr '10

04 Apr '10

Hi all, I am implementing something which needs to make use of generic rewriting. I tried implementing a rewriting system of my own, using Uniplate's transform and rewrite methods, and currently I am trying to use the guarded-rewriting package. (whose maintainer is generics(a)haskell.org) I am reading the paper linked from hackage, A Lightweight Approach to Datatype-Generic Rewriting, and I must say I quite liked the approach in most places. Especially not using simple pattern matching in rewrite rules is an important step, to my understanding. However I do have some questions regarding the toolchain: - There is another package, rewriting, which links to the same paper. What is the relationship between these two implementations? Is one of them obsolete? - In the paper, it's mentioned that the Representable instances might be generated automatically. I have quite a complex term structure (and subject to changes), so I wonder if you are planning to work towards achieving this. If not, can you give me some pointers to automate this process myself? - Is it possible to write "nice" show functions for rewrite rules, namely the Rule data type. Thanks a lot for this work, Best, -- Ozgur Akgun PhD Student University of St Andrews

2 1

ANNOUNCE: guarded-rewriting-0.1: Generic rewriting with preconditions
by José Pedro Magalhães 03 Mar '10

03 Mar '10

guarded-rewriting-0.1: Generic rewriting with preconditions ===================================================================== This is a generic rewriting library based on type classes and type families described in the paper: Thomas van Noort, Alexey Rodriguez Yakushev, Stefan Holdermans, Johan Jeuring, Bastiaan Heeren, José Pedro Magalhães. A Lightweight Approach to Datatype-Generic Rewriting. Journal of Functional Programming, Special Issue on Generic Programming, 2010. A draft version of this paper is currently available at http://dreixel.net/research/pdf/ladgr_draft.pdf. The main differences from our previous generic programming library (see http://hackage.haskell.org/package/rewriting) are the support for more datatypes (including parametrized and families of datatypes) and the possibility of adding preconditions to rewrite rules. It uses the instant-generics library, first described by Chakravarty et al. (see http://www.cse.unsw.edu.au/~chak/project/generics/) which we packaged and released separately (see http://hackage.haskell.org/package/instant-generics) Requirements ------------ * GHC 6.10.4 or later * Cabal 1.6 or later Download -------- With cabal-install: cabal install guarded-rewriting Get the package: http://hackage.haskell.org/package/guarded-rewriting Get the source: svn checkout https://subversion.cs.uu.nl/repos/project.dgp-haskell.libraries/GuardedRewr… Bugs & Support -------------- For more information visit the project homepage: http://www.cs.uu.nl/wiki/bin/view/GenericProgramming/GuardedRewriting 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

1 0

WGP 2010 Call for Papers
by Bruno Oliveira 18 Feb '10

18 Feb '10

6th ACM SIGPLAN Workshop on Generic Programming, 2010 Baltimore, Maryland, US Sunday, September 26th, 2010 http://osl.iu.edu/wgp2010 Goals of the workshop Generic programming is about making programs more adaptable by making them more general. Generic programs often embody non-traditional kinds of polymorphism; ordinary programs are obtained from them by suitably instantiating their parameters. In contrast with normal programs, the parameters of a generic program are often quite rich in structure; for example they may be other programs, types or type constructors, class hierarchies, or even programming paradigms. Generic programming techniques have always been of interest, both to practitioners and to theoreticians, and, for at least 20 years, generic programming techniques have been a specific focus of research in the functional and object-oriented programming communities. Generic programming has gradually spread to more and more mainstream languages, and today is widely used in industry. This workshop brings together leading researchers and practitioners in generic programming from around the world, and features papers capturing the state of the art in this important area. We welcome contributions on all aspects, theoretical as well as practical, of * polytypic programming, * programming with dependent types, * programming with type classes, * programming with (C++) concepts, * generic programming, * programming with modules, * meta-programming, * adaptive object-oriented programming, * component-based programming, * strategic programming, * aspect-oriented programming, * family polymorphism, * object-oriented generic programming, * and so on. Organisers: Co-Chair Bruno C. d. S. Oliveira, Seoul National University Co-Chair Marcin Zalewski, Indiana University Programme Committee: Alley Stoughton, Kansas State University Andrei Alexandrescu, Facebook Bruno C. d. S. Oliveira (Co-Chair), Seoul National University Doug Gregor, Apple Gilad Bracha, I am a Computational Theologist Emeritus Magne Haveraaen, Universitetet i Bergen Marcin Zalewski (Co-Chair), Indiana University Neil Mitchell, Standard Chartered Ralf Lämmel, University of Koblenz-Landau Shin-Cheng Mu, Academia Sinica Thorsten Altenkirch, University of Nottingham Ulf Norell, Chalmers University We plan to have formal proceedings, published by the ACM. Submission details Deadline for submission: Sunday 2010-06-13 Notification of acceptance: Monday 2010-07-12 Final submission due: Tuesday 2010-07-27 Workshop: Sunday 2010-09-26 Authors should submit papers, in postscript or PDF format, formatted for A4 paper, to the WGP09 EasyChair instance by 13th of June 2010. The length should be restricted to 12 pages in standard (two-column, 9pt) ACM format. Accepted papers are published by the ACM and will additionally appear in the ACM digital library. History of the Workshop on Generic Programming This year: * Baltimore, Maryland, US 2010 (affiliated with ICFP10) Earlier Workshops on Generic Programming have been held in * Edinburgh, UK 2009 (affiliated with ICFP09) * Victoria, BC, Canada 2008 (affiliated with ICFP), * Portland 2006 (affiliated with ICFP), * Ponte de Lima 2000 (affiliated with MPC), * Marstrand 1998 (affiliated with MPC). Furthermore, there were a few informal workshops * Utrecht 2005 (informal workshop), * Dagstuhl 2002 (IFIP WG2.1 Working Conference), * Nottingham 2001 (informal workshop), There were also (closely related) DGP workshops in Oxford (June 3-4 2004), and a Spring School on DGP in Nottingham (April 24-27 2006, which had a half-day workshop attached). Additional information: The WGP steering committee consists of J Gibbons, R Hinze, P Jansson, J Jarvi, J Jeuring, B Oliveira, S Schupp and M Zalewski

1 0

ANNOUNCE: regular-0.2 and regular-extras-0.1
by José Pedro Magalhães 28 Oct '09

28 Oct '09

Hello all, I'm pleased to announce a new version of the regular library which provides 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. http://people.cs.uu.nl/stefan/pubs/noort08lightweight.html More information is available on the webpage: http://www.cs.uu.nl/wiki/GenericProgramming/Regular Additionally, we have also released a regular-extras package which provides more generic functions operating on the fixed point view provided by regular. Currently the functions provided are: * QuickCheck's arbitrary, with an option to provide size, and frequencies for each constructor; * QuickCheck's coarbitrary; * Data.Binary get and put. 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/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 cabal install regular-extras Get the packages: http://hackage.haskell.org/package/regular http://hackage.haskell.org/package/regular-extras Get the source: svn checkout https://subversion.cs.uu.nl/repos/project.dgp-haskell.libraries/regular/ svn checkout https://subversion.cs.uu.nl/repos/project.dgp-haskell.libraries/regular-ext… 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 Pedro

1 0

Re: [Hs-Generics] how to automatically create and install documentations of a package?
by Daneel Yaitskov 19 Sep '09

19 Sep '09

Gwern Branwen wrote: > On Sat, Sep 19, 2009 at 11:59 AM, Sean Leather <leather(a)cs.uu.nl> wrote: >> Hi Daneel, >> >> On Sat, Sep 19, 2009 at 13:58, Daneel Yaitskov wrote: >>> Recently I've found wonderful thing cabal can install packages itself! It >>> can even install those packages which need for final one. But I'm disturbed >>> cabal doesn't create the documentation of a package by default. It manually >>> makes "runhaskell Setup haddock". >>> >>> Who knows? >> I believe you can do 'cabal haddock', but I don't know why it doesn't do it >> by default. >> >> BTW, the Haskell Café is typically more suitable for questions such as >> these. The Generics list is more specifically for generic programming >> discussions while the Haskell Café serves a broader audience. I've CC'd >> haskell-cafe@ to see if anybody there knows the answer to your question. >> >> Regards, >> Sean > > If you use cabal-install (as you should!), you can have it build > haddocks by customizing ~/.cabal/config and adding: > > documentation: True > Thank you very much for short hint, but effective one. Daneel Yaitskov.

1 0

how to automatically create and install documentations of a package?
by Daneel Yaitskov 19 Sep '09

19 Sep '09

Hi All, Recently I've found wonderful thing cabal can install packages itself! It can even install those packages which need for final one. But I'm disturbed cabal doesn't create the documentation of a package by default. It manually makes "runhaskell Setup haddock". Who knows? Daneel Yaitskov.

2 2

Generics for constructing Rows
by Max Desyatov 20 Aug '09

20 Aug '09

Hi, all. I've come into trouble defining function `gmap` which will work on these data types: > data Row = Row > (E Name) > (E Salary) > (E Department) > type E a = Either (Maybe RowIndex) (Maybe a) > type RowIndex = Int `RowIndex`, `Name`, `Salary`, `Department` have kind * pseudocode: > gmap :: (E a -> E a) -> Row -> Row > readRow :: [String] -> Row -> Row > readRow l = gmap (\(Left (Just ri)) -> Right $ l `atMay` c >>= readMay) `atMay` and `readMay` are defined in module `Safe` from package `safe` > atMay :: [a] -> Int -> Maybe a > readMay :: (Read a) => String -> Maybe a Basically we have optional Row indices and try to read raw row (list of Strings) into the same Row type if index is present. At this moment I just have separate data type for row which has been read and just a list of row indices, but it is definitely flawed when I need to add fields to Row from time to time, as it is too easy to introduce bugs while positioning in list of row indices, not mentioning all those boilerplate code flowing around. I've tried to define gmap using libraries for generic programming but failed each time while type checking for different reasons. With `Data.Generics` and `gmapT` it fails because gmapT doesn't allow traversion function to have `Read a` constraint (Data and Typeable instances for Row and inner data types of course were derived). EMGM's map demands traversion function to be non-polymorphic, i.e. type-checker fails with the message, complaining it cannot match `E a` against `E Name`, against `E Salary` etc. For each of this I've spent smth about five hours just reading API docs, papers, and trying to beat type-checker. Maybe I'll look into Smash, RepLib and others, but I hope someone was also trying to define such gmap and succeeded. So, generic programming folks, is it even possible to define such function? I don't really care about using GHC extensions, I don't care about code being portable, I just want to remove boilerplate and prevent introducing bugs. Thanks in advance, Max.

1 0

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

08 Aug '09

Ok, here is another piece of the three way merging puzzle. The gzip3 function can do three way merging when there are no conflicts that need to be resolved manually. When there are such conflicts we need a user interface which displays the common ancestor, the two alternative edits, and provides a place to input the merged result. For this we are using a generic programming interface to formlets . Formlets are members of class Applicative, so we can write a function to turn a value into a formlet using a gmapA function (this is syb-with-class generics): type GenericA f ctx = forall a. (Applicative f, Data ctx a) => a -> f a gmapA :: (Applicative f) => Proxy ctx -> GenericA f ctx -> GenericA f ctx gmapA ctx f = gfoldl ctx k pure where k c x = c <*> (f x) Then the formlet for a value is created using something like this: gmapA formletOfProxy (formletOfD dict) x For three way merging, though, we need to turn three values of the same type into a formlet, something like a gmap3A function: gmap3A formletOfProxy (formletOfD dict) ancestor variant1 variant2 Its this gmap3A function that I'm unable to create. I'm hoping someone out there will find this a piece of cake... 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 >

1 1