Data.Barbie

A common Haskell idiom is to parameterise a datatype by a type k -> *, typically a functor or a GADT. These are like outfits of a Barbie, that turn her into a different doll. E.g.

data Barbie f
  = Barbie
      { name :: f String
      , age  :: f Int
      }

b1 :: Barbie Last       -- Barbie with a monoid structure
b2 :: Barbie (Const a)  -- Container Barbie
b3 :: Barbie Identity   -- Barbie's new clothes

This module define the classes to work with these types and easily transform them. They all come with default instances based on Generic, so using them is as easy as:

data Barbie f
  = Barbie
      { name :: f String
      , age  :: f Int
      }
  deriving
    ( Generic
    , FunctorB, TraversableB, ProductB, ConstraintsB, ProductBC
    )

deriving instance AllBF Show f Barbie => Show (Barbie f)
deriving instance AllBF Eq   f Barbie => Eq   (Barbie f)

Sometimes one wants to use Barbie Identity and it may feel like a second-class record type, where one needs to unpack values in each field. Data.Barbie.Bare offers a way to have bare versions of a barbie-type.

Notice that all classes in this package are poly-kinded. Intuitively, a barbie is a type parameterised by a functor, and because a barbies is a type of functor, a type parameterised by a barbie is a (higher-kinded) barbie too:

data Catalog b
  = Catalog (b Identity) (b Maybe)
  deriving
    (Generic
    , FunctorB, TraversableB, ProductB, ConstraintsB, ProductBC
    )

Functor

class FunctorB (b :: (k -> Type) -> Type) where

Barbie-types that can be mapped over. Instances of FunctorB should satisfy the following laws:

  bmap id = id
  bmap f . bmap g = bmap (f . g)

There is a default bmap implementation for Generic types, so instances can derived automatically.

Minimal complete definition

Nothing

Methods

bmap :: (forall a. f a -> g a) -> b f -> b g

bmap :: forall f g. CanDeriveFunctorB b f g => (forall a. f a -> g a) -> b f -> b g

Instances

