packages feed

syb 0.7.2.3 → 0.7.2.4

raw patch · 7 files changed

+434/−64 lines, 7 files

Files

Changelog.md view
@@ -1,3 +1,7 @@+# 0.7.2.4+- Improved documentation (thanks to @BinderDavid)+- Export `ext2` function which was already defined but not exported+ # 0.7.2.3 - Compatibility with `mtl` 2.3 and GHC 9.6
src/Data/Generics/Aliases.hs view
@@ -4,35 +4,58 @@ -- Module      :  Data.Generics.Aliases -- Copyright   :  (c) The University of Glasgow, CWI 2001--2004 -- License     :  BSD-style (see the LICENSE file)--- +-- -- Maintainer  :  generics@haskell.org -- Stability   :  experimental -- Portability :  non-portable (local universal quantification) ----- \"Scrap your boilerplate\" --- Generic programming in Haskell --- See <http://www.cs.uu.nl/wiki/GenericProgramming/SYB>.--- The present module provides a number of declarations for typical generic+-- This module provides a number of declarations for typical generic -- function types, corresponding type case, and others. -- -----------------------------------------------------------------------------  module Data.Generics.Aliases ( -        -- * Combinators to \"make\" generic functions via cast-        mkT, mkQ, mkM, mkMp, mkR,-        ext0, extT, extQ, extM, extMp, extB, extR,+        -- * Combinators which create generic functions via cast+        --+        -- $castcombinators -        -- * Type synonyms for generic function types+        -- ** Transformations+        mkT,+        extT,+        -- ** Queries+        mkQ,+        extQ,+        -- ** Monadic transformations+        mkM,+        extM,+        -- ** MonadPlus transformations+        mkMp,+        extMp,+        -- ** Readers+        mkR,+        extR,+        -- ** Builders+        extB,+        -- ** Other+        ext0,+        -- * Types for generic functions+        -- ** Transformations         GenericT,+        GenericT'(..),+        -- ** Queries         GenericQ,+        GenericQ'(..),+        -- ** Monadic transformations         GenericM,-        GenericB,+        GenericM'(..),+        -- ** Readers         GenericR,+        -- ** Builders+        GenericB,+        -- ** Other         Generic,         Generic'(..),-        GenericT'(..),-        GenericQ'(..),-        GenericM'(..),          -- * Ingredients of generic functions         orElse,@@ -52,6 +75,7 @@         ext1B,          -- * Type extension for binary type constructors+        ext2,         ext2T,         ext2M,         ext2Q,@@ -73,149 +97,346 @@ -- ------------------------------------------------------------------------------ --- | Make a generic transformation;---   start from a type-specific case;---   preserve the term otherwise+-- $castcombinators --+-- Other programming languages sometimes provide an operator @instanceof@ which+-- can check whether an expression is an instance of a given type. This operator+-- allows programmers to implement a function @f :: forall a. a -> a@ which exhibits+-- a different behaviour depending on whether a `Bool` or a `Char` is passed.+-- In Haskell this is not the case: A function with type @forall a. a -> a@+-- can only be the identity function or a function which loops indefinitely+-- or throws an exception. That is, it must implement exactly the same behaviour+-- for any type at which it is used. But sometimes it is very useful to have+-- a function which can accept (almost) any type and exhibit a different behaviour+-- for different types. Haskell provides this functionality with the 'Typeable'+-- typeclass, whose instances can be automatically derived by GHC for almost all+-- types. This typeclass allows the definition of a functon 'cast' which has type+-- @forall a b. (Typeable a, Typeable b) => a -> Maybe b@. The 'cast' function allows+-- to implement a polymorphic function with different behaviour at different types:+--+-- >>> cast True :: Maybe Bool+-- Just True+--+-- >>> cast True :: Maybe Int+-- Nothing+--+-- This section provides combinators which make use of 'cast' internally to+-- provide various polymorphic functions with type-specific behaviour.+++-- | Extend the identity function with a type-specific transformation.+-- The function created by @mkT ext@ behaves like the identity function on all+-- arguments which cannot be cast to type @b@, and like the function @ext@ otherwise.+-- The name 'mkT' is short for "make transformation".+--+-- === __Examples__+--+-- >>> mkT not True+-- False+--+-- >>> mkT not 'a'+-- 'a'+--+-- @since 0.1.0.0 mkT :: ( Typeable a        , Typeable b        )     => (b -> b)+    -- ^ The type-specific transformation     -> a+    -- ^ The argument we try to cast to type @b@     -> a mkT = extT id  --- | Make a generic query;---   start from a type-specific case;---   return a constant otherwise+-- | The function created by @mkQ def f@ returns the default result+-- @def@ if its argument cannot be cast to type @b@, otherwise it returns+-- the result of applying @f@ to its argument.+-- The name 'mkQ' is short for "make query". --+-- === __Examples__+--+-- >>> mkQ "default" (show :: Bool -> String) True+-- "True"+--+-- >>> mkQ "default" (show :: Bool -> String) ()+-- "default"+--+-- @since 0.1.0.0 mkQ :: ( Typeable a        , Typeable b        )     => r+    -- ^ The default result     -> (b -> r)+    -- ^ The transformation to apply if the cast is successful     -> a+    -- ^ The argument we try to cast to type @b@     -> r (r `mkQ` br) a = case cast a of                         Just b  -> br b                         Nothing -> r  --- | Make a generic monadic transformation;---   start from a type-specific case;---   resort to return otherwise+-- | Extend the default monadic action @pure :: Monad m => a -> m a@ by a type-specific+-- monadic action. The function created by @mkM act@ behaves like 'pure' if its+-- argument cannot be cast to type @b@, and like the monadic action @act@ otherwise.+-- The name 'mkM' is short for "make monadic transformation". --+-- === __Examples__+--+-- >>> mkM (\x -> [x, not x]) True+-- [True,False]+--+-- >>> mkM (\x -> [x, not x]) (5 :: Int)+-- [5]+--+-- @since 0.1.0.0 mkM :: ( Monad m        , Typeable a        , Typeable b        )     => (b -> m b)+    -- ^ The type-specific monadic transformation     -> a+    -- ^ The argument we try to cast to type @b@     -> m a mkM = extM return --{---For the remaining definitions, we stick to a more concise style, i.e.,-we fold maybes with "maybe" instead of case ... of ..., and we also-use a point-free style whenever possible.---}----- | Make a generic monadic transformation for MonadPlus;---   use \"const mzero\" (i.e., failure) instead of return as default.+-- | Extend the default 'MonadPlus' action @const mzero@ by a type-specific 'MonadPlus'+-- action. The function created by @mkMp act@ behaves like @const mzero@ if its argument+-- cannot be cast to type @b@, and like the monadic action @act@ otherwise.+-- The name 'mkMp' is short for "make MonadPlus transformation". --+-- === __Examples__+--+-- >>> mkMp (\x -> Just (not x)) True+-- Just False+--+-- >>> mkMp (\x -> Just (not x)) 'a'+-- Nothing+--+-- @since 0.1.0.0 mkMp :: ( MonadPlus m         , Typeable a         , Typeable b         )      => (b -> m b)+     -- ^ The type-specific MonadPlus action      -> a+     -- ^ The argument we try to cast to type @b@      -> m a mkMp = extM (const mzero)  --- | Make a generic builder;---   start from a type-specific ase;---   resort to no build (i.e., mzero) otherwise+-- | Make a generic reader from a type-specific case.+-- The function created by @mkR f@ behaves like the reader @f@ if an expression+-- of type @a@ can be cast to type @b@, and like the expression @mzero@ otherwise.+-- The name 'mkR' is short for "make reader". --+-- === __Examples__+--+-- >>> mkR (Just True) :: Maybe Bool+-- Just True+--+-- >>> mkR (Just True) :: Maybe Int+-- Nothing+--+-- @since 0.1.0.0 mkR :: ( MonadPlus m        , Typeable a        , Typeable b        )-    => m b -> m a+    => m b+    -- ^ The type-specific reader+    -> m a mkR f = mzero `extR` f   -- | Flexible type extension+--+-- === __Examples__+--+-- >>> ext0 [1 :: Int, 2, 3] [True, False] :: [Int]+-- [1,2,3]+--+-- >>> ext0 [1 :: Int, 2, 3] [4 :: Int, 5, 6] :: [Int]+-- [4,5,6]+--+-- @since 0.1.0.0 ext0 :: (Typeable a, Typeable b) => c a -> c b -> c a ext0 def ext = maybe def id (gcast ext)  --- | Extend a generic transformation by a type-specific case+-- | Extend a generic transformation by a type-specific transformation.+-- The function created by @extT def ext@ behaves like the generic transformation+-- @def@ if its argument cannot be cast to the type @b@, and like the type-specific+-- transformation @ext@ otherwise.+-- The name 'extT' is short for "extend transformation".+--+-- === __Examples__+--+-- >>> extT id not True+-- False+--+-- >>> extT id not 'a'+-- 'a'+--+-- @since 0.1.0.0 extT :: ( Typeable a         , Typeable b         )      => (a -> a)+     -- ^ The transformation we want to extend      -> (b -> b)+     -- ^ The type-specific transformation      -> a+     -- ^ The argument we try to cast to type @b@      -> a extT def ext = unT ((T def) `ext0` (T ext))  --- | Extend a generic query by a type-specific case+-- | Extend a generic query by a type-specific query. The function created by @extQ def ext@ behaves+-- like the generic query @def@ if its argument cannot be cast to the type @b@, and like the type-specific+-- query @ext@ otherwise.+-- The name 'extQ' is short for "extend query".+--+-- === __Examples__+--+-- >>> extQ (const True) not True+-- False+--+-- >>> extQ (const True) not 'a'+-- True+--+-- @since 0.1.0.0 extQ :: ( Typeable a         , Typeable b         )-     => (a -> q)-     -> (b -> q)+     => (a -> r)+     -- ^ The query we want to extend+     -> (b -> r)+     -- ^ The type-specific query      -> a-     -> q+     -- ^ The argument we try to cast to type @b@+     -> r extQ f g a = maybe (f a) g (cast a)  --- | Extend a generic monadic transformation by a type-specific case+-- | Extend a generic monadic transformation by a type-specific case.+-- The function created by @extM def ext@ behaves like the monadic transformation+-- @def@ if its argument cannot be cast to type @b@, and like the monadic transformation+-- @ext@ otherwise.+-- The name 'extM' is short for "extend monadic transformation".+--+-- === __Examples__+--+-- >>> extM (\x -> [x,x])(\x -> [not x, x]) True+-- [False,True]+--+-- >>> extM (\x -> [x,x])(\x -> [not x, x]) (5 :: Int)+-- [5,5]+--+-- @since 0.1.0.0 extM :: ( Monad m         , Typeable a         , Typeable b         )-     => (a -> m a) -> (b -> m b) -> a -> m a+     => (a -> m a)+     -- ^ The monadic transformation we want to extend+     -> (b -> m b)+     -- ^ The type-specific monadic transformation+     -> a+     -- ^ The argument we try to cast to type @b@+     -> m a extM def ext = unM ((M def) `ext0` (M ext))  --- | Extend a generic MonadPlus transformation by a type-specific case+-- | Extend a generic MonadPlus transformation by a type-specific case.+-- The function created by @extMp def ext@ behaves like 'MonadPlus' transformation @def@+-- if its argument cannot be cast to type @b@, and like the transformation @ext@ otherwise.+-- Note that 'extMp' behaves exactly like 'extM'.+-- The name 'extMp' is short for "extend MonadPlus transformation".+--+-- === __Examples__+--+-- >>> extMp (\x -> [x,x])(\x -> [not x, x]) True+-- [False,True]+--+-- >>> extMp (\x -> [x,x])(\x -> [not x, x]) (5 :: Int)+-- [5,5]+--+-- @since 0.1.0.0 extMp :: ( MonadPlus m          , Typeable a          , Typeable b          )-      => (a -> m a) -> (b -> m b) -> a -> m a+      => (a -> m a)+      -- ^ The 'MonadPlus' transformation we want to extend+      -> (b -> m b)+      -- ^ The type-specific 'MonadPlus' transformation+      -> a+      -- ^ The argument we try to cast to type @b@+      -> m a extMp = extM  --- | Extend a generic builder+-- | Extend a generic builder by a type-specific case.+-- The builder created by @extB def ext@ returns @def@ if @ext@ cannot be cast+-- to type @a@, and like @ext@ otherwise.+-- The name 'extB' is short for "extend builder".+--+-- === __Examples__+--+-- >>> extB True 'a'+-- True+--+-- >>> extB True False+-- False+--+-- @since 0.1.0.0 extB :: ( Typeable a         , Typeable b         )-     => a -> b -> a+     => a+     -- ^ The default result+     -> b+     -- ^ The argument we try to cast to type @a@+     -> a extB a = maybe a id . cast  --- | Extend a generic reader+-- | Extend a generic reader by a type-specific case.+-- The reader created by @extR def ext@ behaves like the reader @def@+-- if expressions of type @b@ cannot be cast to type @a@, and like the+-- reader @ext@ otherwise.+-- The name 'extR' is short for "extend reader".+--+-- === __Examples__+--+-- >>> extR (Just True) (Just 'a')+-- Just True+--+-- >>> extR (Just True) (Just False)+-- Just False+--+-- @since 0.1.0.0 extR :: ( Monad m         , Typeable a         , Typeable b         )-     => m a -> m b -> m a+     => m a+     -- ^ The generic reader we want to extend+     -> m b+     -- ^ The type-specific reader+     -> m a extR def ext = unR ((R def) `ext0` (R ext))    ------------------------------------------------------------------------------ -----      Type synonyms for generic function types+--      Types for generic functions -- ------------------------------------------------------------------------------ @@ -223,30 +444,53 @@ -- | Generic transformations, --   i.e., take an \"a\" and return an \"a\" --+-- @since 0.1.0.0 type GenericT = forall a. Data a => a -> a +-- | The type synonym `GenericT` has a polymorphic type, and can therefore not+--   appear in places where monomorphic types are expected, for example in a list.+--   The newtype `GenericT'` wraps `GenericT` in a newtype to lift this restriction.+--+-- @since 0.1.0.0+newtype GenericT' = GT { unGT :: GenericT }  -- | Generic queries of type \"r\", --   i.e., take any \"a\" and return an \"r\" --+-- @since 0.1.0.0 type GenericQ r = forall a. Data a => a -> r +-- | The type synonym `GenericQ` has a polymorphic type, and can therefore not+--   appear in places where monomorphic types are expected, for example in a list.+--   The newtype `GenericQ'` wraps `GenericQ` in a newtype to lift this restriction.+--+-- @since 0.1.0.0+newtype GenericQ' r = GQ { unGQ :: GenericQ r }  -- | Generic monadic transformations, --   i.e., take an \"a\" and compute an \"a\" --+-- @since 0.1.0.0 type GenericM m = forall a. Data a => a -> m a +-- | The type synonym `GenericM` has a polymorphic type, and can therefore not+--   appear in places where monomorphic types are expected, for example in a list.+--   The newtype `GenericM'` wraps `GenericM` in a newtype to lift this restriction.+--+-- @since 0.1.0.0+newtype GenericM' m = GM { unGM :: GenericM m }  -- | Generic builders --   i.e., produce an \"a\". --+-- @since 0.1.0.0 type GenericB = forall a. Data a => a   -- | Generic readers, say monadic builders, --   i.e., produce an \"a\" with the help of a monad \"m\". --+-- @since 0.1.0.0 type GenericR m = forall a. Data a => m a  @@ -254,28 +498,51 @@ --   assumed by gfoldl; there are isomorphisms such as --   GenericT = Generic T. --+-- @since 0.1.0.0 type Generic c = forall a. Data a => a -> c a  --- | Wrapped generic functions;---   recall: [Generic c] would be legal but [Generic' c] not.+-- | The type synonym `Generic` has a polymorphic type, and can therefore not+--   appear in places where monomorphic types are expected, for example in a list.+--   The data type `Generic'` wraps `Generic` in a data type to lift this restriction. --+-- @since 0.1.0.0 data Generic' c = Generic' { unGeneric' :: Generic c } ---- | Other first-class polymorphic wrappers-newtype GenericT'   = GT { unGT :: forall a. Data a => a -> a }-newtype GenericQ' r = GQ { unGQ :: GenericQ r }-newtype GenericM' m = GM { unGM :: forall a. Data a => a -> m a }-+------------------------------------------------------------------------------+--+-- Ingredients of generic functions+--+------------------------------------------------------------------------------  -- | Left-biased choice on maybes+--+-- === __Examples__+--+-- >>> orElse Nothing Nothing+-- Nothing+--+-- >>> orElse Nothing (Just 'a')+-- Just 'a'+--+-- >>> orElse (Just 'a') Nothing+-- Just 'a'+--+-- >>> orElse (Just 'a') (Just 'b')+-- Just 'a'+--+-- @since 0.1.0.0 orElse :: Maybe a -> Maybe a -> Maybe a x `orElse` y = case x of                  Just _  -> x                  Nothing -> y  +------------------------------------------------------------------------------+--+-- Function combinators on generic functions+--+------------------------------------------------------------------------------ {-  The following variations take "orElse" to the function@@ -289,21 +556,29 @@ -}  -- | Choice for monadic transformations+--+-- @since 0.1.0.0 choiceMp :: MonadPlus m => GenericM m -> GenericM m -> GenericM m choiceMp f g x = f x `mplus` g x   -- | Choice for monadic queries+--+-- @since 0.1.0.0 choiceQ :: MonadPlus m => GenericQ (m r) -> GenericQ (m r) -> GenericQ (m r) choiceQ f g x = f x `mplus` g x   -- | Recover from the failure of monadic transformation by identity+--+-- @since 0.1.0.0 recoverMp :: MonadPlus m => GenericM m -> GenericM m recoverMp f = f `choiceMp` return   -- | Recover from the failure of monadic query by a constant+--+-- @since 0.1.0.0 recoverQ :: MonadPlus m => r -> GenericQ (m r) -> GenericQ (m r) recoverQ r f = f `choiceQ` const (return r) @@ -319,6 +594,8 @@ #endif  -- | Flexible type extension+--+-- @since 0.3 ext1 :: (Data a, Typeable1 t)      => c a      -> (forall d. Data d => c (t d))@@ -327,6 +604,8 @@   -- | Type extension of transformations for unary type constructors+--+-- @since 0.1.0.0 ext1T :: (Data d, Typeable1 t)       => (forall e. Data e => e -> e)       -> (forall f. Data f => t f -> t f)@@ -335,6 +614,8 @@   -- | Type extension of monadic transformations for type constructors+--+-- @since 0.1.0.0 ext1M :: (Monad m, Data d, Typeable1 t)       => (forall e. Data e => e -> m e)       -> (forall f. Data f => t f -> m (t f))@@ -343,6 +624,8 @@   -- | Type extension of queries for type constructors+--+-- @since 0.1.0.0 ext1Q :: (Data d, Typeable1 t)       => (d -> q)       -> (forall e. Data e => t e -> q)@@ -351,6 +634,8 @@   -- | Type extension of readers for type constructors+--+-- @since 0.1.0.0 ext1R :: (Monad m, Data d, Typeable1 t)       => m d       -> (forall e. Data e => m (t e))@@ -359,6 +644,8 @@   -- | Type extension of builders for type constructors+--+-- @since 0.2 ext1B :: (Data a, Typeable1 t)       => a       -> (forall b. Data b => (t b))@@ -378,6 +665,8 @@   -- | Type extension of transformations for unary type constructors+--+-- @since 0.3 ext2T :: (Data d, Typeable2 t)       => (forall e. Data e => e -> e)       -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> t d1 d2)@@ -386,6 +675,8 @@   -- | Type extension of monadic transformations for type constructors+--+-- @since 0.3 ext2M :: (Monad m, Data d, Typeable2 t)       => (forall e. Data e => e -> m e)       -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> m (t d1 d2))@@ -394,6 +685,8 @@   -- | Type extension of queries for type constructors+--+-- @since 0.3 ext2Q :: (Data d, Typeable2 t)       => (d -> q)       -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q)@@ -402,6 +695,8 @@   -- | Type extension of readers for type constructors+--+-- @since 0.3 ext2R :: (Monad m, Data d, Typeable2 t)       => m d       -> (forall d1 d2. (Data d1, Data d2) => m (t d1 d2))@@ -410,6 +705,8 @@   -- | Type extension of builders for type constructors+--+-- @since 0.3 ext2B :: (Data a, Typeable2 t)       => a       -> (forall d1 d2. (Data d1, Data d2) => (t d1 d2))
src/Data/Generics/Builders.hs view
@@ -6,7 +6,7 @@ -- Module      :  Data.Generics.Builders
 -- Copyright   :  (c) 2008 Universiteit Utrecht
 -- License     :  BSD-style
