Generic.Functor

Generic functors, foldables, and traversables.

Derive functors

Derive Functor, Bifunctor, Foldable, Traversable

DerivingVia

The type synonyms GenericFunctor and GenericBifunctor can be used with the DerivingVia extension to derive Functor, Bifunctor, and Foldable. Sadly, Traversable cannot be derived-via.

newtype GenericFunctor f a

newtype for DerivingVia of Functor and Foldable instances.

Note: the GHC extensions DeriveFunctor, DeriveFoldable, and DeriveTraversable (which implies all three) already works out-of-the-box in most cases. There are exceptions, such as the following example.

Example

{-# LANGUAGE DeriveGeneric, DerivingVia #-}

import GHC.Generics (Generic)
import Generic.Functor (GenericFunctor(..))

data Twice a = Twice (Either a a)
  deriving Generic
  deriving (Functor, Foldable) via (GenericFunctor Twice)

Constructors

GenericFunctor (f a)

Instances

GFoldable f => Foldable (GenericFunctor f)

Defined in Generic.Functor.Internal

Methods

fold :: Monoid m => GenericFunctor f m -> m

foldMap :: Monoid m => (a -> m) -> GenericFunctor f a -> m

foldMap' :: Monoid m => (a -> m) -> GenericFunctor f a -> m

foldr :: (a -> b -> b) -> b -> GenericFunctor f a -> b

foldr' :: (a -> b -> b) -> b -> GenericFunctor f a -> b

foldl :: (b -> a -> b) -> b -> GenericFunctor f a -> b

foldl' :: (b -> a -> b) -> b -> GenericFunctor f a -> b

foldr1 :: (a -> a -> a) -> GenericFunctor f a -> a

foldl1 :: (a -> a -> a) -> GenericFunctor f a -> a

toList :: GenericFunctor f a -> [a]

null :: GenericFunctor f a -> Bool

length :: GenericFunctor f a -> Int

elem :: Eq a => a -> GenericFunctor f a -> Bool

maximum :: Ord a => GenericFunctor f a -> a

minimum :: Ord a => GenericFunctor f a -> a

sum :: Num a => GenericFunctor f a -> a

product :: Num a => GenericFunctor f a -> a

GFunctor f => Functor (GenericFunctor f)

Defined in Generic.Functor.Internal

Methods

fmap :: (a -> b) -> GenericFunctor f a -> GenericFunctor f b

(<$) :: a -> GenericFunctor f b -> GenericFunctor f a

newtype GenericBifunctor f a b

newtype for DerivingVia of Bifunctor and Bifoldable instances.

Note: deriving Bifunctor for a generic type often requires Functor instances for types mentioned in the fields.

Example

{-# LANGUAGE DeriveGeneric, DerivingVia #-}

import Data.Bifoldable (Bifoldable)
import Data.Bifunctor (Bifunctor)
import GHC.Generics (Generic)
import Generic.Functor (GenericFunctor(..), GenericBifunctor(..))

data Tree a b = Node a (Tree a b) (Tree a b) | Leaf b
  deriving Generic
  deriving (Functor, Foldable) via (GenericFunctor (Tree a))
  deriving (Bifunctor, Bifoldable) via (GenericBifunctor Tree)

data CofreeF f a b = a :< f b
  deriving Generic
  deriving (Bifunctor, Bifoldable) via (GenericBifunctor (CofreeF f))

Constructors

GenericBifunctor (f a b)

Instances

GBifoldable f => Bifoldable (GenericBifunctor f)

Defined in Generic.Functor.Internal

Methods

bifold :: Monoid m => GenericBifunctor f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> GenericBifunctor f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> GenericBifunctor f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> GenericBifunctor f a b -> c

GBifunctor f => Bifunctor (GenericBifunctor f)

Defined in Generic.Functor.Internal

Methods

bimap :: (a -> b) -> (c -> d) -> GenericBifunctor f a c -> GenericBifunctor f b d

first :: (a -> b) -> GenericBifunctor f a c -> GenericBifunctor f b c

second :: (b -> c) -> GenericBifunctor f a b -> GenericBifunctor f a c

Generic method definitions

gfmap :: forall f a b. GFunctor f => (a -> b) -> f a -> f b

Generic implementation of fmap. See also GenericFunctor for DerivingVia, using gfmap under the hood.

Example

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic)
import Generic.Functor (gfmap)

data Twice a = Twice (Either a a)
  deriving Generic

instance Functor Twice where
  fmap = gfmap

Unlike gsolomap, gfmap is safe to use in all contexts.

gfoldMap :: forall t m a. (GFoldMap m t, Monoid m) => (a -> m) -> t a -> m

Generic implementation of foldMap from Foldable.

gtraverse :: forall t f a b. (GTraverse f t, Applicative f) => (a -> f b) -> t a -> f (t b)

Generic implementation of traverse from Traversable.

Bifunctors

gbimap :: forall f a b c d. GBimap f => (a -> b) -> (c -> d) -> f a c -> f b d

Generic implementation of bimap from Bifunctor. See also GenericBifunctor.

gfirst :: forall f a b c. GFirst f => (a -> b) -> f a c -> f b c

Generic implementation of first from Bifunctor. See also GenericBifunctor.

gsecond :: forall f a c d. GSecond f => (c -> d) -> f a c -> f a d

Generic implementation of second from Bifunctor. See also GenericBifunctor.

gbifoldMap :: forall t m a b. (GBifoldMap m t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m

Generic implementation of bifoldMap from Bifoldable.

gbitraverse :: forall t f a b c d. (GBitraverse f t, Applicative f) => (a -> f b) -> (c -> f d) -> t a c -> f (t b d)

Generic implementation of bitraverse from Bitraversable.

Auxiliary classes

Related to standard classes

class (forall a. Generic (f a), forall a b. GFunctorRep a b f) => GFunctor f

Generic Functor. Constraint for gfmap.

Instances

(forall a. Generic (f a), forall a b. GFunctorRep a b f) => GFunctor f

Defined in Generic.Functor.Internal

class (forall m. Monoid m => GFoldMap m t) => GFoldable t

Generic Foldable. Constraint for GenericFunctor (deriving-via Foldable).

Instances

(forall m. Monoid m => GFoldMap m t) => GFoldable t

Defined in Generic.Functor.Internal

class (forall a. Generic (t a), forall a b. GFoldMapRep a b m t) => GFoldMap m t

Constraint for gfoldMap.

Instances

(forall a. Generic (t a), forall a b. GFoldMapRep a b m t) => GFoldMap m t

Defined in Generic.Functor.Internal

class (forall f. Applicative f => GBitraverse f t) => GTraversable t

Generic Traversable.

Instances

(forall (f :: Type -> Type). Applicative f => GBitraverse f t) => GTraversable t

Defined in Generic.Functor.Internal

class (forall a. Generic (t a), forall a b. GTraverseRep a b f t) => GTraverse f t

Constraint for gtraverse.

Instances

(forall a. Generic (t a), forall a b. GTraverseRep a b f t) => GTraverse f t

Defined in Generic.Functor.Internal

Bifunctors

class (GBimap f, GFirst f, GSecond f) => GBifunctor f

Generic Bifunctor.

Instances

(GBimap f, GFirst f, GSecond f) => GBifunctor f

Defined in Generic.Functor.Internal

class (forall a c. Generic (f a c), forall a b c d. GBimapRep a b c d f) => GBimap f

Constraint for gbimap.

Instances

(forall a c. Generic (f a c), forall a b c d. GBimapRep a b c d f) => GBimap f

Defined in Generic.Functor.Internal

class (forall a c. Generic (f a c), forall a b c. GFirstRep a b c f) => GFirst f

Constraint for gfirst.

Instances

(forall a c. Generic (f a c), forall a b c. GFirstRep a b c f) => GFirst f

Defined in Generic.Functor.Internal

class (forall a c. Generic (f a c), forall a c d. GFunctorRep c d (f a)) => GSecond f

Constraint for gsecond.

Instances

(forall a c. Generic (f a c), forall a c d. GFunctorRep c d (f a)) => GSecond f

Defined in Generic.Functor.Internal

class (forall m. Monoid m => GBifoldMap m t) => GBifoldable t

Generic Foldable. Constraint for GenericFunctor (deriving-via Foldable).

Instances

(forall m. Monoid m => GBifoldMap m t) => GBifoldable t

Defined in Generic.Functor.Internal

class (forall a b. Generic (t a b), forall a b c d. GBifoldMapRep a b c d m t) => GBifoldMap m t

Constraint for gbifoldMap.

Instances

(forall a b. Generic (t a b), forall a b c d. GBifoldMapRep a b c d m t) => GBifoldMap m t

Defined in Generic.Functor.Internal

class (forall f. Applicative f => GBitraverse f t) => GBitraversable t

Generic Bitraversable.

Instances

(forall (f :: Type -> Type). Applicative f => GBitraverse f t) => GBitraversable t

Defined in Generic.Functor.Internal

class (forall a b. Generic (t a b), forall a b c d. GBitraverseRep a b c d f t) => GBitraverse f t

Constraint for gtraverse.

Instances

(forall a b. Generic (t a b), forall a b c d. GBitraverseRep a b c d f t) => GBitraverse f t

Defined in Generic.Functor.Internal