-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Generic programming API for large-records and large-anon
--   
--   The large-generics package offers a style of generic programming
--   inspired by generics-sop, but optimized for compilation time. For more
--   information, see the blog posts "Avoiding quadratic core code size
--   with large records"
--   <a>https://well-typed.com/blog/2021/08/large-records/</a>.
@package large-generics
@version 0.2.2


-- | Definition of <a>Rep</a> and functions that do not depend on
--   ".Generic"
--   
--   Defined as a separate module to avoid circular module dependencies.
module Data.Record.Generic.Rep.Internal

-- | Representation of some record <tt>a</tt>
--   
--   The <tt>f</tt> parameter describes which functor has been applied to
--   all fields of the record; in other words <tt>Rep I</tt> is isomorphic
--   to the record itself.
newtype Rep f a
Rep :: SmallArray (f Any) -> Rep f a

-- | Strict map
--   
--   <tt>map' f x</tt> is strict in <tt>x</tt>: if <tt>x</tt> is undefined,
--   <tt>map f x</tt> will also be undefined, even if <tt>f</tt> never
--   needs any values from <tt>x</tt>.
map' :: (forall x. f x -> g x) -> Rep f a -> Rep g a
sequenceA :: Applicative m => Rep (m :.: f) a -> m (Rep f a)

-- | Convert list to <a>Rep</a>
--   
--   Does not check that the list has the right number of elements.
unsafeFromList :: [b] -> Rep (K b) a

-- | Convert list to <a>Rep</a>
--   
--   Does not check that the list has the right number of elements, nor the
--   types of those elements.
unsafeFromListAny :: [f Any] -> Rep f a
collapse :: Rep (K a) b -> [a]

-- | Convert <a>Rep</a> to list
toListAny :: Rep f a -> [f Any]

-- | Avoid potential segfault with ghc &lt; 9.0
--   
--   See <a>https://gitlab.haskell.org/ghc/ghc/-/issues/16893</a>. I
--   haven't actually seen this fail in large-records, but we saw it fail
--   in the compact representation branch of sop-core, and what we do here
--   is not so different, so better to play it safe.
noInlineUnsafeCo :: forall a b. a -> b
instance GHC.Show.Show x => GHC.Show.Show (Data.Record.Generic.Rep.Internal.Rep (Data.SOP.BasicFunctors.K x) a)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Data.Record.Generic.Rep.Internal.Rep (Data.SOP.BasicFunctors.K x) a)

module Data.Record.Generic
class Generic a where {
    
    -- | <tt>Constraints a c</tt> means "all fields of <tt>a</tt> satisfy
    --   <tt>c</tt>"
    type Constraints a :: (Type -> Constraint) -> Constraint;
    
    -- | Type-level metadata
    --   
    --   NOTE: using type-level lists without resulting in quadratic core code
    --   is extremely difficult. Any use of this type-level metadata therefore
    --   needs delibrate consideration. Some examples:
    --   
    --   o Within the <tt>large-generics</tt> library, <a>MetadataOf</a> is
    --   used in the definition of <tt>HasNormalForm</tt>. This constraint is
    --   carefully defined to avoid quadratic code, as described in the
    --   presentation "Avoiding Quadratic Blow-up During Compilation"
    --   <a>https://skillsmatter.com/skillscasts/17262-avoiding-quadratic-blow-up-during-compilation</a>
    --   o The <tt>large-records</tt> library uses it to provide a
    --   compatibility layer between it and <tt>sop-core</tt>; this is however
    --   only for testing purposes, and the quadratic code here is simply
    --   accepted.
    type MetadataOf a :: [(Symbol, Type)];
}

-- | Translate to generic representation
from :: Generic a => a -> Rep I a

-- | Translate from generic representation
to :: Generic a => Rep I a -> a

-- | Construct vector of dictionaries, one for each field of the record
dict :: (Generic a, Constraints a c) => Proxy c -> Rep (Dict c) a