--- 
+--
 -- Maintainer  :  generics@haskell.org
 -- Stability   :  experimental
 -- Portability :  non-portable
@@ -22,6 +22,8 @@ 
 -- | Construct the empty value for a datatype. For algebraic datatypes, the
 -- leftmost constructor is chosen.
+--
+-- @since 0.2
 empty :: forall a. Data a => a
 empty = general 
       `extB` char 
@@ -43,6 +45,8 @@ 
 -- | Return a list of values of a datatype. Each value is one of the possible
 -- constructors of the datatype, populated with 'empty' values.
+--
+-- @since 0.2
 constrs :: forall a. Data a => [a]
 constrs = general
       `extB` char
src/Data/Generics/Schemes.hs view
@@ -48,7 +48,8 @@ import Control.Monad  -- | Apply a transformation everywhere in bottom-up manner-+--+-- @since 0.1.0.0 everywhere :: (forall a. Data a => a -> a)            -> (forall a. Data a => a -> a) @@ -62,6 +63,8 @@     go = f . gmapT go  -- | Apply a transformation everywhere in top-down manner+--+-- @since 0.1.0.0 everywhere' :: (forall a. Data a => a -> a)             -> (forall a. Data a => a -> a) @@ -73,6 +76,8 @@   -- | Variation on everywhere with an extra stop condition+--+-- @since 0.1.0.0 everywhereBut :: GenericQ Bool -> GenericT -> GenericT  -- Guarded to let traversal cease if predicate q holds for x@@ -85,6 +90,8 @@   -- | Monadic variation on everywhere+--+-- @since 0.1.0.0 everywhereM :: forall m. Monad m => GenericM m -> GenericM m  -- Bottom-up order is also reflected in order of do-actions@@ -97,6 +104,8 @@   -- | Apply a monadic transformation at least somewhere+--+-- @since 0.1.0.0 somewhere :: forall m. MonadPlus m => GenericM m -> GenericM m  -- We try "f" in top-down manner, but descent into "x" when we fail@@ -110,6 +119,8 @@   -- | Summarise all nodes in top-down, left-to-right order+--+-- @since 0.1.0.0 everything :: forall r. (r -> r -> r) -> GenericQ r -> GenericQ r  -- Apply f to x to summarise top-level node;@@ -122,6 +133,8 @@     go x = foldl k (f x) (gmapQ go x)  -- | Variation of "everything" with an added stop condition+--+-- @since 0.3 everythingBut :: forall r. (r -> r -> r) -> GenericQ (r, Bool) -> GenericQ r everythingBut k f = go   where@@ -133,6 +146,8 @@  -- | Summarise all nodes in top-down, left-to-right order, carrying some state -- down the tree during the computation, but not left-to-right to siblings.+--+-- @since 0.3.7 everythingWithContext :: forall s r. s -> (r -> r -> r) -> GenericQ (s -> (r, s)) -> GenericQ r everythingWithContext s0 f q = go s0   where@@ -141,11 +156,15 @@       where (r, s') = q x s  -- | Get a list of all entities that meet a predicate+--+-- @since 0.1.0.0 listify :: Typeable r => (r -> Bool) -> GenericQ [r] listify p = everything (++) ([] `mkQ` (\x -> if p x then [x] else []))   -- | Look up a subterm by means of a maybe-typed filter+--+-- @since 0.1.0.0 something :: GenericQ (Maybe u) -> GenericQ (Maybe u)  -- "something" can be defined in terms of "everything"@@ -159,6 +178,7 @@ --   2nd argument o is for reduction of results from subterms; --   3rd argument f updates the synthesised data according to the given term --+-- @since 0.1.0.0 synthesize :: forall s t. s  -> (t -> s -> s) -> GenericQ (s -> t) -> GenericQ t synthesize z o f = go   where@@ -167,36 +187,50 @@   -- | Compute size of an arbitrary data structure+--+-- @since 0.1.0.0 gsize :: Data a => a -> Int gsize t = 1 + sum (gmapQ gsize t)   -- | Count the number of immediate subterms of the given term+--+-- @since 0.1.0.0 glength :: GenericQ Int glength = length . gmapQ (const ())   -- | Determine depth of the given term+--+-- @since 0.1.0.0 gdepth :: GenericQ Int gdepth = (+) 1 . foldr max 0 . gmapQ gdepth   -- | Determine the number of all suitable nodes in a given term+--+-- @since 0.1.0.0 gcount :: GenericQ Bool -> GenericQ Int gcount p =  everything (+) (\x -> if p x then 1 else 0)   -- | Determine the number of all nodes in a given term+--+-- @since 0.1.0.0 gnodecount :: GenericQ Int gnodecount = gcount (const True)   -- | Determine the number of nodes of a given type in a given term+--+-- @since 0.1.0.0 gtypecount :: Typeable a => a -> GenericQ Int gtypecount (_::a) = gcount (False `mkQ` (\(_::a) -> True))   -- | Find (unambiguously) an immediate subterm of a given type+--+-- @since 0.1.0.0 gfindtype :: (Data x, Typeable y) => x -> Maybe y gfindtype = singleton           . foldl unJust []
src/Data/Generics/Text.hs view
@@ -40,10 +40,14 @@   -- | Generic show: an alternative to \"deriving Show\"+--+-- @since 0.1.0.0 gshow :: Data a => a -> String gshow x = gshows x ""  -- | Generic shows+--+-- @since 0.2 gshows :: Data a => a -> ShowS  -- This is a prefix-show using surrounding "(" and ")",@@ -57,6 +61,8 @@   -- | Generic read: an alternative to \"deriving Read\"+--+-- @since 0.1.0.0 gread :: Data a => ReadS a  {-
src/Data/Generics/Twins.hs view
@@ -82,7 +82,8 @@ --------------------------------------------------------------}  -- | gfoldl with accumulation-+--+-- @since 0.1.0.0 gfoldlAccum :: Data d             => (forall e r. Data e => a -> c (e -> r) -> e -> (a, c r))             -> (forall g. a -> g -> (a, c g))@@ -99,6 +100,8 @@   -- | gmapT with accumulation+--+-- @since 0.1.0.0 gmapAccumT :: Data d            => (forall e. Data e => a -> e -> (a,e))            -> a -> d -> (a, d)@@ -111,6 +114,8 @@   -- | Applicative version+--+-- @since 0.2 gmapAccumA :: forall b d a. (Data d, Applicative a)            => (forall e. Data e => b -> e -> (b, a e))            -> b -> d -> (b, a d)@@ -127,6 +132,8 @@   -- | gmapM with accumulation+--+-- @since 0.1.0.0 gmapAccumM :: (Data d, Monad m)            => (forall e. Data e => a -> e -> (a, m e))            -> a -> d -> (a, m d)@@ -138,6 +145,8 @@   -- | gmapQl with accumulation+--+-- @since 0.1.0.0 gmapAccumQl :: Data d             => (r -> r' -> r)             -> r@@ -152,6 +161,8 @@   -- | gmapQr with accumulation+--+-- @since 0.1.0.0 gmapAccumQr :: Data d             => (r' -> r -> r)             -> r@@ -166,6 +177,8 @@   -- | gmapQ with accumulation+--+-- @since 0.1.0.0 gmapAccumQ :: Data d            => (forall e. Data e => a -> e -> (a,q))            -> a -> d -> (a, [q])@@ -201,6 +214,8 @@   -- | Twin map for transformation+--+-- @since 0.1.0.0 gzipWithT :: GenericQ (GenericT) -> GenericQ (GenericT) gzipWithT f x y = case gmapAccumT perkid funs y of                     ([], c) -> c@@ -212,6 +227,8 @@   -- | Twin map for monadic transformation+--+-- @since 0.1.0.0 gzipWithM :: Monad m => GenericQ (GenericM m) -> GenericQ (GenericM m) gzipWithM f x y = case gmapAccumM perkid funs y of                     ([], c) -> c@@ -222,6 +239,8 @@   -- | Twin map for queries+--+-- @since 0.1.0.0 gzipWithQ :: GenericQ (GenericQ r) -> GenericQ (GenericQ [r]) gzipWithQ f x y = case gmapAccumQ perkid funs y of                    ([], r) -> r@@ -239,6 +258,8 @@ ------------------------------------------------------------------------------  -- | Generic equality: an alternative to \"deriving Eq\"+--+-- @since 0.1.0.0 geq :: Data a => a -> a -> Bool  {-@@ -264,6 +285,8 @@   -- | Generic zip controlled by a function with type-specific branches+--+-- @since 0.1.0.0 gzip :: GenericQ (GenericM Maybe) -> GenericQ (GenericM Maybe) -- See testsuite/.../Generics/gzip.hs for an illustration gzip f = go@@ -277,6 +300,8 @@         else Nothing  -- | Generic comparison: an alternative to \"deriving Ord\"+--+-- @since 0.5 gcompare :: Data a => a -> a -> Ordering gcompare = gcompare'   where
syb.cabal view
@@ -1,10 +1,10 @@ name:                 syb-version:              0.7.2.3+version:              0.7.2.4 license:              BSD3 license-file:         LICENSE author:               Ralf Lammel, Simon Peyton Jones, Jose Pedro Magalhaes maintainer:           Sergey Vinokurov <serg.foo@gmail.com>-homepage:             http://www.cs.uu.nl/wiki/GenericProgramming/SYB+homepage:             https://github.com/dreixel/syb bug-reports:          https://github.com/dreixel/syb/issues synopsis:             Scrap Your Boilerplate description: