Hoogle Search

Within LTS Haskell 24.27 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. type CanDeriveConstraintsT (c :: k -> Constraint) (t :: k -> Type -> kg -> Type) (f :: k -> Type) (x :: kg) = (GenericN t f x, GenericN t Product Dict c f x, AllT c t ~ GAll 1 c GAllRepT t, GConstraints 1 c f GAllRepT t RepN t f x RepN t Product Dict c f x)

   barbies	Barbies.Internal

   CanDeriveConstraintsT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f and x:

   • There is an instance of Generic (T f x).
   • T f can contain fields of type t f x as long as there exists a ConstraintsT t instance. In particular, recursive usages of T f x are allowed.

2. type CanDeriveDistributiveB (b :: k1 -> Type -> Type) (f :: Type -> Type) (g :: k1 -> Type) = (GenericP 0 b g, GenericP 0 b Compose f g, GDistributive 0 f RepP 0 b g RepP 0 b Compose f g)

   barbies	Barbies.Internal

   CanDeriveDistributiveB B f g is in practice a predicate about B only. Intuitively, it says the the following holds for any arbitrary f:

   • There is an instance of Generic (B f).
   • (B f) has only one constructor, and doesn't contain "naked" fields (that is, not covered by f).
   • B f can contain fields of type b f as long as there exists a DistributiveB b instance. In particular, recursive usages of B f are allowed.
   • B f can also contain usages of b f under a Distributive h. For example, one could use a -> (B f) as a field of B f.

3. type CanDeriveDistributiveT (t :: Type -> Type -> i -> Type) (f :: Type -> Type) (g :: Type -> Type) (x :: i) = (GenericP 1 t g x, GenericP 1 t Compose f g x, GDistributive 1 f RepP 1 t g x RepP 1 t Compose f g x)

   barbies	Barbies.Internal

   CanDeriveDistributiveT T f g x is in practice a predicate about T only. Intuitively, it says the the following holds for any arbitrary f:

   • There is an instance of Generic (B f x).
   • (B f x) has only one constructor, and doesn't contain "naked" fields (that is, not covered by f). In particular, x needs to occur under f.
   • B f x can contain fields of type b f y as long as there exists a DistributiveT b instance. In particular, recursive usages of B f x are allowed.
   • B f x can also contain usages of b f y under a Distributive h. For example, one could use a -> (B f x) as a field of B f x.

4. type CanDeriveFunctorB (b :: k -> Type -> Type) (f :: k -> Type) (g :: k -> Type) = (GenericP 0 b f, GenericP 0 b g, GFunctor 0 f g RepP 0 b f RepP 0 b g)

   barbies	Barbies.Internal

   CanDeriveFunctorB B f g is in practice a predicate about B only. Intuitively, it says that the following holds, for any arbitrary f:

   • There is an instance of Generic (B f).
   • B f can contain fields of type b f as long as there exists a FunctorB b instance. In particular, recursive usages of B f are allowed.
   • B f can also contain usages of b f under a Functor h. For example, one could use Maybe (B f) when defining B f.

5. type CanDeriveFunctorT (t :: k -> Type -> k1 -> Type) (f :: k -> Type) (g :: k -> Type) (x :: k1) = (GenericP 1 t f x, GenericP 1 t g x, GFunctor 1 f g RepP 1 t f x RepP 1 t g x)

   barbies	Barbies.Internal

   CanDeriveFunctorT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f:

   • There is an instance of Generic (T f).
   • T f x can contain fields of type t f y as long as there exists a FunctorT t instance. In particular, recursive usages of T f y are allowed.
   • T f x can also contain usages of t f y under a Functor h. For example, one could use Maybe (T f y) when defining T f y.

6. type CanDeriveTraversableB (b :: k1 -> Type -> Type) (f :: k1 -> Type) (g :: k1 -> Type) = (GenericP 0 b f, GenericP 0 b g, GTraversable 0 f g RepP 0 b f RepP 0 b g)

   barbies	Barbies.Internal

   CanDeriveTraversableB B f g is in practice a predicate about B only. It is analogous to CanDeriveFunctorB, so it essentially requires the following to hold, for any arbitrary f:

   • There is an instance of Generic (B f).
   • B f can contain fields of type b f as long as there exists a TraversableB b instance. In particular, recursive usages of B f are allowed.
   • B f can also contain usages of b f under a Traversable h. For example, one could use Maybe (B f) when defining B f.

7. type CanDeriveTraversableT (t :: k1 -> Type -> k -> Type) (f :: k1 -> Type) (g :: k1 -> Type) (x :: k) = (GenericP 1 t f x, GenericP 1 t g x, GTraversable 1 f g RepP 1 t f x RepP 1 t g x)

   barbies	Barbies.Internal

   CanDeriveTraversableT T f g x is in practice a predicate about T only. It is analogous to CanDeriveFunctorT, so it essentially requires the following to hold, for any arbitrary f:

   • There is an instance of Generic (T f x).
   • T f x can contain fields of type t f x as long as there exists a TraversableT t instance. In particular, recursive usages of T f x are allowed.
   • T f x can also contain usages of t f x under a Traversable h. For example, one could use Maybe (T f x) when defining T f x.

8. DatabaseStateSourceDerived :: DatabaseStateSource

   beam-migrate	Database.Beam.Migrate.Actions

   Predicate is from an action we've committed to in this action chain

9. checkDerived :: Config -> Bool

   liquidhaskell-boot	Language.Haskell.Liquid.UX.Config

   check internal (GHC-derived) binders

10. isDerivedInstance :: ClsInst -> Bool

    liquidhaskell-boot	Language.Haskell.Liquid.WiredIn

    No documentation available.

Page 95 of many | Previous | Next