-- | Metadata
metadata :: Generic a => proxy a -> Metadata a

-- | Representation of some record <tt>a</tt>
--   
--   The <tt>f</tt> parameter describes which functor has been applied to
--   all fields of the record; in other words <tt>Rep I</tt> is isomorphic
--   to the record itself.
newtype Rep f a
Rep :: SmallArray (f Any) -> Rep f a
data Metadata a
Metadata :: String -> String -> Int -> Rep FieldMetadata a -> Metadata a
[recordName] :: Metadata a -> String
[recordConstructor] :: Metadata a -> String
[recordSize] :: Metadata a -> Int
[recordFieldMetadata] :: Metadata a -> Rep FieldMetadata a
data FieldStrictness
FieldStrict :: FieldStrictness
FieldLazy :: FieldStrictness
recordFieldNames :: Metadata a -> Rep (K String) a
data FieldMetadata x
[FieldMetadata] :: KnownSymbol name => Proxy name -> FieldStrictness -> FieldMetadata x
type family FieldName (field :: (Symbol, Type)) :: Symbol
type family FieldType (field :: (Symbol, Type)) :: Type
class (field ~ '(FieldName field, FieldType field), KnownSymbol (FieldName field)) => IsField field

-- | Composition of functors.
--   
--   Like <a>Compose</a>, but kind-polymorphic and with a shorter name.
newtype () => ( (f :: l -> Type) :.: (g :: k -> l) ) (p :: k)
Comp :: f (g p) -> (:.:) (f :: l -> Type) (g :: k -> l) (p :: k)
infixr 7 :.:

-- | The identity type functor.
--   
--   Like <a>Identity</a>, but with a shorter name.
newtype () => I a
I :: a -> I a

-- | The constant type functor.
--   
--   Like <a>Constant</a>, but kind-polymorphic in its second argument and
--   with a shorter name.
newtype () => K a (b :: k)
K :: a -> K a (b :: k)

-- | Lifted functions.
newtype () => ( (f :: k -> Type) -.-> (g :: k -> Type) ) (a :: k)
Fn :: (f a -> g a) -> (-.->) (f :: k -> Type) (g :: k -> Type) (a :: k)
[apFn] :: (-.->) (f :: k -> Type) (g :: k -> Type) (a :: k) -> f a -> g a
infixr 1 -.->

-- | An explicit dictionary carrying evidence of a class constraint.
--   
--   The constraint parameter is separated into a second argument so that
--   <tt><a>Dict</a> c</tt> is of the correct kind to be used directly as a
--   parameter to e.g. <a>NP</a>.
data () => Dict (c :: k -> Constraint) (a :: k)
[Dict] :: forall {k} (c :: k -> Constraint) (a :: k). c a => Dict c a

-- | Extract the contents of a <a>K</a> value.
unK :: forall {k} a (b :: k). K a b -> a

-- | Extract the contents of an <a>I</a> value.
unI :: I a -> a

-- | Extract the contents of a <a>Comp</a> value.
unComp :: forall {l} {k} f (g :: k -> l) (p :: k). (f :.: g) p -> f (g p)

-- | Lift the given function.
mapII :: (a -> b) -> I a -> I b

-- | Lift the given function.
mapIK :: forall {k} a b (c :: k). (a -> b) -> I a -> K b c

-- | Lift the given function.
mapKI :: forall {k} a b (c :: k). (a -> b) -> K a c -> I b

-- | Lift the given function.
mapKK :: forall {k1} {k2} a b (c :: k1) (d :: k2). (a -> b) -> K a c -> K b d

-- | Lift the given function.
mapIII :: (a -> b -> c) -> I a -> I b -> I c

-- | Lift the given function.
mapIIK :: forall {k} a b c (d :: k). (a -> b -> c) -> I a -> I b -> K c d

-- | Lift the given function.
mapIKI :: forall {k} a b c (d :: k). (a -> b -> c) -> I a -> K b d -> I c

-- | Lift the given function.
mapIKK :: forall {k1} {k2} a b c (d :: k1) (e :: k2). (a -> b -> c) -> I a -> K b d -> K c e

-- | Lift the given function.
mapKII :: forall {k} a b c (d :: k). (a -> b -> c) -> K a d -> I b -> I c

-- | Lift the given function.
mapKIK :: forall {k1} {k2} a b c (d :: k1) (e :: k2). (a -> b -> c) -> K a d -> I b -> K c e

-- | Lift the given function.
mapKKI :: forall {k1} {k2} a b c (d :: k1) (e :: k2). (a -> b -> c) -> K a d -> K b e -> I c

-- | Lift the given function.
mapKKK :: forall {k1} {k2} {k3} a b c (d :: k1) (e :: k2) (f :: k3). (a -> b -> c) -> K a d -> K b e -> K c f

-- | <a>Proxy</a> is a type that holds no data, but has a phantom parameter
--   of arbitrary type (or even kind). Its use is to provide type
--   information, even though there is no value available of that type (or
--   it may be too costly to create one).
--   
--   Historically, <tt><a>Proxy</a> :: <a>Proxy</a> a</tt> is a safer
--   alternative to the <tt><a>undefined</a> :: a</tt> idiom.
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy (Void, Int -&gt; Int)
--   Proxy
--   </pre>
--   
--   Proxy can even hold types of higher kinds,
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Either
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Functor
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy complicatedStructure
--   Proxy
--   </pre>
data () => Proxy (t :: k)
Proxy :: Proxy (t :: k)
instance (field GHC.Types.~ '(Data.Record.Generic.FieldName field, Data.Record.Generic.FieldType field), GHC.TypeLits.KnownSymbol (Data.Record.Generic.FieldName field)) => Data.Record.Generic.IsField field


-- | Operations on the generic representation
--   
--   We also re-export some non-derive functions to clarify where they
--   belong in this list.
--   
--   This module is intended for qualified import.
--   
--   <pre>
--   import qualified Data.Record.Generic.Rep as Rep
--   </pre>
--   
--   TODO: Could we provide instances for the <tt>generics-sop</tt> type
--   classes? Might lessen the pain of switching between the two or using
--   both?
module Data.Record.Generic.Rep

-- | Representation of some record <tt>a</tt>
--   
--   The <tt>f</tt> parameter describes which functor has been applied to
--   all fields of the record; in other words <tt>Rep I</tt> is isomorphic
--   to the record itself.
newtype Rep f a
Rep :: SmallArray (f Any) -> Rep f a
map :: Generic a => (forall x. f x -> g x) -> Rep f a -> Rep g a
mapM :: (Applicative m, Generic a) => (forall x. f x -> m (g x)) -> Rep f a -> m (Rep g a)
cmap :: (Generic a, Constraints a c) => Proxy c -> (forall x. c x => f x -> g x) -> Rep f a -> Rep g a
cmapM :: forall m f g c a. (Generic a, Applicative m, Constraints a c) => Proxy c -> (forall x. c x => f x -> m (g x)) -> Rep f a -> m (Rep g a)
zip :: Generic a => Rep f a -> Rep g a -> Rep (Product f g) a
zipWith :: Generic a => (forall x. f x -> g x -> h x) -> Rep f a -> Rep g a -> Rep h a
zipWithM :: forall m f g h a. (Generic a, Applicative m) => (forall x. f x -> g x -> m (h x)) -> Rep f a -> Rep g a -> m (Rep h a)
czipWith :: (Generic a, Constraints a c) => Proxy c -> (forall x. c x => f x -> g x -> h x) -> Rep f a -> Rep g a -> Rep h a
czipWithM :: forall m f g h c a. (Generic a, Applicative m, Constraints a c) => Proxy c -> (forall x. c x => f x -> g x -> m (h x)) -> Rep f a -> Rep g a -> m (Rep h a)
collapse :: Rep (K a) b -> [a]
sequenceA :: Applicative m => Rep (m :.: f) a -> m (Rep f a)
pure :: forall f a. Generic a => (forall x. f x) -> Rep f a
cpure :: (Generic a, Constraints a c) => Proxy c -> (forall x. c x => f x) -> Rep f a

-- | Higher-order version of <tt><a>*</a></tt>
--   
--   Lazy in the second argument.
ap :: forall f g a. Generic a => Rep (f -.-> g) a -> Rep f a -> Rep g a
data Index a x
indexToInt :: Index a x -> Int
getAtIndex :: Index a x -> Rep f a -> f x
putAtIndex :: Index a x -> f x -> Rep f a -> Rep f a
updateAtIndex :: Functor m => Index a x -> (f x -> m (f x)) -> Rep f a -> m (Rep f a)
allIndices :: forall a. Generic a => Rep (Index a) a

-- | Map with index
--   
--   This is an important building block in this module. Crucially,
--   <tt>mapWithIndex f a</tt> is lazy in <tt>a</tt>, reading elements from
--   <tt>a</tt> only if and when <tt>f</tt> demands them.
mapWithIndex :: forall f g a. Generic a => (forall x. Index a x -> f x -> g x) -> Rep f a -> Rep g a

module Data.Record.Generic.NFData

-- | Generic rnf function
--   
--   Typical usage:
--   
--   <pre>
--   instance NFData T where
--     rnf = grnf
--   </pre>
grnf :: (Generic a, Constraints a NFData) => a -> ()


-- | Simple example of a generic function
module Data.Record.Generic.LowerBound

-- | Types with a lower bound
class LowerBound a
lowerBound :: LowerBound a => a
glowerBound :: (Generic a, Constraints a LowerBound) => a
instance Data.Record.Generic.LowerBound.LowerBound GHC.Types.Word
instance Data.Record.Generic.LowerBound.LowerBound GHC.Types.Bool
instance Data.Record.Generic.LowerBound.LowerBound GHC.Types.Char
instance Data.Record.Generic.LowerBound.LowerBound ()
instance Data.Record.Generic.LowerBound.LowerBound [a]


-- | Generic conversion to/from JSON
module Data.Record.Generic.JSON
gtoJSON :: forall a. (Generic a, Constraints a ToJSON) => a -> Value
gparseJSON :: forall a. (Generic a, Constraints a FromJSON) => Value -> Parser a


-- | Interop with standard GHC generics
module Data.Record.Generic.GHC

-- | Route from GHC generics to LR generics
--   
--   Suppose a function such as
--   
--   <pre>
--   allEqualTo :: Eq a =&gt; a -&gt; [a] -&gt; Bool
--   allEqualTo x = all (== x)
--   </pre>
--   
--   is instead written as
--   
--   <pre>
--   allEqualTo :: (GHC.Generic a, GHC.GEq' (GHC.Rep a)) =&gt; a -&gt; [a] -&gt; Bool
--   allEqualTo x = all (GHC.geqdefault x)
--   </pre>
--   
--   where instead of using an indirection through an auxiliary type class
--   <a>Eq</a>, it directly assumes <tt>GHC.Generics</tt> and uses a
--   concrete generic implementation. Such design is arguably questionable,
--   but for example <tt>beam-core</tt> contains many such deeply ingrained
--   assumptions of the availability of <tt>GHC.Generics</tt>.
--   
--   In order to be able to call such a function on a large record
--   <tt>Foo</tt>, <tt>largeRecord</tt> will generate an instance
--   
--   <pre>
--   instance GHC.Generic Foo where
--     type Rep Foo = ThroughLRGenerics Foo
--   
--     from = WrapThroughLRGenerics
--     to   = unwrapThroughLRGenerics
--   </pre>
--   
--   For our running example, this instance makes it possible to call
--   <tt>allEqualTo</tt> provided we then provide an instance
--   
--   <pre>
--   instance ( LR.Generic a
--            , LR.Constraints a Eq
--            ) =&gt; GHC.GEq' (ThroughLRGenerics a) where
--     geq' = LR.geq `on` unwrapThroughLRGenerics
--   </pre>
--   
--   Effectively, <a>ThroughLRGenerics</a> can be used to redirect a
--   function that uses GHC generics to a function that uses LR generics.
newtype ThroughLRGenerics a p
WrapThroughLRGenerics :: a -> ThroughLRGenerics a p
[unwrapThroughLRGenerics] :: ThroughLRGenerics a p -> a

-- | GHC generics metadata
--   
--   TODO: Currently we provide metadata only for the record fields, not
--   the constructor or type name
data GhcMetadata a
GhcMetadata :: Rep GhcFieldMetadata a -> GhcMetadata a
[ghcMetadataFields] :: GhcMetadata a -> Rep GhcFieldMetadata a
data GhcFieldMetadata :: Type -> Type
[GhcFieldMetadata] :: forall (f :: Meta) (a :: Type). Selector f => Proxy f -> GhcFieldMetadata a
ghcMetadata :: Generic a => proxy a -> GhcMetadata a

module Data.Record.Generic.Eq

-- | Generic equality function
--   
--   Typical usage:
--   
--   <pre>
--   instance Eq T where
--     (==) = geq
--   </pre>
--   
--   TODO: Should we worry about short-circuiting here?
geq :: (Generic a, Constraints a Eq) => a -> a -> Bool
gcompare :: (Generic a, Constraints a Ord) => a -> a -> Ordering


-- | Interop with <tt>generics-sop</tt> generics
module Data.Record.Generic.SOP
newtype Field (f :: Type -> Type) (field :: (Symbol, Type))
[Field] :: f (FieldType field) -> Field f field
fromSOP :: SListI (MetadataOf a) => NP (Field f) (MetadataOf a) -> Rep f a
toSOP :: SListI (MetadataOf a) => Rep f a -> Maybe (NP (Field f) (MetadataOf a))

-- | Translate constraints
--   
--   When using <a>toSOP</a>, if you start with something of type
--   
--   <pre>
--   Rep f a
--   </pre>
--   
--   you end up with something of type
--   
--   <pre>
--   NP (Field f) (MetadataOf a)
--   </pre>
--   
--   When doing so, <a>toDictAll</a> can translate
--   
--   <pre>
--   Constraints a (Compose c f)
--   </pre>
--   
--   (which is useful over the original representation) to
--   
--   <pre>
--   All (Compose c (Field f)) (MetadataOf a)
--   </pre>
--   
--   which is useful for the translated representation.
toDictAll :: forall f a c. (Generic a, Constraints a (Compose c f), All IsField (MetadataOf a), forall nm x. c (f x) => c (Field f '(nm, x))) => Proxy f -> Proxy a -> Proxy c -> Dict (All (Compose c (Field f))) (MetadataOf a)
glowerBound :: (Generic a, All LowerBound xs, Code a ~ '[xs]) => a
instance GHC.Show.Show (f x) => GHC.Show.Show (Data.Record.Generic.SOP.Field f '(nm, x))
instance GHC.Classes.Eq (f x) => GHC.Classes.Eq (Data.Record.Generic.SOP.Field f '(nm, x))

module Data.Record.Generic.Show

-- | Generic definition of <a>showsPrec</a>, compatible with the GHC
--   generated one.
--   
--   Typical usage:
--   
--   <pre>
--   instance Show T where
--     showsPrec = gshowsPrec
--   </pre>
gshowsPrec :: forall a. (Generic a, Constraints a Show) => Int -> a -> ShowS

module Data.Record.Generic.Transform
type family Interpreted (d :: dom) (x :: Type) :: Type
newtype Interpret d x
Interpret :: Interpreted d x -> Interpret d x
liftInterpreted :: (Interpreted dx x -> Interpreted dy y) -> Interpret dx x -> Interpret dy y
liftInterpretedA2 :: Applicative m => (Interpreted dx x -> Interpreted dy y -> m (Interpreted dz z)) -> Interpret dx x -> Interpret dy y -> m (Interpret dz z)
type HasNormalForm d x y = InterpretTo d (MetadataOf x) (MetadataOf y)
type family InterpretTo d xs ys :: Constraint
type family IfEqual x y (r :: k) :: k

-- | Construct normal form
--   
--   TODO: Documentation.
normalize :: HasNormalForm d x y => Proxy d -> Proxy y -> Rep I x -> Rep (Interpret d) y
denormalize :: HasNormalForm d x y => Proxy d -> Proxy y -> Rep (Interpret d) y -> Rep I x
data Uninterpreted x
data DefaultInterpretation (f :: Type -> Type)
normalize1 :: forall d f x. HasNormalForm (d f) (x f) (x Uninterpreted) => Proxy d -> Rep I (x f) -> Rep (Interpret (d f)) (x Uninterpreted)
denormalize1 :: forall d f x. HasNormalForm (d f) (x f) (x Uninterpreted) => Proxy d -> Rep (Interpret (d f)) (x Uninterpreted) -> Rep I (x f)
class StandardInterpretation d f
standardInterpretation :: StandardInterpretation d f => Proxy d -> (Interpreted (d f) (Uninterpreted x) -> f x, f x -> Interpreted (d f) (Uninterpreted x))
standardInterpretation :: (StandardInterpretation d f, Coercible (Interpreted (d f) (Uninterpreted x)) (f x)) => Proxy d -> (Interpreted (d f) (Uninterpreted x) -> f x, f x -> Interpreted (d f) (Uninterpreted x))
toStandardInterpretation :: forall d f x. StandardInterpretation d f => Proxy d -> f x -> Interpret (d f) (Uninterpreted x)
fromStandardInterpretation :: forall d f x. StandardInterpretation d f => Proxy d -> Interpret (d f) (Uninterpreted x) -> f x
instance Data.Record.Generic.Transform.StandardInterpretation Data.Record.Generic.Transform.DefaultInterpretation f


-- | van Laarhoven lenses for large records. The type synonym
--   
--   <pre>
--   type Lens' s a = forall f. Functor f =&gt; (a -&gt; f a) -&gt; s -&gt; f s
--   </pre>
--   
--   Appears below, however it is not exported to avoid conflicts with
--   other libraries defining equivalent synonyms.
module Data.Record.Generic.Lens.VL
data SimpleRecordLens a b
[SimpleRecordLens] :: Lens' a b -> SimpleRecordLens a b

-- | Lens for higher-kinded record
--   
--   See <a>lensesForHKRecord</a> for details.
data HKRecordLens d (f :: Type -> Type) tbl x
[HKRecordLens] :: Lens' (tbl f) (Interpret (d f) x) -> HKRecordLens d f tbl x

-- | Lens into a regular record
--   
--   See <a>lensesForRegularRecord</a>
data RegularRecordLens tbl f x
[RegularRecordLens] :: Lens' (tbl f) (f x) -> RegularRecordLens tbl f x

-- | Construct lenses for each field in the record
--   
--   NOTE: This is of limited use since we cannot pattern match on the
--   resulting <a>Rep</a> in any meaningful way. It is possible to go
--   through the SOP adapter, but if we do, we incur quadratic cost again.
--   
--   We can do better for higher-kinded records, and better still for
--   regular higher-kinded records. See <a>lensesForHKRecord</a> and
--   <a>lensesForRegularRecord</a>.
lensesForSimpleRecord :: forall a. Generic a => Rep (SimpleRecordLens a) a

-- | Lenses for higher-kinded records
--   
--   NOTE: The lenses constructed by this function are primarily intended
--   for further processing, either by <a>lensesForRegularRecord</a> or
--   using application specific logic. Details below.
--   
--   Suppose we have a record <tt>tbl f</tt> which is indexed by a functor
--   <tt>f</tt>, and we want to construct lenses from <tt>tbl f</tt> to
--   each field in the record. Using the <tt>Transform</tt> infrastructure,
--   we can construct a lens
--   
--   <pre>
--   tbl f ~~&gt; Rep I (tbl f) ~~&gt; Rep (Interpret (d f)) (tbl Uninterpreted)
--   </pre>
--   
--   Using <a>repLenses</a> we can construct a lens of type
--   
--   <pre>
--   Rep (Interpret (d f)) (tbl Uninterpreted) ~~&gt; Interpret (d f) x
--   </pre>
--   
--   for every field of type <tt>x</tt>. Putting these two together gives
--   us a lens
--   
--   <pre>
--   tbl f ~~&gt; Interpret (d f) x
--   </pre>
--   
--   for every field in <tt>tbl Uninterpreted</tt>. We cannot simplify
--   this, because we do not know anything about the shape of <tt>x</tt>;
--   specifically, it might not be equal to <tt>Uninterpreted x'</tt> for
--   some <tt>x'</tt>, and hence we cannot simplify the target type of the
--   lens. We can do better for records with regular fields; see
--   <a>lensesForRegularRecord</a>.
lensesForHKRecord :: forall d tbl f. (Generic (tbl f), Generic (tbl Uninterpreted), HasNormalForm (d f) (tbl f) (tbl Uninterpreted)) => Proxy d -> Rep (HKRecordLens d f tbl) (tbl Uninterpreted)

-- | Lenses into higher-kinded records with regular fields
--   
--   We can use <a>lensesForHKRecord</a> to construct a <a>Rep</a> of
--   lenses into a higher-kinded record. If in addition the record is
--   regular, we can use the record type <i>itself</i> to store all the
--   lenses.
lensesForRegularRecord :: forall d tbl f. (Generic (tbl (RegularRecordLens tbl f)), Generic (tbl Uninterpreted), Generic (tbl f), HasNormalForm (d (RegularRecordLens tbl f)) (tbl (RegularRecordLens tbl f)) (tbl Uninterpreted), HasNormalForm (d f) (tbl f) (tbl Uninterpreted), Constraints (tbl Uninterpreted) (IsRegularField Uninterpreted), StandardInterpretation d (RegularRecordLens tbl f), StandardInterpretation d f) => Proxy d -> tbl (RegularRecordLens tbl f)

-- | Proof that <tt>x</tt> is a regular field
--   
--   See <a>IsRegularField</a>
data RegularField f x
[RegularField] :: RegularField f (f x)

-- | Regular record fields
--   
--   For a higher-kinded record <tt>tbl f</tt>, parameterized over some
--   functor <tt>f</tt>, we say that the fields are <i>regular</i> iff
--   every field has the form <tt>f x</tt> for some <tt>x</tt>.
class IsRegularField f x
isRegularField :: IsRegularField f x => Proxy (f x) -> RegularField f x
data RepLens f a x
[RepLens] :: Lens' (Rep f a) (f x) -> RepLens f a x
repLenses :: Generic a => Rep (RepLens f a) a
genericLens :: Generic a => Lens' a (Rep I a)
normalForm1Lens :: HasNormalForm (d f) (x f) (x Uninterpreted) => Proxy d -> Lens' (Rep I (x f)) (Rep (Interpret (d f)) (x Uninterpreted))
interpretedLens :: Lens' (Interpret d x) (Interpreted d x)
standardInterpretationLens :: forall d f x. StandardInterpretation d f => Proxy d -> Lens' (Interpret (d f) (Uninterpreted x)) (f x)
instance Data.Record.Generic.Lens.VL.IsRegularField f (f x)