FunctorB (Proxy :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Functor

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Proxy f -> Proxy g

FunctorB (Void :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Void f -> Void g

FunctorB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Unit f -> Unit g

FunctorB (Const x :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Functor

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Const x f -> Const x g

FunctorB b => FunctorB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Barbie b f -> Barbie b g

(FunctorB a, FunctorB b) => FunctorB (Sum a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Functor

Methods

bmap :: (forall (a0 :: k0). f a0 -> g a0) -> Sum a b f -> Sum a b g

(FunctorB a, FunctorB b) => FunctorB (Product a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Functor

Methods

bmap :: (forall (a0 :: k0). f a0 -> g a0) -> Product a b f -> Product a b g

(Functor f, FunctorB b) => FunctorB (Compose f b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Functor

Methods

bmap :: (forall (a :: k0). f0 a -> g a) -> Compose f b f0 -> Compose f b g

Traversable

class FunctorB b => TraversableB (b :: (k -> Type) -> Type) where

Barbie-types that can be traversed from left to right. Instances should satisfy the following laws:

 t . btraverse f   = btraverse (t . f)  -- naturality
btraverse Identity = Identity           -- identity
btraverse (Compose . fmap g . f) = Compose . fmap (btraverse g) . btraverse f -- composition

There is a default btraverse implementation for Generic types, so instances can derived automatically.

Minimal complete definition

Nothing

Methods

btraverse :: Applicative t => (forall a. f a -> t (g a)) -> b f -> t (b g)

btraverse :: (Applicative t, CanDeriveTraversableB b f g) => (forall a. f a -> t (g a)) -> b f -> t (b g)

Instances

TraversableB (Proxy :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Traversable

Methods

btraverse :: Applicative t => (forall (a :: k0). f a -> t (g a)) -> Proxy f -> t (Proxy g)

TraversableB (Void :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

btraverse :: Applicative t => (forall (a :: k0). f a -> t (g a)) -> Void f -> t (Void g)

TraversableB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

btraverse :: Applicative t => (forall (a :: k0). f a -> t (g a)) -> Unit f -> t (Unit g)

TraversableB (Const a :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Traversable

Methods

btraverse :: Applicative t => (forall (a0 :: k0). f a0 -> t (g a0)) -> Const a f -> t (Const a g)

TraversableB b => TraversableB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

btraverse :: Applicative t => (forall (a :: k0). f a -> t (g a)) -> Barbie b f -> t (Barbie b g)

(TraversableB a, TraversableB b) => TraversableB (Sum a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Traversable

Methods

btraverse :: Applicative t => (forall (a0 :: k0). f a0 -> t (g a0)) -> Sum a b f -> t (Sum a b g)

(TraversableB a, TraversableB b) => TraversableB (Product a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Traversable

Methods

btraverse :: Applicative t => (forall (a0 :: k0). f a0 -> t (g a0)) -> Product a b f -> t (Product a b g)

(Traversable f, TraversableB b) => TraversableB (Compose f b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Traversable

Methods

btraverse :: Applicative t => (forall (a :: k0). f0 a -> t (g a)) -> Compose f b f0 -> t (Compose f b g)

Utility functions

btraverse_ :: (TraversableB b, Applicative t) => (forall a. f a -> t c) -> b f -> t ()

Map each element to an action, evaluate these actions from left to right, and ignore the results.

bfoldMap :: (TraversableB b, Monoid m) => (forall a. f a -> m) -> b f -> m

Map each element to a monoid, and combine the results.

bsequence :: (Applicative f, TraversableB b) => b (Compose f g) -> f (b g)

Evaluate each action in the structure from left to right, and collect the results.

bsequence' :: (Applicative f, TraversableB b) => b f -> f (b Identity)

A version of bsequence with g specialized to Identity.

Product

class FunctorB b => ProductB (b :: (k -> Type) -> Type) where

Barbie-types that can form products, subject to the laws:

bmap (\(Pair a _) -> a) . uncurry bprod = fst
bmap (\(Pair _ b) -> b) . uncurry bprod = snd

Notice that because of the laws, having an internal product structure is not enough to have a lawful instance. E.g.

data Ok  f = Ok {o1 :: f String, o2 :: f Int}
data Bad f = Bad{b1 :: f String, hiddenFromArg: Int} -- no lawful instance

Intuitively, the laws for this class require that b hides no structure from its argument f. Because of this, if we are given any:

x :: forall a . f a

then this determines a unique value of type b f, witnessed by the buniq method. For example:

buniq x = Ok {o1 = x, o2 = x}

Formally, buniq should satisfy:

const (buniq x) = bmap (const x)

There is a default implementation of bprod and buniq for Generic types, so instances can derived automatically.

Minimal complete definition

Nothing

Methods

bprod :: b f -> b g -> b (f `Product` g)

buniq :: (forall a. f a) -> b f

bprod :: CanDeriveProductB b f g => b f -> b g -> b (f `Product` g)

buniq :: CanDeriveProductB b f f => (forall a. f a) -> b f

Instances

ProductB (Proxy :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Product

Methods

bprod :: Proxy f -> Proxy g -> Proxy (Product f g)

buniq :: (forall (a :: k0). f a) -> Proxy f

ProductB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bprod :: Unit f -> Unit g -> Unit (Product f g)

buniq :: (forall (a :: k0). f a) -> Unit f

ProductB b => ProductB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

bprod :: Barbie b f -> Barbie b g -> Barbie b (Product f g)

buniq :: (forall (a :: k0). f a) -> Barbie b f

(ProductB a, ProductB b) => ProductB (Product a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Product

Methods

bprod :: Product a b f -> Product a b g -> Product a b (Product f g)

buniq :: (forall (a0 :: k0). f a0) -> Product a b f

Utility functions

bzip :: ProductB b => b f -> b g -> b (f `Product` g)

An alias of bprod, since this is like a zip for Barbie-types.

bunzip :: ProductB b => b (f `Product` g) -> (b f, b g)

An equivalent of unzip for Barbie-types.

bzipWith :: ProductB b => (forall a. f a -> g a -> h a) -> b f -> b g -> b h

An equivalent of zipWith for Barbie-types.

bzipWith3 :: ProductB b => (forall a. f a -> g a -> h a -> i a) -> b f -> b g -> b h -> b i

An equivalent of zipWith3 for Barbie-types.

bzipWith4 :: ProductB b => (forall a. f a -> g a -> h a -> i a -> j a) -> b f -> b g -> b h -> b i -> b j

An equivalent of zipWith4 for Barbie-types.

Applicative-like interface

(/*/) :: ProductB b => b f -> b g -> b (Prod '[f, g]) infixr 4

Like bprod, but returns a binary Prod, instead of Product, which composes better.

See /*/ for usage.

(/*) :: ProductB b => b f -> b (Prod fs) -> b (Prod (f ': fs)) infixr 4

Similar to /*/ but one of the sides is already a Prod fs.

Note that /*, /*/ and uncurryn are meant to be used together: /* and /*/ combine b f1, b f2...b fn into a single product that can then be consumed by using uncurryn on an n-ary function. E.g.

f :: f a -> g a -> h a -> i a

bmap (uncurryn f) (bf /* bg /*/ bh)

Constraints and instance dictionaries

class FunctorB b => ConstraintsB (b :: (k -> *) -> *) where

Instances of this class provide means to talk about constraints, both at compile-time, using AllB, and at run-time, in the form of Dict, via baddDicts.

A manual definition would look like this:

data T f = A (f Int) (f String) | B (f Bool) (f Int)

instance ConstraintsB T where
  type AllB c T = (c Int, c String, c Bool)

  baddDicts t = case t of
    A x y -> A (Pair Dict x) (Pair Dict y)
    B z w -> B (Pair Dict z) (Pair Dict w)

Now if we given a T f, we need to use the Show instance of their fields, we can use:

baddDicts :: AllB Show b => b f -> b (Dict Show Product b)

There is a default implementation of ConstraintsB for Generic types, so in practice one will simply do:

derive instance Generic (T f)
instance ConstraintsB T

Minimal complete definition

Nothing

Associated Types

type AllB (c :: k -> Constraint) b :: Constraint

AllB c b should contain a constraint c a for each a occurring under an f in b f. E.g.:

AllB Show Barbie ~ (Show String, Show Int)

For requiring constraints of the form c (f a), use AllBF.

Methods

baddDicts :: forall c f. AllB c b => b f -> b (Dict c `Product` f)

baddDicts :: forall c f. (CanDeriveConstraintsB c b f, AllB c b) => b f -> b (Dict c `Product` f)

Instances

ConstraintsB (Proxy :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Constraints

Associated Types

type AllB c Proxy :: Constraint

Methods

baddDicts :: AllB c Proxy => Proxy f -> Proxy (Product (Dict c) f)

ConstraintsB (Void :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Associated Types

type AllB c Void :: Constraint

Methods

baddDicts :: AllB c Void => Void f -> Void (Product (Dict c) f)

ConstraintsB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Associated Types

type AllB c Unit :: Constraint

Methods

baddDicts :: AllB c Unit => Unit f -> Unit (Product (Dict c) f)

ConstraintsB (Const a :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Constraints

Associated Types

type AllB c (Const a) :: Constraint

Methods

baddDicts :: AllB c (Const a) => Const a f -> Const a (Product (Dict c) f)

ConstraintsB b => ConstraintsB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Associated Types

type AllB c (Barbie b) :: Constraint

Methods

baddDicts :: AllB c (Barbie b) => Barbie b f -> Barbie b (Product (Dict c) f)

(ConstraintsB a, ConstraintsB b) => ConstraintsB (Sum a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Constraints

Associated Types

type AllB c (Sum a b) :: Constraint

Methods

baddDicts :: AllB c (Sum a b) => Sum a b f -> Sum a b (Product (Dict c) f)

(ConstraintsB a, ConstraintsB b) => ConstraintsB (Product a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Constraints

Associated Types

type AllB c (Product a b) :: Constraint

Methods

baddDicts :: AllB c (Product a b) => Product a b f -> Product a b (Product (Dict c) f)

(Functor f, ConstraintsB b) => ConstraintsB (Compose f b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Constraints

Associated Types

type AllB c (Compose f b) :: Constraint

Methods

baddDicts :: AllB c (Compose f b) => Compose f b f0 -> Compose f b (Product (Dict c) f0)

type AllBF c f b = AllB (ClassF c f) b

Similar to AllB but will put the functor argument f between the constraint c and the type a. For example:

  AllB  Show   Barbie ~ (Show    String,  Show    Int)
  AllBF Show f Barbie ~ (Show (f String), Show (f Int))
  

Utility functions

bmapC :: forall c b f g. (AllB c b, ConstraintsB b) => (forall a. c a => f a -> g a) -> b f -> b g

Like bmap but a constraint is allowed to be required on each element of b

E.g. If all fields of b are Showable then you could store each shown value in it's slot using Const:

showFields :: (AllB Show b, ConstraintsB b) => b Identity -> b (Const String)
showFields = bmapC @Show showField
  where
    showField :: forall a. Show a => Identity a -> Const String a
    showField (Identity a) = Const (show a)

btraverseC :: forall c b f g h. (TraversableB b, ConstraintsB b, AllB c b, Applicative g) => (forall a. c a => f a -> g (h a)) -> b f -> g (b h)

Like btraverse but with a constraint on the elements of b.

Products and constaints

class (ConstraintsB b, ProductB b) => ProductBC (b :: (k -> Type) -> Type) where

Every type b that is an instance of both ProductB and ConstraintsB can be made an instance of ProductBC as well.

Intuitively, in addition to buniq from ProductB, one can define buniqC that takes into account constraints:

buniq :: (forall a . f a) -> b f
buniqC :: AllB c b => (forall a . c a => f a) -> b f

For technical reasons, buniqC is not currently provided as a method of this class and is instead defined in terms bdicts, which is similar to baddDicts but can produce the instance dictionaries out-of-the-blue. bdicts could also be defined in terms of buniqC, so they are essentially equivalent.

bdicts :: forall c b . AllB c b => b (Dict c)
bdicts = buniqC (Dict @c)

There is a default implementation for Generic types, so instances can derived automatically.

Minimal complete definition

Nothing

Methods

bdicts :: AllB c b => b (Dict c)

bdicts :: (CanDeriveProductBC c b, AllB c b) => b (Dict c)

Instances

ProductBC (Proxy :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.ProductC

Methods

bdicts :: AllB c Proxy => Proxy (Dict c)

ProductBC (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bdicts :: AllB c Unit => Unit (Dict c)

ProductBC b => ProductBC (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

bdicts :: AllB c (Barbie b) => Barbie b (Dict c)

(ProductBC a, ProductBC b) => ProductBC (Product a b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.ProductC

Methods

bdicts :: AllB c (Product a b) => Product a b (Dict c)

Utility functions

buniqC :: forall c f b. (AllB c b, ProductBC b) => (forall a. c a => f a) -> b f

Like buniq but a constraint is allowed to be required on each element of b.

bmempty :: forall f b. (AllBF Monoid f b, ProductBC b) => b f

Builds a b f, by applying mempty on every field of b.

Wrapper

newtype Barbie (b :: (k -> Type) -> Type) f

A wrapper for Barbie-types, providing useful instances.

Constructors

Barbie

Fields

• getBarbie :: b f

Instances

FunctorB b => FunctorB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Barbie b f -> Barbie b g

TraversableB b => TraversableB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

btraverse :: Applicative t => (forall (a :: k0). f a -> t (g a)) -> Barbie b f -> t (Barbie b g)

ProductB b => ProductB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

bprod :: Barbie b f -> Barbie b g -> Barbie b (Product f g)

buniq :: (forall (a :: k0). f a) -> Barbie b f

ConstraintsB b => ConstraintsB (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Associated Types

type AllB c (Barbie b) :: Constraint

Methods

baddDicts :: AllB c (Barbie b) => Barbie b f -> Barbie b (Product (Dict c) f)

ProductBC b => ProductBC (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

Methods

bdicts :: AllB c (Barbie b) => Barbie b (Dict c)

(ProductBC b, AllBF Semigroup f b) => Semigroup (Barbie b f)

Defined in Data.Barbie.Internal.Instances

Methods

(<>) :: Barbie b f -> Barbie b f -> Barbie b f

sconcat :: NonEmpty (Barbie b f) -> Barbie b f

stimes :: Integral b0 => b0 -> Barbie b f -> Barbie b f

(ProductBC b, AllBF Semigroup f b, AllBF Monoid f b) => Monoid (Barbie b f)

Defined in Data.Barbie.Internal.Instances

Methods

mempty :: Barbie b f

mappend :: Barbie b f -> Barbie b f -> Barbie b f

mconcat :: [Barbie b f] -> Barbie b f

type AllB (c :: k -> Constraint) (Barbie b :: (k -> Type) -> Type)

Defined in Data.Barbie.Internal.Instances

type AllB (c :: k -> Constraint) (Barbie b :: (k -> Type) -> Type) = AllB c b

Trivial Barbies

data Void (f :: k -> Type)

Uninhabited barbie type.

Instances

FunctorB (Void :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Void f -> Void g

TraversableB (Void :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

btraverse :: Applicative t => (forall (a :: k0). f a -> t (g a)) -> Void f -> t (Void g)

ConstraintsB (Void :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Associated Types

type AllB c Void :: Constraint

Methods

baddDicts :: AllB c Void => Void f -> Void (Product (Dict c) f)

Eq (Void f)

Defined in Data.Barbie.Trivial

Methods

(==) :: Void f -> Void f -> Bool

(/=) :: Void f -> Void f -> Bool

Ord (Void f)

Defined in Data.Barbie.Trivial

Methods

compare :: Void f -> Void f -> Ordering

(<) :: Void f -> Void f -> Bool

(<=) :: Void f -> Void f -> Bool

(>) :: Void f -> Void f -> Bool

(>=) :: Void f -> Void f -> Bool

max :: Void f -> Void f -> Void f

min :: Void f -> Void f -> Void f

Show (Void f)

Defined in Data.Barbie.Trivial

Methods

showsPrec :: Int -> Void f -> ShowS

show :: Void f -> String

showList :: [Void f] -> ShowS

Generic (Void f)

Defined in Data.Barbie.Trivial

Associated Types

type Rep (Void f) :: Type -> Type

Methods

from :: Void f -> Rep (Void f) x

to :: Rep (Void f) x -> Void f

Semigroup (Void f)

Defined in Data.Barbie.Trivial

Methods

(<>) :: Void f -> Void f -> Void f

sconcat :: NonEmpty (Void f) -> Void f

stimes :: Integral b => b -> Void f -> Void f

type AllB (c :: k -> Constraint) (Void :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

type AllB (c :: k -> Constraint) (Void :: (k -> Type) -> Type) = GAllB c (GAllBRep (Void :: (k -> Type) -> Type))

type Rep (Void f)

Defined in Data.Barbie.Trivial

type Rep (Void f) = D1 (MetaData "Void" "Data.Barbie.Trivial" "barbies-1.1.3.0-CMVVqlu4ofTCwkhij0xzhp" False) (V1 :: Type -> Type)

data Unit (f :: k -> Type)

A barbie type without structure.

Constructors

Unit

Instances

FunctorB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bmap :: (forall (a :: k0). f a -> g a) -> Unit f -> Unit g

TraversableB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

btraverse :: Applicative t => (forall (a :: k0). f a -> t (g a)) -> Unit f -> t (Unit g)

ProductB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bprod :: Unit f -> Unit g -> Unit (Product f g)

buniq :: (forall (a :: k0). f a) -> Unit f

ConstraintsB (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Associated Types

type AllB c Unit :: Constraint

Methods

baddDicts :: AllB c Unit => Unit f -> Unit (Product (Dict c) f)

ProductBC (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

Methods

bdicts :: AllB c Unit => Unit (Dict c)

Eq (Unit f)

Defined in Data.Barbie.Trivial

Methods

(==) :: Unit f -> Unit f -> Bool

(/=) :: Unit f -> Unit f -> Bool

(Typeable f, Typeable k) => Data (Unit f)

Defined in Data.Barbie.Trivial

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unit f -> c (Unit f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Unit f)

toConstr :: Unit f -> Constr

dataTypeOf :: Unit f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Unit f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Unit f))

gmapT :: (forall b. Data b => b -> b) -> Unit f -> Unit f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit f -> r

gmapQ :: (forall d. Data d => d -> u) -> Unit f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Unit f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unit f -> m (Unit f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit f -> m (Unit f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit f -> m (Unit f)

Ord (Unit f)

Defined in Data.Barbie.Trivial

Methods

compare :: Unit f -> Unit f -> Ordering

(<) :: Unit f -> Unit f -> Bool

(<=) :: Unit f -> Unit f -> Bool

(>) :: Unit f -> Unit f -> Bool

(>=) :: Unit f -> Unit f -> Bool

max :: Unit f -> Unit f -> Unit f

min :: Unit f -> Unit f -> Unit f

Read (Unit f)

Defined in Data.Barbie.Trivial

Methods

readsPrec :: Int -> ReadS (Unit f)

readList :: ReadS [Unit f]

readPrec :: ReadPrec (Unit f)

readListPrec :: ReadPrec [Unit f]

Show (Unit f)

Defined in Data.Barbie.Trivial

Methods

showsPrec :: Int -> Unit f -> ShowS

show :: Unit f -> String

showList :: [Unit f] -> ShowS

Generic (Unit f)

Defined in Data.Barbie.Trivial

Associated Types

type Rep (Unit f) :: Type -> Type

Methods

from :: Unit f -> Rep (Unit f) x

to :: Rep (Unit f) x -> Unit f

Semigroup (Unit f)

Defined in Data.Barbie.Trivial

Methods

(<>) :: Unit f -> Unit f -> Unit f

sconcat :: NonEmpty (Unit f) -> Unit f

stimes :: Integral b => b -> Unit f -> Unit f

Monoid (Unit f)

Defined in Data.Barbie.Trivial

Methods

mempty :: Unit f

mappend :: Unit f -> Unit f -> Unit f

mconcat :: [Unit f] -> Unit f

type AllB (c :: k -> Constraint) (Unit :: (k -> Type) -> Type)

Defined in Data.Barbie.Trivial

type AllB (c :: k -> Constraint) (Unit :: (k -> Type) -> Type) = GAllB c (GAllBRep (Unit :: (k -> Type) -> Type))

type Rep (Unit f)

Defined in Data.Barbie.Trivial

type Rep (Unit f) = D1 (MetaData "Unit" "Data.Barbie.Trivial" "barbies-1.1.3.0-CMVVqlu4ofTCwkhij0xzhp" False) (C1 (MetaCons "Unit" PrefixI False) (U1 :: Type -> Type))

Generic derivations

newtype Rec (p :: Type) a x

Constructors

Rec

Fields

• unRec :: K1 R a x

Instances

GConstraintsB (c :: k3 -> Constraint) (f :: k2 -> Type) (Rec a a :: Type -> Type) (Rec a a :: k1 -> Type) (Rec a a :: k1 -> Type)

Defined in Data.Barbie.Internal.Constraints

Methods

gbaddDicts :: GAllB c (Rec a a) => Rec a a x -> Rec a a x

GFunctorB (f :: k2 -> Type) (g :: k2 -> Type) (Rec x x :: k1 -> Type) (Rec x x :: k1 -> Type)

Defined in Data.Barbie.Internal.Functor

Methods

gbmap :: (forall (a :: k). f a -> g a) -> Rec x x x0 -> Rec x x x0

GTraversableB (f :: k2 -> Type) (g :: k2 -> Type) (Rec a a :: k1 -> Type) (Rec a a :: k1 -> Type)

Defined in Data.Barbie.Internal.Traversable

Methods

gbtraverse :: Applicative t => (forall (a0 :: k). f a0 -> t (g a0)) -> Rec a a x -> t (Rec a a x)

GAllBC (Rec a a :: Type -> Type)

Defined in Data.Barbie.Internal.Constraints

Associated Types

type GAllB c (Rec a a) :: Constraint

repbi ~ repbb => GBareB (Rec repbi repbi :: Type -> Type) (Rec repbb repbb :: Type -> Type)

Defined in Data.Barbie.Internal.Bare

Methods

gbstrip :: Rec repbi repbi x -> Rec repbb repbb x

gbcover :: Rec repbb repbb x -> Rec repbi repbi x

type GAllB (c :: k -> Constraint) (Rec a a :: Type -> Type)

Defined in Data.Barbie.Internal.Constraints

type GAllB (c :: k -> Constraint) (Rec a a :: Type -> Type) = ()

Deprecations

type ConstraintsOf c f b = AllBF c f b

Deprecated: Renamed to AllBF (now based on AllB)

adjProof :: forall b c f. (ConstraintsB b, AllB c b) => b f -> b (Dict c `Product` f)

Deprecated: Renamed to baddDicts

type ProofB b = ProductBC b

Deprecated: Class was renamed to ProductBC

bproof :: forall b c. (ProductBC b, AllB c b) => b (Dict c)

Deprecated: Renamed to bdicts