| Safe Haskell | None |
|---|---|
| Language | GHC2021 |
Stock
Description
Synthesize class instances for the Stock / Stock1 /
Stock2 newtype wrappers directly from a datatype's structure,
same as hand-written without Generic. This one module both
provides the wrappers and is the plugin, so a single name does
everything:
{-# options_ghc -fplugin Stock #-}
import Stock
data Colour = Red | Green | Blue
deriving (Eq, Ord, Show)
via Stock ColourSupported classes:
Stock:Eq,Ord,Show,Read,Semigroup,Monoid,Enum,Bounded,Ix,Generic.Stock1:Functor/Contravariant,Foldable,Applicative,Generic1,Eq1,Ord1,Show1,Read1,Traversable.Stock2:Bifunctor,Bifoldable,Eq2,Ord2,Show2,Read2,Category,Bitraversable.
Traversable/Bitraversable are synthesized at the wrapper (Stock1
F/Stock2 P) and used directly, or put on your type with the one-liner
traverse g = fmap unStock1 . traverse g . Stock1. A bare deriving via
can't coerce them onto your type: traverse's result f (t b) places the
wrapper under an abstract applicative (nominal role), which is unsound to
coerce — but the instance itself is ordinary, so the one-liner works.
The set is open: a satellite package adds a brand-new class with no
configuration change (just a dependency) by writing a DeriveStock
instance. See Stock.Derive.
Individual fields can be reshaped during synthesis (per-field
DerivingVia) with deriving Cls via Stock (Override T cfg); see
Stock.Override.
When does it run? All synthesis happens at compile time,
while the plugin type-checks your deriving clause: it emits
ordinary Core — the same a hand-written instance would. At runtime
there is no Rep, no reflection, no instance lookup; you pay
exactly the usual dictionary plumbing (including any dictionaries
that polymorphic or polymorphically-recursive code builds at
runtime), and never anything extra for having used Stock.
Synopsis
- newtype Stock a = Stock {
- unStock :: a
- newtype Stock1 (f :: k -> Type) (a :: k) = Stock1 {
- unStock1 :: f a
- newtype Stock2 (bi :: k -> j -> Type) (a :: k) (b :: j) = Stock2 {
- unStock2 :: bi a b
- plugin :: Plugin
- class Contravariant (f :: Type -> Type)
- class (forall a. Eq a => Eq (f a)) => Eq1 (f :: Type -> Type)
- class (Eq1 f, forall a. Ord a => Ord (f a)) => Ord1 (f :: Type -> Type)
- class (forall a. Show a => Show (f a)) => Show1 (f :: Type -> Type)
- class (forall a. Read a => Read (f a)) => Read1 (f :: Type -> Type)
- class (forall a. Eq a => Eq1 (f a)) => Eq2 (f :: Type -> Type -> Type)
- class (Eq2 f, forall a. Ord a => Ord1 (f a)) => Ord2 (f :: Type -> Type -> Type)
- class (forall a. Show a => Show1 (f a)) => Show2 (f :: Type -> Type -> Type)
- class (forall a. Read a => Read1 (f a)) => Read2 (f :: Type -> Type -> Type)
- class (forall a. Functor (p a)) => Bifunctor (p :: Type -> Type -> Type)
- class Bifoldable (p :: Type -> Type -> Type)
- class Category (cat :: k -> k -> Type)
- class Ord a => Ix a
- class Generic a
- class Generic1 (f :: k -> Type)
- module Stock.Override
Documentation
Wrap a type a so that deriving C via Stock a synthesizes C a.
newtype Stock1 (f :: k -> Type) (a :: k) Source #
Wrap a type constructor f so that deriving C via Stock1 f synthesizes
a C f instance (for classes over type constructors, e.g. Functor).
Poly-kinded in the index (f :: k -> Type) so it works for classes over
non-Type indices too (e.g. TestEquality) — maximally polymorphic.
newtype Stock2 (bi :: k -> j -> Type) (a :: k) (b :: j) Source #
Wrap a two-parameter type constructor p so that deriving C via Stock2 p
synthesizes a C p instance (for classes over two-parameter type
constructors, e.g. Bifunctor, Bifoldable, Eq2, Ord2, Show2,
Read2, Category).
The Stock type-checker plugin. Enable with -fplugin Stock.
{-# options_ghc -fplugin Stock #-}class Contravariant (f :: Type -> Type) #
The class of contravariant functors.
Whereas in Haskell, one can think of a Functor as containing or producing
values, a contravariant functor is a functor that can be thought of as
consuming values.
As an example, consider the type of predicate functions a -> Bool. One
such predicate might be negative x = x < 0, which
classifies integers as to whether they are negative. However, given this
predicate, we can re-use it in other situations, providing we have a way to
map values to integers. For instance, we can use the negative predicate
on a person's bank balance to work out if they are currently overdrawn:
newtype Predicate a = Predicate { getPredicate :: a -> Bool }
instance Contravariant Predicate where
contramap :: (a' -> a) -> (Predicate a -> Predicate a')
contramap f (Predicate p) = Predicate (p . f)
| `- First, map the input...
`----- then apply the predicate.
overdrawn :: Predicate Person
overdrawn = contramap personBankBalance negative
Any instance should be subject to the following laws:
Note, that the second law follows from the free theorem of the type of
contramap and the first law, so you need only check that the former
condition holds.
Minimal complete definition
Instances
| Contravariant Comparison | A |
Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Comparison a -> Comparison a' # (>$) :: b -> Comparison b -> Comparison a # | |
| Contravariant Equivalence | Equivalence relations are |
Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Equivalence a -> Equivalence a' # (>$) :: b -> Equivalence b -> Equivalence a # | |
| Contravariant Predicate | A Without newtypes contramap :: (a' -> a) -> (Predicate a -> Predicate a') contramap f (Predicate g) = Predicate (g . f) |
| Contravariant (Op a) | |
| Contravariant (Proxy :: Type -> Type) | |
| Contravariant (U1 :: Type -> Type) | |
| Contravariant (V1 :: Type -> Type) | |
| Contravariant (Const a :: Type -> Type) | |
| Contravariant f => Contravariant (Alt f) | |
| Contravariant f => Contravariant (Rec1 f) | |
| (Contravariant f, Contravariant g) => Contravariant (Product f g) | |
| (Contravariant f, Contravariant g) => Contravariant (Sum f g) | |
| (Contravariant f, Contravariant g) => Contravariant (f :*: g) | |
| (Contravariant f, Contravariant g) => Contravariant (f :+: g) | |
| Contravariant (K1 i c :: Type -> Type) | |
| (Functor f, Contravariant g) => Contravariant (Compose f g) | |
| (Functor f, Contravariant g) => Contravariant (f :.: g) | |
| Contravariant f => Contravariant (M1 i c f) | |
class (forall a. Eq a => Eq (f a)) => Eq1 (f :: Type -> Type) #
Lifting of the Eq class to unary type constructors.
Any instance should be subject to the following law that canonicity is preserved:
liftEq (==) = (==)
This class therefore represents the generalization of Eq by
decomposing its main method into a canonical lifting on a canonical
inner method, so that the lifting can be reused for other arguments
than the canonical one.
Since: base-4.9.0.0
Instances
| Eq1 Complex |
Since: base-4.16.0.0 |
| Eq1 Identity | Since: base-4.9.0.0 |
| Eq1 Down | Since: base-4.12.0.0 |
| Eq1 NonEmpty | Since: base-4.10.0.0 |
| Eq1 Word64Map | Since: ghc-0.5.9 |
| Eq1 Maybe | Since: base-4.9.0.0 |
| Eq1 Solo | Since: base-4.15 |
| Eq1 [] | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Eq a => Eq1 (Either a) | Since: base-4.9.0.0 |
| Eq1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| Eq a => Eq1 ((,) a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Eq a => Eq1 (Const a :: Type -> Type) | Since: base-4.9.0.0 |
| (Generic1 f, Eq1 (Rep1 f)) => Eq1 (Generically1 f) | Since: base-4.17.0.0 |
Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Generically1 f a -> Generically1 f b -> Bool # | |
| (Eq a, Eq b) => Eq1 ((,,) a b) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
| (Eq1 f, Eq1 g) => Eq1 (Product f g) | Since: base-4.9.0.0 |
| (Eq1 f, Eq1 g) => Eq1 (Sum f g) | Since: base-4.9.0.0 |
| (Eq a, Eq b, Eq c) => Eq1 ((,,,) a b c) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
| (Eq1 f, Eq1 g) => Eq1 (Compose f g) | Since: base-4.9.0.0 |
class (Eq1 f, forall a. Ord a => Ord (f a)) => Ord1 (f :: Type -> Type) #
Lifting of the Ord class to unary type constructors.
Any instance should be subject to the following law that canonicity is preserved:
liftCompare compare = compare
This class therefore represents the generalization of Ord by
decomposing its main method into a canonical lifting on a canonical
inner method, so that the lifting can be reused for other arguments
than the canonical one.
Since: base-4.9.0.0
Instances
| Ord1 Identity | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Ord1 Down | Since: base-4.12.0.0 |
Defined in Data.Functor.Classes | |
| Ord1 NonEmpty | Since: base-4.10.0.0 |
Defined in Data.Functor.Classes | |
| Ord1 Word64Map | Since: ghc-0.5.9 |
Defined in GHC.Data.Word64Map.Internal | |
| Ord1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Ord1 Solo | Since: base-4.15 |
Defined in Data.Functor.Classes | |
| Ord1 [] | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> [a] -> [b] -> Ordering # | |
| Ord a => Ord1 (Either a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Ord1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Ord a => Ord1 ((,) a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> (a, a0) -> (a, b) -> Ordering # | |
| Ord a => Ord1 (Const a :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| (Generic1 f, Ord1 (Rep1 f)) => Ord1 (Generically1 f) | Since: base-4.17.0.0 |
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Generically1 f a -> Generically1 f b -> Ordering # | |
| (Ord a, Ord b) => Ord1 ((,,) a b) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b0 -> Ordering) -> (a, b, a0) -> (a, b, b0) -> Ordering # | |
| (Ord1 f, Ord1 g) => Ord1 (Product f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Product | |
| (Ord1 f, Ord1 g) => Ord1 (Sum f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Sum | |
| (Ord a, Ord b, Ord c) => Ord1 ((,,,) a b c) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b0 -> Ordering) -> (a, b, c, a0) -> (a, b, c, b0) -> Ordering # | |
| (Ord1 f, Ord1 g) => Ord1 (Compose f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose | |
class (forall a. Show a => Show (f a)) => Show1 (f :: Type -> Type) #
Lifting of the Show class to unary type constructors.
Any instance should be subject to the following laws that canonicity is preserved:
liftShowsPrec showsPrec showList = showsPrec
liftShowList showsPrec showList = showList
This class therefore represents the generalization of Show by
decomposing it's methods into a canonical lifting on a canonical
inner method, so that the lifting can be reused for other arguments
than the canonical one.
Since: base-4.9.0.0
Instances
| Show1 Complex |
Since: base-4.16.0.0 |
| Show1 Identity | Since: base-4.9.0.0 |
| Show1 Down | Since: base-4.12.0.0 |
| Show1 NonEmpty | Since: base-4.10.0.0 |
| Show1 Word64Map | Since: ghc-0.5.9 |
| Show1 Maybe | Since: base-4.9.0.0 |
| Show1 Solo | Since: base-4.15 |
| Show1 [] | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Show a => Show1 (Either a) | Since: base-4.9.0.0 |
| Show1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| Show a => Show1 ((,) a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Show a => Show1 (Const a :: Type -> Type) | Since: base-4.9.0.0 |
| (Show a, Show b) => Show1 ((,,) a b) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
| (Show1 f, Show1 g) => Show1 (Product f g) | Since: base-4.9.0.0 |
| (Show1 f, Show1 g) => Show1 (Sum f g) | Since: base-4.9.0.0 |
| (Show a, Show b, Show c) => Show1 ((,,,) a b c) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
| (Show1 f, Show1 g) => Show1 (Compose f g) | Since: base-4.9.0.0 |
class (forall a. Read a => Read (f a)) => Read1 (f :: Type -> Type) #
Lifting of the Read class to unary type constructors.
Any instance should be subject to the following laws that canonicity is preserved:
liftReadsPrec readsPrec readList = readsPrec
liftReadList readsPrec readList = readList
liftReadPrec readPrec readListPrec = readPrec
liftReadListPrec readPrec readListPrec = readListPrec
This class therefore represents the generalization of Read by
decomposing it's methods into a canonical lifting on a canonical
inner method, so that the lifting can be reused for other arguments
than the canonical one.
Both liftReadsPrec and liftReadPrec exist to match the interface
provided in the Read type class, but it is recommended to implement
Read1 instances using liftReadPrec as opposed to liftReadsPrec, since
the former is more efficient than the latter. For example:
instanceRead1T whereliftReadPrec= ...liftReadListPrec=liftReadListPrecDefault
For more information, refer to the documentation for the Read class.
Since: base-4.9.0.0
Minimal complete definition
Instances
| Read1 Complex |
Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
| Read1 Identity | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read1 Down | Since: base-4.12.0.0 |
Defined in Data.Functor.Classes | |
| Read1 NonEmpty | Since: base-4.10.0.0 |
Defined in Data.Functor.Classes | |
| Read1 Word64Map | Since: ghc-0.5.9 |
Defined in GHC.Data.Word64Map.Internal | |
| Read1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read1 Solo | Since: base-4.15 |
Defined in Data.Functor.Classes | |
| Read1 [] | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read a => Read1 (Either a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] # | |
| Read1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read a => Read1 ((,) a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read a => Read1 (Const a :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] # | |
| (Read a, Read b) => Read1 ((,,) a b) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
| (Read1 f, Read1 g) => Read1 (Product f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Product Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Product f g a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Product f g a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Product f g a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Product f g a] # | |
| (Read1 f, Read1 g) => Read1 (Sum f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Sum | |
| (Read a, Read b, Read c) => Read1 ((,,,) a b c) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (a, b, c, a0) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [(a, b, c, a0)] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (a, b, c, a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [(a, b, c, a0)] # | |
| (Read1 f, Read1 g) => Read1 (Compose f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose f g a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose f g a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Compose f g a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Compose f g a] # | |
class (forall a. Eq a => Eq1 (f a)) => Eq2 (f :: Type -> Type -> Type) #
Lifting of the Eq class to binary type constructors.
Since: base-4.9.0.0
Minimal complete definition
Instances
| Eq2 Either | Since: base-4.9.0.0 |
| Eq2 (,) | Since: base-4.9.0.0 |
| Eq2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 |
| Eq a => Eq2 ((,,) a) |
Since: base-4.16.0.0 |
| (Eq a, Eq b) => Eq2 ((,,,) a b) |
Since: base-4.16.0.0 |
class (Eq2 f, forall a. Ord a => Ord1 (f a)) => Ord2 (f :: Type -> Type -> Type) #
Lifting of the Ord class to binary type constructors.
Since: base-4.9.0.0
Minimal complete definition
Instances
| Ord2 Either | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Ord2 (,) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> (a, c) -> (b, d) -> Ordering # | |
| Ord2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Ord a => Ord2 ((,,) a) |
Since: base-4.16.0.0 |
Defined in Data.Functor.Classes Methods liftCompare2 :: (a0 -> b -> Ordering) -> (c -> d -> Ordering) -> (a, a0, c) -> (a, b, d) -> Ordering # | |
| (Ord a, Ord b) => Ord2 ((,,,) a b) |
Since: base-4.16.0.0 |
Defined in Data.Functor.Classes Methods liftCompare2 :: (a0 -> b0 -> Ordering) -> (c -> d -> Ordering) -> (a, b, a0, c) -> (a, b, b0, d) -> Ordering # | |
class (forall a. Show a => Show1 (f a)) => Show2 (f :: Type -> Type -> Type) #
Lifting of the Show class to binary type constructors.
Since: base-4.9.0.0
Minimal complete definition
Instances
| Show2 Either | Since: base-4.9.0.0 |
| Show2 (,) | Since: base-4.9.0.0 |
| Show2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 |
| Show a => Show2 ((,,) a) |
Since: base-4.16.0.0 |
| (Show a, Show b) => Show2 ((,,,) a b) |
Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
class (forall a. Read a => Read1 (f a)) => Read2 (f :: Type -> Type -> Type) #
Lifting of the Read class to binary type constructors.
Both liftReadsPrec2 and liftReadPrec2 exist to match the interface
provided in the Read type class, but it is recommended to implement
Read2 instances using liftReadPrec2 as opposed to liftReadsPrec2,
since the former is more efficient than the latter. For example:
instanceRead2T whereliftReadPrec2= ...liftReadListPrec2=liftReadListPrec2Default
For more information, refer to the documentation for the Read class.
Since: base-4.9.0.0
Minimal complete definition
Instances
| Read2 Either | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] # | |
| Read2 (,) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (a, b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [(a, b)] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (a, b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [(a, b)] # | |
| Read2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] # | |
| Read a => Read2 ((,,) a) |
Since: base-4.16.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (a, a0, b) # liftReadList2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [(a, a0, b)] # liftReadPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (a, a0, b) # liftReadListPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [(a, a0, b)] # | |
| (Read a, Read b) => Read2 ((,,,) a b) |
Since: base-4.16.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b0) -> ReadS [b0] -> Int -> ReadS (a, b, a0, b0) # liftReadList2 :: (Int -> ReadS a0) -> ReadS [a0] -> (Int -> ReadS b0) -> ReadS [b0] -> ReadS [(a, b, a0, b0)] # liftReadPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b0 -> ReadPrec [b0] -> ReadPrec (a, b, a0, b0) # liftReadListPrec2 :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec b0 -> ReadPrec [b0] -> ReadPrec [(a, b, a0, b0)] # | |
class (forall a. Functor (p a)) => Bifunctor (p :: Type -> Type -> Type) #
A bifunctor is a type constructor that takes
two type arguments and is a functor in both arguments. That
is, unlike with Functor, a type constructor such as Either
does not need to be partially applied for a Bifunctor
instance, and the methods in this class permit mapping
functions over the Left value or the Right value,
or both at the same time.
Formally, the class Bifunctor represents a bifunctor
from Hask -> Hask.
Intuitively it is a bifunctor where both the first and second arguments are covariant.
You can define a Bifunctor by either defining bimap or by
defining both first and second. A partially applied Bifunctor
must be a Functor and the second method must agree with fmap.
From this it follows that:
secondid=id
If you supply bimap, you should ensure that:
bimapidid≡id
If you supply first and second, ensure:
firstid≡idsecondid≡id
If you supply both, you should also ensure:
bimapf g ≡firstf.secondg
These ensure by parametricity:
bimap(f.g) (h.i) ≡bimapf h.bimapg ifirst(f.g) ≡firstf.firstgsecond(f.g) ≡secondf.secondg
Since 4.18.0.0 Functor is a superclass of 'Bifunctor.
Since: base-4.8.0.0
Instances
| Bifunctor Either | Since: base-4.8.0.0 |
| Bifunctor Arg | Since: base-4.9.0.0 |
| Bifunctor Gr | |
| Bifunctor (,) | Class laws for tuples hold only up to laziness. Both
Since: base-4.8.0.0 |
| Bifunctor (Const :: Type -> Type -> Type) | Since: base-4.8.0.0 |
| Bifunctor ((,,) x1) | Since: base-4.8.0.0 |
| Bifunctor (K1 i :: Type -> Type -> Type) | Since: base-4.9.0.0 |
| Bifunctor ((,,,) x1 x2) | Since: base-4.8.0.0 |
| Bifunctor ((,,,,) x1 x2 x3) | Since: base-4.8.0.0 |
| Bifunctor ((,,,,,) x1 x2 x3 x4) | Since: base-4.8.0.0 |
| Bifunctor ((,,,,,,) x1 x2 x3 x4 x5) | Since: base-4.8.0.0 |
class Bifoldable (p :: Type -> Type -> Type) #
Bifoldable identifies foldable structures with two different varieties
of elements (as opposed to Foldable, which has one variety of element).
Common examples are Either and (,):
instance Bifoldable Either where bifoldMap f _ (Left a) = f a bifoldMap _ g (Right b) = g b instance Bifoldable (,) where bifoldr f g z (a, b) = f a (g b z)
Some examples below also use the following BiList to showcase empty
Bifoldable behaviors when relevant (Either and (,) containing always exactly
resp. 1 and 2 elements):
data BiList a b = BiList [a] [b] instance Bifoldable BiList where bifoldr f g z (BiList as bs) = foldr f (foldr g z bs) as
A minimal Bifoldable definition consists of either bifoldMap or
bifoldr. When defining more than this minimal set, one should ensure
that the following identities hold:
bifold≡bifoldMapididbifoldMapf g ≡bifoldr(mappend. f) (mappend. g)memptybifoldrf g z t ≡appEndo(bifoldMap(Endo . f) (Endo . g) t) z
If the type is also a Bifunctor instance, it should satisfy:
bifoldMapf g ≡bifold.bimapf g
which implies that
bifoldMapf g .bimaph i ≡bifoldMap(f . h) (g . i)
Since: base-4.10.0.0
Instances
| Bifoldable Either | Since: base-4.10.0.0 |
| Bifoldable Arg | Since: base-4.10.0.0 |
| Bifoldable (,) | Since: base-4.10.0.0 |
| Bifoldable (Const :: Type -> Type -> Type) | Since: base-4.10.0.0 |
| Bifoldable ((,,) x) | Since: base-4.10.0.0 |
| Bifoldable (K1 i :: Type -> Type -> Type) | Since: base-4.10.0.0 |
| Bifoldable ((,,,) x y) | Since: base-4.10.0.0 |
| Bifoldable ((,,,,) x y z) | Since: base-4.10.0.0 |
| Bifoldable ((,,,,,) x y z w) | Since: base-4.10.0.0 |
Defined in Data.Bifoldable | |
| Bifoldable ((,,,,,,) x y z w v) | Since: base-4.10.0.0 |
Defined in Data.Bifoldable | |
class Category (cat :: k -> k -> Type) #
A class for categories. Instances should satisfy the laws
Instances
| Category Op | |
| Monad m => Category (Kleisli m :: Type -> Type -> Type) | Since: base-3.0 |
| (Applicative f, Monad f) => Category (WhenMissing f :: Type -> Type -> Type) | Since: ghc-0.5.9 |
Defined in GHC.Data.Word64Map.Internal Methods id :: WhenMissing f a a # (.) :: WhenMissing f b c -> WhenMissing f a b -> WhenMissing f a c # | |
| Category (Coercion :: k -> k -> Type) | Since: base-4.7.0.0 |
| Category ((:~:) :: k -> k -> Type) | Since: base-4.7.0.0 |
| (Monad f, Applicative f) => Category (WhenMatched f x :: Type -> Type -> Type) | Since: ghc-0.5.9 |
Defined in GHC.Data.Word64Map.Internal Methods id :: WhenMatched f x a a # (.) :: WhenMatched f x b c -> WhenMatched f x a b -> WhenMatched f x a c # | |
| Category (->) | Since: base-3.0 |
Defined in Control.Category | |
| Category ((:~~:) :: k -> k -> Type) | Since: base-4.10.0.0 |
The Ix class is used to map a contiguous subrange of values in
a type onto integers. It is used primarily for array indexing
(see the array package).
The first argument (l,u) of each of these operations is a pair
specifying the lower and upper bounds of a contiguous subrange of values.
An implementation is entitled to assume the following laws about these operations:
Minimal complete definition
range, (index | unsafeIndex), inRange
Instances
| Ix CBool | |
| Ix CChar | |
| Ix CInt | |
| Ix CIntMax | |
Defined in Foreign.C.Types | |
| Ix CIntPtr | |
Defined in Foreign.C.Types | |
| Ix CLLong | |
| Ix CLong | |
| Ix CPtrdiff | |
Defined in Foreign.C.Types Methods range :: (CPtrdiff, CPtrdiff) -> [CPtrdiff] # index :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Int # unsafeIndex :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Int # inRange :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Bool # rangeSize :: (CPtrdiff, CPtrdiff) -> Int # unsafeRangeSize :: (CPtrdiff, CPtrdiff) -> Int # | |
| Ix CSChar | |
| Ix CShort | |
| Ix CSigAtomic | |
Defined in Foreign.C.Types Methods range :: (CSigAtomic, CSigAtomic) -> [CSigAtomic] # index :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Int # unsafeIndex :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Int # inRange :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Bool # rangeSize :: (CSigAtomic, CSigAtomic) -> Int # unsafeRangeSize :: (CSigAtomic, CSigAtomic) -> Int # | |
| Ix CSize | |
| Ix CUChar | |
| Ix CUInt | |
| Ix CUIntMax | |
Defined in Foreign.C.Types Methods range :: (CUIntMax, CUIntMax) -> [CUIntMax] # index :: (CUIntMax, CUIntMax) -> CUIntMax -> Int # unsafeIndex :: (CUIntMax, CUIntMax) -> CUIntMax -> Int # inRange :: (CUIntMax, CUIntMax) -> CUIntMax -> Bool # rangeSize :: (CUIntMax, CUIntMax) -> Int # unsafeRangeSize :: (CUIntMax, CUIntMax) -> Int # | |
| Ix CUIntPtr | |
Defined in Foreign.C.Types Methods range :: (CUIntPtr, CUIntPtr) -> [CUIntPtr] # index :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int # unsafeIndex :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int # inRange :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool # rangeSize :: (CUIntPtr, CUIntPtr) -> Int # unsafeRangeSize :: (CUIntPtr, CUIntPtr) -> Int # | |
| Ix CULLong | |
Defined in Foreign.C.Types | |
| Ix CULong | |
| Ix CUShort | |
Defined in Foreign.C.Types | |
| Ix CWchar | |
| Ix IntPtr | |
| Ix WordPtr | |
Defined in Foreign.Ptr | |
| Ix Void | Since: base-4.8.0.0 |
| Ix Associativity | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods range :: (Associativity, Associativity) -> [Associativity] # index :: (Associativity, Associativity) -> Associativity -> Int # unsafeIndex :: (Associativity, Associativity) -> Associativity -> Int # inRange :: (Associativity, Associativity) -> Associativity -> Bool # rangeSize :: (Associativity, Associativity) -> Int # unsafeRangeSize :: (Associativity, Associativity) -> Int # | |
| Ix DecidedStrictness | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods range :: (DecidedStrictness, DecidedStrictness) -> [DecidedStrictness] # index :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int # unsafeIndex :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int # inRange :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Bool # rangeSize :: (DecidedStrictness, DecidedStrictness) -> Int # unsafeRangeSize :: (DecidedStrictness, DecidedStrictness) -> Int # | |
| Ix SourceStrictness | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods range :: (SourceStrictness, SourceStrictness) -> [SourceStrictness] # index :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int # unsafeIndex :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int # inRange :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Bool # rangeSize :: (SourceStrictness, SourceStrictness) -> Int # unsafeRangeSize :: (SourceStrictness, SourceStrictness) -> Int # | |
| Ix SourceUnpackedness | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods range :: (SourceUnpackedness, SourceUnpackedness) -> [SourceUnpackedness] # index :: (SourceUnpackedness, SourceUnpackedness) -> SourceUnpackedness -> Int # unsafeIndex :: (SourceUnpackedness, SourceUnpackedness) -> SourceUnpackedness -> Int # inRange :: (SourceUnpackedness, SourceUnpackedness) -> SourceUnpackedness -> Bool # rangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int # unsafeRangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int # | |
| Ix SeekMode | Since: base-4.2.0.0 |
Defined in GHC.IO.Device Methods range :: (SeekMode, SeekMode) -> [SeekMode] # index :: (SeekMode, SeekMode) -> SeekMode -> Int # unsafeIndex :: (SeekMode, SeekMode) -> SeekMode -> Int # inRange :: (SeekMode, SeekMode) -> SeekMode -> Bool # rangeSize :: (SeekMode, SeekMode) -> Int # unsafeRangeSize :: (SeekMode, SeekMode) -> Int # | |
| Ix IOMode | Since: base-4.2.0.0 |
| Ix Int16 | Since: base-2.1 |
| Ix Int32 | Since: base-2.1 |
| Ix Int64 | Since: base-2.1 |
| Ix Int8 | Since: base-2.1 |
| Ix GeneralCategory | Since: base-2.1 |
Defined in GHC.Unicode Methods range :: (GeneralCategory, GeneralCategory) -> [GeneralCategory] # index :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int # unsafeIndex :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int # inRange :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Bool # rangeSize :: (GeneralCategory, GeneralCategory) -> Int # unsafeRangeSize :: (GeneralCategory, GeneralCategory) -> Int # | |
| Ix Word16 | Since: base-2.1 |
| Ix Word32 | Since: base-2.1 |
| Ix Word64 | Since: base-2.1 |
| Ix Word8 | Since: base-2.1 |
| Ix CBlkCnt | |
Defined in System.Posix.Types | |
| Ix CBlkSize | |
Defined in System.Posix.Types Methods range :: (CBlkSize, CBlkSize) -> [CBlkSize] # index :: (CBlkSize, CBlkSize) -> CBlkSize -> Int # unsafeIndex :: (CBlkSize, CBlkSize) -> CBlkSize -> Int # inRange :: (CBlkSize, CBlkSize) -> CBlkSize -> Bool # rangeSize :: (CBlkSize, CBlkSize) -> Int # unsafeRangeSize :: (CBlkSize, CBlkSize) -> Int # | |
| Ix CClockId | |
Defined in System.Posix.Types Methods range :: (CClockId, CClockId) -> [CClockId] # index :: (CClockId, CClockId) -> CClockId -> Int # unsafeIndex :: (CClockId, CClockId) -> CClockId -> Int # inRange :: (CClockId, CClockId) -> CClockId -> Bool # rangeSize :: (CClockId, CClockId) -> Int # unsafeRangeSize :: (CClockId, CClockId) -> Int # | |
| Ix CDev | |
| Ix CFsBlkCnt | |
Defined in System.Posix.Types Methods range :: (CFsBlkCnt, CFsBlkCnt) -> [CFsBlkCnt] # index :: (CFsBlkCnt, CFsBlkCnt) -> CFsBlkCnt -> Int # unsafeIndex :: (CFsBlkCnt, CFsBlkCnt) -> CFsBlkCnt -> Int # inRange :: (CFsBlkCnt, CFsBlkCnt) -> CFsBlkCnt -> Bool # rangeSize :: (CFsBlkCnt, CFsBlkCnt) -> Int # unsafeRangeSize :: (CFsBlkCnt, CFsBlkCnt) -> Int # | |
| Ix CFsFilCnt | |
Defined in System.Posix.Types Methods range :: (CFsFilCnt, CFsFilCnt) -> [CFsFilCnt] # index :: (CFsFilCnt, CFsFilCnt) -> CFsFilCnt -> Int # unsafeIndex :: (CFsFilCnt, CFsFilCnt) -> CFsFilCnt -> Int # inRange :: (CFsFilCnt, CFsFilCnt) -> CFsFilCnt -> Bool # rangeSize :: (CFsFilCnt, CFsFilCnt) -> Int # unsafeRangeSize :: (CFsFilCnt, CFsFilCnt) -> Int # | |
| Ix CGid | |
| Ix CId | |
| Ix CIno | |
| Ix CKey | |
| Ix CMode | |
| Ix CNfds | |
| Ix CNlink | |
| Ix COff | |
| Ix CPid | |
| Ix CRLim | |
| Ix CSocklen | |
Defined in System.Posix.Types Methods range :: (CSocklen, CSocklen) -> [CSocklen] # index :: (CSocklen, CSocklen) -> CSocklen -> Int # unsafeIndex :: (CSocklen, CSocklen) -> CSocklen -> Int # inRange :: (CSocklen, CSocklen) -> CSocklen -> Bool # rangeSize :: (CSocklen, CSocklen) -> Int # unsafeRangeSize :: (CSocklen, CSocklen) -> Int # | |
| Ix CSsize | |
| Ix CTcflag | |
Defined in System.Posix.Types | |
| Ix CUid | |
| Ix Fd | |
| Ix StgReg | |
| Ix StgRet | |
| Ix Ordering | Since: base-2.1 |
Defined in GHC.Ix Methods range :: (Ordering, Ordering) -> [Ordering] # index :: (Ordering, Ordering) -> Ordering -> Int # unsafeIndex :: (Ordering, Ordering) -> Ordering -> Int # inRange :: (Ordering, Ordering) -> Ordering -> Bool # rangeSize :: (Ordering, Ordering) -> Int # unsafeRangeSize :: (Ordering, Ordering) -> Int # | |
| Ix Day | |
| Ix Integer | Since: base-2.1 |
Defined in GHC.Ix | |
| Ix Natural | Since: base-4.8.0.0 |
Defined in GHC.Ix | |
| Ix () | Since: base-2.1 |
| Ix Bool | Since: base-2.1 |
| Ix Char | Since: base-2.1 |
| Ix Int | Since: base-2.1 |
| Ix Word | Since: base-4.6.0.0 |
| Ix a => Ix (Identity a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] # index :: (Identity a, Identity a) -> Identity a -> Int # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int # inRange :: (Identity a, Identity a) -> Identity a -> Bool # rangeSize :: (Identity a, Identity a) -> Int # unsafeRangeSize :: (Identity a, Identity a) -> Int # | |
| Ix a => Ix (Down a) | Since: base-4.14.0.0 |
| Ix a => Ix (Solo a) | |
| Ix (Proxy s) | Since: base-4.7.0.0 |
Defined in Data.Proxy | |
| (Ix a, Ix b) => Ix (a, b) | Since: base-2.1 |
| Ix a => Ix (Const a b) | Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] # index :: (Const a b, Const a b) -> Const a b -> Int # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int # inRange :: (Const a b, Const a b) -> Const a b -> Bool # rangeSize :: (Const a b, Const a b) -> Int # unsafeRangeSize :: (Const a b, Const a b) -> Int # | |
| (Ix a1, Ix a2, Ix a3) => Ix (a1, a2, a3) | Since: base-2.1 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3), (a1, a2, a3)) -> [(a1, a2, a3)] # index :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Int # unsafeIndex :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Int # inRange :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Bool # rangeSize :: ((a1, a2, a3), (a1, a2, a3)) -> Int # unsafeRangeSize :: ((a1, a2, a3), (a1, a2, a3)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4) => Ix (a1, a2, a3, a4) | Since: base-2.1 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> [(a1, a2, a3, a4)] # index :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Int # unsafeIndex :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Int # inRange :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Bool # rangeSize :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (a1, a2, a3, a4, a5) | Since: base-2.1 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> [(a1, a2, a3, a4, a5)] # index :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5) -> Int # inRange :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6) => Ix (a1, a2, a3, a4, a5, a6) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> [(a1, a2, a3, a4, a5, a6)] # index :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7) => Ix (a1, a2, a3, a4, a5, a6, a7) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> [(a1, a2, a3, a4, a5, a6, a7)] # index :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8) => Ix (a1, a2, a3, a4, a5, a6, a7, a8) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> [(a1, a2, a3, a4, a5, a6, a7, a8)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8), (a1, a2, a3, a4, a5, a6, a7, a8)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9), (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC, Ix aD) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC, Ix aD, Ix aE) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)) -> Int # | |
| (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix aA, Ix aB, Ix aC, Ix aD, Ix aE, Ix aF) => Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) | Since: base-4.15.0.0 |
Defined in GHC.Ix Methods range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)] # index :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) -> Int # unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) -> Int # inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) -> Bool # rangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> Int # unsafeRangeSize :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF), (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)) -> Int # | |
Representable types of kind *.
This class is derivable in GHC with the DeriveGeneric flag on.
A Generic instance must satisfy the following laws:
from.to≡idto.from≡id
Instances
class Generic1 (f :: k -> Type) #
Representable types of kind * -> * (or kind k -> *, when PolyKinds
is enabled).
This class is derivable in GHC with the DeriveGeneric flag on.
A Generic1 instance must satisfy the following laws:
from1.to1≡idto1.from1≡id
Instances
| Generic1 ZipList | |||||
Defined in Control.Applicative Associated Types
| |||||
| Generic1 Complex | |||||
Defined in Data.Complex Associated Types
| |||||
| Generic1 Identity | |||||
Defined in Data.Functor.Identity Associated Types
| |||||
| Generic1 First | |||||
Defined in Data.Monoid Associated Types
| |||||
| Generic1 Last | |||||
Defined in Data.Monoid Associated Types
| |||||
| Generic1 Down | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 First | |||||
Defined in Data.Semigroup Associated Types
| |||||
| Generic1 Last | |||||
Defined in Data.Semigroup Associated Types
| |||||
| Generic1 Max | |||||
Defined in Data.Semigroup Associated Types
| |||||
| Generic1 Min | |||||
Defined in Data.Semigroup Associated Types
| |||||
| Generic1 WrappedMonoid | |||||
Defined in Data.Semigroup Associated Types
Methods from1 :: WrappedMonoid a -> Rep1 WrappedMonoid a # to1 :: Rep1 WrappedMonoid a -> WrappedMonoid a # | |||||
| Generic1 Dual | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
| Generic1 Product | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
| Generic1 Sum | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
| Generic1 NonEmpty | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 Par1 | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 Maybe | |||||
Defined in GHC.Generics | |||||
| Generic1 Solo | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 [] | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (WrappedMonad m :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a # to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a # | |||||
| Generic1 (Either a :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (Arg a :: Type -> Type) | |||||
Defined in Data.Semigroup Associated Types
| |||||
| Generic1 ((,) a :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (Proxy :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| Generic1 (U1 :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| Generic1 (V1 :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| Generic1 (WrappedArrow a b :: Type -> Type) | |||||
Defined in Control.Applicative Associated Types
Methods from1 :: WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 # to1 :: Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 # | |||||
| Generic1 (Kleisli m a :: Type -> Type) | |||||
Defined in Control.Arrow | |||||
| Generic1 ((,,) a b :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (Const a :: k -> Type) | |||||
Defined in Data.Functor.Const Associated Types
| |||||
| Generic1 (Ap f :: k -> Type) | |||||
Defined in Data.Monoid Associated Types
| |||||
| Generic1 (Alt f :: k -> Type) | |||||
Defined in Data.Semigroup.Internal Associated Types
| |||||
| Generic1 (Rec1 f :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (URec (Ptr ()) :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (URec Char :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (URec Double :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (URec Float :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (URec Int :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (URec Word :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 ((,,,) a b c :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (Product f g :: k -> Type) | |||||
Defined in Data.Functor.Product Associated Types
| |||||
| Generic1 (Sum f g :: k -> Type) | |||||
Defined in Data.Functor.Sum Associated Types
| |||||
| Generic1 (f :*: g :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (f :+: g :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (K1 i c :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 ((,,,,) a b c d :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Functor f => Generic1 (Compose f g :: k -> Type) | |||||
Defined in Data.Functor.Compose Associated Types
| |||||
| Functor f => Generic1 (f :.: g :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 (M1 i c f :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 ((,,,,,) a b c d e :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 ((,,,,,,) a b c d e f :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 ((,,,,,,,) a b c d e f g :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Generic1 ((,,,,,,,,) a b c d e f g h :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
Methods from1 :: (a, b, c, d, e, f, g, h, a0) -> Rep1 ((,,,,,,,,) a b c d e f g h) a0 # to1 :: Rep1 ((,,,,,,,,) a b c d e f g h) a0 -> (a, b, c, d, e, f, g, h, a0) # | |||||
| Generic1 ((,,,,,,,,,) a b c d e f g h i :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
Methods from1 :: (a, b, c, d, e, f, g, h, i, a0) -> Rep1 ((,,,,,,,,,) a b c d e f g h i) a0 # to1 :: Rep1 ((,,,,,,,,,) a b c d e f g h i) a0 -> (a, b, c, d, e, f, g, h, i, a0) # | |||||
| Generic1 ((,,,,,,,,,,) a b c d e f g h i j :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
Methods from1 :: (a, b, c, d, e, f, g, h, i, j, a0) -> Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0 # to1 :: Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0 -> (a, b, c, d, e, f, g, h, i, j, a0) # | |||||
| Generic1 ((,,,,,,,,,,,) a b c d e f g h i j k :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
Methods from1 :: (a, b, c, d, e, f, g, h, i, j, k, a0) -> Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0 # to1 :: Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0 -> (a, b, c, d, e, f, g, h, i, j, k, a0) # | |||||
| Generic1 ((,,,,,,,,,,,,) a b c d e f g h i j k l :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
Methods from1 :: (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0 # to1 :: Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) # | |||||
| Generic1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
Methods from1 :: (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0 # to1 :: Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) # | |||||
| Generic1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
Methods from1 :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0 # to1 :: Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) # | |||||
module Stock.Override