Data.Wrapped

Provides Wrapped and Wrapped1 types to hold DerivingVia instances.

Derived Instances

newtype Wrapped (c :: Type -> Constraint) a

A type holding derived instances for classes of kind Type -> Constraint.

For example, Show or Pretty.

Generally, instances derived from SomeClass should be placed on Wrapped SomeClass. This way, they can be grouped into relatively few deriving clauses per type.

Constructors

Wrapped

Fields

• unWrapped :: a

Instances

IsList a => IsList (Wrapped IsList a)

Just forwarding the instance; not meant to be used for deriving.

Defined in Data.Wrapped

Associated Types

type Item (Wrapped IsList a)

Methods

fromList :: [Item (Wrapped IsList a)] -> Wrapped IsList a

fromListN :: Int -> [Item (Wrapped IsList a)] -> Wrapped IsList a

toList :: Wrapped IsList a -> [Item (Wrapped IsList a)]

(IsList a, Eq (Item a)) => Eq (Wrapped IsList a)

Equality of the results of toList.

Defined in Data.Wrapped

Methods

(==) :: Wrapped IsList a -> Wrapped IsList a -> Bool

(/=) :: Wrapped IsList a -> Wrapped IsList a -> Bool

(IsList a, Ord (Item a)) => Ord (Wrapped IsList a)

Comparison of the results of toList.

Defined in Data.Wrapped

Methods

compare :: Wrapped IsList a -> Wrapped IsList a -> Ordering

(<) :: Wrapped IsList a -> Wrapped IsList a -> Bool

(<=) :: Wrapped IsList a -> Wrapped IsList a -> Bool

(>) :: Wrapped IsList a -> Wrapped IsList a -> Bool

(>=) :: Wrapped IsList a -> Wrapped IsList a -> Bool

max :: Wrapped IsList a -> Wrapped IsList a -> Wrapped IsList a

min :: Wrapped IsList a -> Wrapped IsList a -> Wrapped IsList a

(IsList a, Read (Item a)) => Read (Wrapped IsList a)

fromList of a parsed list.

Defined in Data.Wrapped

Methods

readsPrec :: Int -> ReadS (Wrapped IsList a)

readList :: ReadS [Wrapped IsList a]

readPrec :: ReadPrec (Wrapped IsList a)

readListPrec :: ReadPrec [Wrapped IsList a]

(IsList a, Show (Item a)) => Show (Wrapped IsList a)

Show of the results of toList.

Defined in Data.Wrapped

Methods

showsPrec :: Int -> Wrapped IsList a -> ShowS

show :: Wrapped IsList a -> String

showList :: [Wrapped IsList a] -> ShowS

(Generic a, GSemigroup (Rep a)) => Semigroup (Wrapped Generic a)

<> by field-wise <>.

Defined in Data.Wrapped

Methods

(<>) :: Wrapped Generic a -> Wrapped Generic a -> Wrapped Generic a

sconcat :: NonEmpty (Wrapped Generic a) -> Wrapped Generic a

stimes :: Integral b => b -> Wrapped Generic a -> Wrapped Generic a

(Generic a, GSemigroup (Rep a), GMonoid (Rep a)) => Monoid (Wrapped Generic a)

mappend by field-wise <>, and mempty by field-wise mempty

Beware: this determines the entire instance including mappend, so do not mix this with a Semigroup instance from another source.

Defined in Data.Wrapped

Methods

mempty :: Wrapped Generic a

mappend :: Wrapped Generic a -> Wrapped Generic a -> Wrapped Generic a

mconcat :: [Wrapped Generic a] -> Wrapped Generic a

type Item (Wrapped IsList a)

Defined in Data.Wrapped

type Item (Wrapped IsList a) = Item a

newtype Wrapped1 (c :: (k -> Type) -> Constraint) f (a :: k)

A type holding derived instances of kind (k -> Type) -> Constraint.

For example, Functor or Traversable.

See also Wrapped.

Constructors

Wrapped1

Fields

• unWrapped1 :: f a

Instances

Functor f => Functor (Wrapped1 (Generic1 :: (Type -> Type) -> Constraint) f)

Forwarding instance for Functor.

If we want Wrapped1 Generic1 f to have instances for things with Functor as a superclass, then it needs to have a Functor instance. There's not much point in providing a Generics-based one, though because DeriveFunctor exists. So, just forward the underlying type's instance.

Defined in Data.Wrapped

Methods

fmap :: (a -> b) -> Wrapped1 Generic1 f a -> Wrapped1 Generic1 f b

(<$) :: a -> Wrapped1 Generic1 f b -> Wrapped1 Generic1 f a

Foldable f => Foldable (Wrapped1 Foldable f)

Just forwarding the instance; not meant to be used for deriving.

Defined in Data.Wrapped

Methods

fold :: Monoid m => Wrapped1 Foldable f m -> m

foldMap :: Monoid m => (a -> m) -> Wrapped1 Foldable f a -> m

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

foldr :: (a -> b -> b) -> b -> Wrapped1 Foldable f a -> b

foldr' :: (a -> b -> b) -> b -> Wrapped1 Foldable f a -> b

foldl :: (b -> a -> b) -> b -> Wrapped1 Foldable f a -> b

foldl' :: (b -> a -> b) -> b -> Wrapped1 Foldable f a -> b

foldr1 :: (a -> a -> a) -> Wrapped1 Foldable f a -> a

foldl1 :: (a -> a -> a) -> Wrapped1 Foldable f a -> a

toList :: Wrapped1 Foldable f a -> [a]

null :: Wrapped1 Foldable f a -> Bool

