| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Data.Record.Plugin.Runtime
Description
Re-exports of types and functions used by generated code
This exports all functionality required by the generated code, with the
exception of GHC generics (name clash with large-records generics).
This follows the structure of Data.Record.Internal.Plugin.RuntimeNames.
Synopsis
- type family Any :: k where ...
- data Constraint
- class Eq a where
- data Int
- class Eq a => Ord a where
- data Proxy (t :: k) = Proxy
- class Show a where
- type Type = Type
- unsafeCoerce :: a -> b
- error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- data Vector a
- fromList :: [a] -> Vector a
- toList :: Vector a -> [a]
- unsafeIndex :: Vector a -> Int -> a
- unsafeUpd :: Vector a -> [(Int, a)] -> Vector a
- class HasField (x :: k) r a | x r -> a where
- hasField :: r -> (a -> r, a)
- data Dict (c :: k -> Constraint) (a :: k)
- data FieldMetadata x where
- FieldMetadata :: forall (name :: Symbol) x. KnownSymbol name => Proxy name -> FieldStrictness -> FieldMetadata x
- data FieldStrictness
- class Generic a where
- type Constraints a :: (Type -> Constraint) -> Constraint
- type MetadataOf a :: [(Symbol, Type)]
- from :: a -> Rep I a
- to :: Rep I a -> a
- dict :: forall (c :: Type -> Constraint). Constraints a c => Proxy c -> Rep (Dict c) a
- metadata :: proxy a -> Metadata a
- data Metadata a = Metadata {}
- newtype Rep (f :: Type -> Type) a = Rep (Vector (f (Any :: Type)))
- newtype ThroughLRGenerics a p = WrapThroughLRGenerics {}
- gcompare :: (Generic a, Constraints a Ord) => a -> a -> Ordering
- geq :: (Generic a, Constraints a Eq) => a -> a -> Bool
- gshowsPrec :: (Generic a, Constraints a Show) => Int -> a -> ShowS
- noInlineUnsafeCo :: a -> b
- dictFor :: c x => Proxy c -> Proxy x -> Dict c x
- repFromVector :: Vector Any -> Rep I a
- repToVector :: Rep I a -> Vector Any
base
type family Any :: k where ... #
The type constructor Any is type to which you can unsafely coerce any
lifted type, and back. More concretely, for a lifted type t and
value x :: t, -- unsafeCoerce (unsafeCoerce x :: Any) :: t is equivalent
to x.
data Constraint #
The kind of constraints, like Show a
The Eq class defines equality (==) and inequality (/=).
All the basic datatypes exported by the Prelude are instances of Eq,
and Eq may be derived for any datatype whose constituents are also
instances of Eq.
The Haskell Report defines no laws for Eq. However, == is customarily
expected to implement an equivalence relationship where two values comparing
equal are indistinguishable by "public" functions, with a "public" function
being one not allowing to see implementation details. For example, for a
type representing non-normalised natural numbers modulo 100, a "public"
function doesn't make the difference between 1 and 201. It is expected to
have the following properties:
Instances
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1].
The exact range for a given implementation can be determined by using
minBound and maxBound from the Bounded class.
Instances
| Bounded Int | Since: base-2.1 |
| Enum Int | Since: base-2.1 |
| Eq Int | |
| Integral Int | Since: base-2.0.1 |
| Data Int | Since: base-4.0.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int # dataTypeOf :: Int -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) # gmapT :: (forall b. Data b => b -> b) -> Int -> Int # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # | |
| Num Int | Since: base-2.1 |
| Ord Int | |
| Read Int | Since: base-2.1 |
| Real Int | Since: base-2.0.1 |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Show Int | Since: base-2.1 |
| Ix Int | Since: base-2.1 |
| Uniquable Int | |
| Outputable Int | |
| Lift Int | |
| Generic1 (URec Int :: k -> Type) | Since: base-4.9.0.0 |
| Foldable (UInt :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
| Traversable (UInt :: Type -> Type) | Since: base-4.9.0.0 |
| Functor (URec Int :: Type -> Type) | Since: base-4.9.0.0 |
| Eq (URec Int p) | Since: base-4.9.0.0 |
| Ord (URec Int p) | Since: base-4.9.0.0 |
| Show (URec Int p) | Since: base-4.9.0.0 |
| Generic (URec Int p) | Since: base-4.9.0.0 |
| data URec Int (p :: k) | Used for marking occurrences of Since: base-4.9.0.0 |
| type Rep1 (URec Int :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Int p) | |
Defined in GHC.Generics | |
The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined datatype whose
constituent types are in Ord. The declared order of the constructors in
the data declaration determines the ordering in derived Ord instances. The
Ordering datatype allows a single comparison to determine the precise
ordering of two objects.
The Haskell Report defines no laws for Ord. However, <= is customarily
expected to implement a non-strict partial order and have the following
properties:
- Transitivity
- if
x <= y && y <= z=True, thenx <= z=True - Reflexivity
x <= x=True- Antisymmetry
- if
x <= y && y <= x=True, thenx == y=True
Note that the following operator interactions are expected to hold:
x >= y=y <= xx < y=x <= y && x /= yx > y=y < xx < y=compare x y == LTx > y=compare x y == GTx == y=compare x y == EQmin x y == if x <= y then x else y=Truemax x y == if x >= y then x else y=True
Note that (7.) and (8.) do not require min and max to return either of
their arguments. The result is merely required to equal one of the
arguments in terms of (==).
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.
Instances
Proxy 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, Proxy :: Proxy aundefined :: a
>>>Proxy :: Proxy (Void, Int -> Int)Proxy
Proxy can even hold types of higher kinds,
>>>Proxy :: Proxy EitherProxy
>>>Proxy :: Proxy FunctorProxy
>>>Proxy :: Proxy complicatedStructureProxy
Constructors
| Proxy |
Instances
| Generic1 (Proxy :: k -> Type) | Since: base-4.6.0.0 |
| Monad (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| Functor (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| Applicative (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| Foldable (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m # foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b # foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b # foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |
| Traversable (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| Alternative (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| MonadPlus (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| Bounded (Proxy t) | Since: base-4.7.0.0 |
| Enum (Proxy s) | Since: base-4.7.0.0 |
| Eq (Proxy s) | Since: base-4.7.0.0 |
| Data t => Data (Proxy t) | Since: base-4.7.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy t -> c (Proxy t) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) # toConstr :: Proxy t -> Constr # dataTypeOf :: Proxy t -> DataType # dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) # dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) # gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # | |
| Ord (Proxy s) | Since: base-4.7.0.0 |
| Read (Proxy t) | Since: base-4.7.0.0 |
| Show (Proxy s) | Since: base-4.7.0.0 |
| Ix (Proxy s) | Since: base-4.7.0.0 |
Defined in Data.Proxy | |
| Generic (Proxy t) | Since: base-4.6.0.0 |
| Semigroup (Proxy s) | Since: base-4.9.0.0 |
| Monoid (Proxy s) | Since: base-4.7.0.0 |
| type Rep1 (Proxy :: k -> Type) | |
| type Rep (Proxy t) | |
Conversion of values to readable Strings.
Derived instances of Show have the following properties, which
are compatible with derived instances of Read:
- The result of
showis a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used. - If the constructor is defined to be an infix operator, then
showsPrecwill produce infix applications of the constructor. - the representation will be enclosed in parentheses if the
precedence of the top-level constructor in
xis less thand(associativity is ignored). Thus, ifdis0then the result is never surrounded in parentheses; ifdis11it is always surrounded in parentheses, unless it is an atomic expression. - If the constructor is defined using record syntax, then
showwill produce the record-syntax form, with the fields given in the same order as the original declaration.
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Show is equivalent to
instance (Show a) => Show (Tree a) where
showsPrec d (Leaf m) = showParen (d > app_prec) $
showString "Leaf " . showsPrec (app_prec+1) m
where app_prec = 10
showsPrec d (u :^: v) = showParen (d > up_prec) $
showsPrec (up_prec+1) u .
showString " :^: " .
showsPrec (up_prec+1) v
where up_prec = 5Note that right-associativity of :^: is ignored. For example,
show(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
Methods
Arguments
| :: Int | the operator precedence of the enclosing
context (a number from |
| -> a | the value to be converted to a |
| -> ShowS |
Instances
unsafeCoerce :: a -> b #
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a #
error stops execution and displays an error message.
vector
Boxed vectors, supporting efficient slicing.
Instances
| Monad Vector | |
| Functor Vector | |
| MonadFix Vector | Instance has same semantics as one for lists Since: vector-0.12.2.0 |
Defined in Data.Vector | |
| MonadFail Vector | Since: vector-0.12.1.0 |
Defined in Data.Vector | |
| Applicative Vector | |
| Foldable Vector | |
Defined in Data.Vector Methods fold :: Monoid m => Vector m -> m # foldMap :: Monoid m => (a -> m) -> Vector a -> m # foldMap' :: Monoid m => (a -> m) -> Vector a -> m # foldr :: (a -> b -> b) -> b -> Vector a -> b # foldr' :: (a -> b -> b) -> b -> Vector a -> b # foldl :: (b -> a -> b) -> b -> Vector a -> b # foldl' :: (b -> a -> b) -> b -> Vector a -> b # foldr1 :: (a -> a -> a) -> Vector a -> a # foldl1 :: (a -> a -> a) -> Vector a -> a # elem :: Eq a => a -> Vector a -> Bool # maximum :: Ord a => Vector a -> a # minimum :: Ord a => Vector a -> a # | |
| Traversable Vector | |
| Alternative Vector | |
| MonadPlus Vector | |
| Eq1 Vector | |
| Ord1 Vector | |
Defined in Data.Vector | |
| Read1 Vector | |
Defined in Data.Vector | |
| Show1 Vector | |
| MonadZip Vector | |
| NFData1 Vector | Since: vector-0.12.1.0 |
Defined in Data.Vector | |
| Vector Vector a | |
Defined in Data.Vector Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) # basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) # basicLength :: Vector a -> Int # basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a # basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () # | |
| IsList (Vector a) | |
| Eq a => Eq (Vector a) | |
| Data a => Data (Vector a) | |
Defined in Data.Vector Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # | |
| Ord a => Ord (Vector a) | |
Defined in Data.Vector | |
| Read a => Read (Vector a) | |
| Show a => Show (Vector a) | |
| Semigroup (Vector a) | |
| Monoid (Vector a) | |
| NFData a => NFData (Vector a) | |
Defined in Data.Vector | |
| type Mutable Vector | |
Defined in Data.Vector | |
| type Item (Vector a) | |
Defined in Data.Vector | |
unsafeIndex :: Vector a -> Int -> a #
O(1) Unsafe indexing without bounds checking
record-hasfield
class HasField (x :: k) r a | x r -> a where #
Constraint representing the fact that the field x can be get and set on
the record type r and has field type a. This constraint will be solved
automatically, but manual instances may be provided as well.
The function should satisfy the invariant:
uncurry ($) (hasField @x r) == r
large-generics
data Dict (c :: k -> Constraint) (a :: k) #
data FieldMetadata x where #
Constructors
| FieldMetadata :: forall (name :: Symbol) x. KnownSymbol name => Proxy name -> FieldStrictness -> FieldMetadata x |
data FieldStrictness #
Constructors
| FieldStrict | |
| FieldLazy |
Associated Types
type Constraints a :: (Type -> Constraint) -> Constraint #
Constraints a c means "all fields of a satisfy c"
type MetadataOf a :: [(Symbol, Type)] #
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 large-generics library, MetadataOf is used in the
definition of HasNormalForm. This constraint is carefully defined to
avoid quadratic code, as described in the presentation
"Avoiding Quadratic Blow-up During Compilation"
https://skillsmatter.com/skillscasts/17262-avoiding-quadratic-blow-up-during-compilation
o The large-records library uses it to provide a compatibility layer
between it and sop-core; this is however only for testing purposes, and
the quadratic code here is simply accepted.
Constructors
| Metadata | |
Fields
| |
newtype Rep (f :: Type -> Type) a #
Representation of some record a
The f parameter describes which functor has been applied to all fields of
the record; in other words Rep I is isomorphic to the record itself.
newtype ThroughLRGenerics a p #
Route from GHC generics to LR generics
Suppose a function such as
allEqualTo :: Eq a => a -> [a] -> Bool allEqualTo x = all (== x)
is instead written as
allEqualTo :: (GHC.Generic a, GHC.GEq' (GHC.Rep a)) => a -> [a] -> Bool allEqualTo x = all (GHC.geqdefault x)
where instead of using an indirection through an auxiliary type class Eq,
it directly assumes GHC.Generics and uses a concrete generic
implementation. Such design is arguably questionable, but for example
beam-core contains many such deeply ingrained assumptions of the
availability of GHC.Generics.
In order to be able to call such a function on a large record Foo,
largeRecord will generate an instance
instance GHC.Generic Foo where type Rep Foo = ThroughLRGenerics Foo from = WrapThroughLRGenerics to = unwrapThroughLRGenerics
For our running example, this instance makes it possible to call allEqualTo
provided we then provide an instance
instance ( LR.Generic a
, LR.Constraints a Eq
) => GHC.GEq' (ThroughLRGenerics a) where
geq' = LR.geq `on` unwrapThroughLRGenericsEffectively, ThroughLRGenerics can be used to redirect a function that uses
GHC generics to a function that uses LR generics.
Constructors
| WrapThroughLRGenerics | |
Fields | |
geq :: (Generic a, Constraints a Eq) => a -> a -> Bool #
Generic equality function
Typical usage:
instance Eq T where (==) = geq
TODO: Should we worry about short-circuiting here?
gshowsPrec :: (Generic a, Constraints a Show) => Int -> a -> ShowS #
Generic definition of showsPrec, compatible with the GHC generated one.
Typical usage:
instance Show T where showsPrec = gshowsPrec
noInlineUnsafeCo :: a -> b #
Avoid potential segfault with ghc < 9.0
See https://gitlab.haskell.org/ghc/ghc/-/issues/16893. 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.