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: although GenericBifunctor has Functor and Foldable instances, it is recommended to use GenericFunctor instead for those two classes. They have to use a separate deriving clause from Bifunctor and Bifoldable anyway. Those instances exist because they are to become superclasses of Bifunctor and Bifoldable. The Foldable instance of GenericBifunctor is also less efficient than GenericFunctor unless the extra const mempty gets optimized away.

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

GBifoldable f => Foldable (GenericBifunctor f a)

Defined in Generic.Functor.Internal

Methods

fold :: Monoid m => GenericBifunctor f a m -> m

foldMap :: Monoid m => (a0 -> m) -> GenericBifunctor f a a0 -> m

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

foldr :: (a0 -> b -> b) -> b -> GenericBifunctor f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> GenericBifunctor f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> GenericBifunctor f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> GenericBifunctor f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> GenericBifunctor f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> GenericBifunctor f a a0 -> a0

toList :: GenericBifunctor f a a0 -> [a0]

null :: GenericBifunctor f a a0 -> Bool

length :: GenericBifunctor f a a0 -> Int

elem :: Eq a0 => a0 -> GenericBifunctor f a a0 -> Bool

maximum :: Ord a0 => GenericBifunctor f a a0 -> a0

minimum :: Ord a0 => GenericBifunctor f a a0 -> a0

sum :: Num a0 => GenericBifunctor f a a0 -> a0

product :: Num a0 => GenericBifunctor f a a0 -> a0

GSecond f => Functor (GenericBifunctor f a)

Defined in Generic.Functor.Internal

Methods

fmap :: (a0 -> b) -> GenericBifunctor f a a0 -> GenericBifunctor f a b

(<$) :: a0 -> GenericBifunctor f a b -> GenericBifunctor f a a0

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