length :: Wrapped1 Foldable f a -> Int

elem :: Eq a => a -> Wrapped1 Foldable f a -> Bool

maximum :: Ord a => Wrapped1 Foldable f a -> a

minimum :: Ord a => Wrapped1 Foldable f a -> a

sum :: Num a => Wrapped1 Foldable f a -> a

product :: Num a => Wrapped1 Foldable f a -> a

(Foldable f, Eq a) => Eq (Wrapped1 Foldable f a)

Equality of the results of toList.

Defined in Data.Wrapped

Methods

(==) :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Bool

(/=) :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Bool

(Foldable f, Ord a) => Ord (Wrapped1 Foldable f a)

Comparison of the results of toList.

Defined in Data.Wrapped

Methods

compare :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Ordering

(<) :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Bool

(<=) :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Bool

(>) :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Bool

(>=) :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Bool

max :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Wrapped1 Foldable f a

min :: Wrapped1 Foldable f a -> Wrapped1 Foldable f a -> Wrapped1 Foldable f a

(Foldable f, Show a) => Show (Wrapped1 Foldable f a)

Show of the results of toList.

Defined in Data.Wrapped

Methods

showsPrec :: Int -> Wrapped1 Foldable f a -> ShowS

show :: Wrapped1 Foldable f a -> String

showList :: [Wrapped1 Foldable f a] -> ShowS

(Applicative f, Semigroup a) => Semigroup (Wrapped1 Applicative f a)

Provide (<>) by liftA2 of an underlying (<>).

Defined in Data.Wrapped

Methods

(<>) :: Wrapped1 Applicative f a -> Wrapped1 Applicative f a -> Wrapped1 Applicative f a

sconcat :: NonEmpty (Wrapped1 Applicative f a) -> Wrapped1 Applicative f a

stimes :: Integral b => b -> Wrapped1 Applicative f a -> Wrapped1 Applicative f a

(Applicative f, Monoid m) => Monoid (Wrapped1 Applicative f m)

Provide mappend by liftA2 and mempty by pure mempty.

Defined in Data.Wrapped

Methods

mempty :: Wrapped1 Applicative f m

mappend :: Wrapped1 Applicative f m -> Wrapped1 Applicative f m -> Wrapped1 Applicative f m

mconcat :: [Wrapped1 Applicative f m] -> Wrapped1 Applicative f m

Wrapped Generic

Instances of Wrapped Generic work on Rep types by to and from.

Typically these implement the "obvious" way to make a sum-of-products type (an algebraic data type) an instance of the given class. For example, for Monoid, it provides field-wise mappend and mempty of types that are products of other Monoids.

Likewise, Wrapped1 Generic1 works on Rep1 types by to1 and from1. This is the same concept applied to type constructors with one parameter.

class GSemigroup f where

Generic Semigroup.

Exported just to give Haddock something to link to; use Wrapped Generic with -XDerivingVia instead.

Methods

gsop :: f x -> f x -> f x

Instances

GSemigroup (U1 :: k -> Type)

Defined in Data.Wrapped

Methods

gsop :: forall (x :: k0). U1 x -> U1 x -> U1 x

Semigroup a => GSemigroup (K1 i a :: k -> Type)

Defined in Data.Wrapped

Methods

gsop :: forall (x :: k0). K1 i a x -> K1 i a x -> K1 i a x

(GSemigroup f, GSemigroup g) => GSemigroup (f :*: g :: k -> Type)

Defined in Data.Wrapped

Methods

gsop :: forall (x :: k0). (f :*: g) x -> (f :*: g) x -> (f :*: g) x

GSemigroup a => GSemigroup (M1 i c a :: k -> Type)

Defined in Data.Wrapped

Methods

gsop :: forall (x :: k0). M1 i c a x -> M1 i c a x -> M1 i c a x

class GMonoid f where

Generic Monoid.

Exported just to give Haddock something to link to; use Wrapped Generic with -XDerivingVia instead.

Methods

gmempty :: f x

Instances

GMonoid (U1 :: k -> Type)

Defined in Data.Wrapped

Methods

gmempty :: forall (x :: k0). U1 x

Monoid a => GMonoid (K1 i a :: k -> Type)

Defined in Data.Wrapped

Methods

gmempty :: forall (x :: k0). K1 i a x

(GMonoid f, GMonoid g) => GMonoid (f :*: g :: k -> Type)

Defined in Data.Wrapped

Methods

gmempty :: forall (x :: k0). (f :*: g) x

GMonoid f => GMonoid (M1 i m f :: k -> Type)

Defined in Data.Wrapped

Methods

gmempty :: forall (x :: k0). M1 i m f x

Wrapped IsList

Instances of Wrapped IsList work by conversion to/from list.

For example, we provide Eq, Ord, and Show instances that convert both operands to lists and compare them, and a Read instance that parses a list and converts to the desired type.

Whereas Wrapped Foldable requires that the type is a type constructor whose argument is the list element, this works on any type with an IsList instance.

On the other hand, IsList requires that the type can be converted from a list, not only to a list, so it can often require unneeded constraints compared to Foldable.

Generally, if both of these compile, they should be expected to be equivalent. More specifically, if you implement instances for Wrapped Foldable or Wrapped IsList these types, you should ensure that, as long as the Foldable instance of f and the IsList instance of f a are consistent, the instances are the same; and if you adopt instances from this type, you should ensure that your Foldable and IsList instances agree, and may then assume that IsList and Foldable give the same instances.

Instances of Wrapped Foldable work by folding over the type.

See above for a description of how this differs from Wrapped IsList.