Movatterモバイル変換
[0]ホーム
{-# LANGUAGE CPP #-}{-# LANGUAGE DataKinds #-}{-# LANGUAGE DeriveFunctor #-}{-# LANGUAGE DeriveGeneric #-}{-# LANGUAGE EmptyDataDeriving #-}{-# LANGUAGE FlexibleContexts #-}{-# LANGUAGE FlexibleInstances #-}{-# LANGUAGE GADTs #-}{-# LANGUAGE GeneralizedNewtypeDeriving #-}{-# LANGUAGE KindSignatures #-}{-# LANGUAGE MagicHash #-}{-# LANGUAGE NoImplicitPrelude #-}{-# LANGUAGE PolyKinds #-}{-# LANGUAGE ScopedTypeVariables #-}{-# LANGUAGE StandaloneDeriving #-}{-# LANGUAGE Trustworthy #-}{-# LANGUAGE TypeFamilies #-}{-# LANGUAGE TypeOperators #-}{-# LANGUAGE TypeSynonymInstances #-}{-# LANGUAGE UndecidableInstances #-}------------------------------------------------------------------------------- |-- Module : GHC.Generics-- Copyright : (c) Universiteit Utrecht 2010-2011, University of Oxford 2012-2014-- License : see libraries/base/LICENSE---- Maintainer : libraries@haskell.org-- Stability : internal-- Portability : non-portable---- @since 4.6.0.0---- If you're using @GHC.Generics@, you should consider using the-- <http://hackage.haskell.org/package/generic-deriving> package, which-- contains many useful generic functions.moduleGHC.Generics(-- * Introduction---- |---- Datatype-generic functions are based on the idea of converting values of-- a datatype @T@ into corresponding values of a (nearly) isomorphic type @'Rep' T@.-- The type @'Rep' T@ is-- built from a limited set of type constructors, all provided by this module. A-- datatype-generic function is then an overloaded function with instances-- for most of these type constructors, together with a wrapper that performs-- the mapping between @T@ and @'Rep' T@. By using this technique, we merely need-- a few generic instances in order to implement functionality that works for any-- representable type.---- Representable types are collected in the 'Generic' class, which defines the-- associated type 'Rep' as well as conversion functions 'from' and 'to'.-- Typically, you will not define 'Generic' instances by hand, but have the compiler-- derive them for you.-- ** Representing datatypes---- |---- The key to defining your own datatype-generic functions is to understand how to-- represent datatypes using the given set of type constructors.---- Let us look at an example first:---- @-- data Tree a = Leaf a | Node (Tree a) (Tree a)-- deriving 'Generic'-- @---- The above declaration (which requires the language pragma @DeriveGeneric@)-- causes the following representation to be generated:---- @-- instance 'Generic' (Tree a) where-- type 'Rep' (Tree a) =-- 'D1' ('MetaData \"Tree\" \"Main\" \"package-name\" 'False)-- ('C1' ('MetaCons \"Leaf\" 'PrefixI 'False)-- ('S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- ('Rec0' a))-- ':+:'-- 'C1' ('MetaCons \"Node\" 'PrefixI 'False)-- ('S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- ('Rec0' (Tree a))-- ':*:'-- 'S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- ('Rec0' (Tree a))))-- ...-- @---- /Hint:/ You can obtain information about the code being generated from GHC by passing-- the @-ddump-deriv@ flag. In GHCi, you can expand a type family such as 'Rep' using-- the @:kind!@ command.---- This is a lot of information! However, most of it is actually merely meta-information-- that makes names of datatypes and constructors and more available on the type level.---- Here is a reduced representation for @Tree@ with nearly all meta-information removed,-- for now keeping only the most essential aspects:---- @-- instance 'Generic' (Tree a) where-- type 'Rep' (Tree a) =-- 'Rec0' a-- ':+:'-- ('Rec0' (Tree a) ':*:' 'Rec0' (Tree a))-- @---- The @Tree@ datatype has two constructors. The representation of individual constructors-- is combined using the binary type constructor ':+:'.---- The first constructor consists of a single field, which is the parameter @a@. This is-- represented as @'Rec0' a@.---- The second constructor consists of two fields. Each is a recursive field of type @Tree a@,-- represented as @'Rec0' (Tree a)@. Representations of individual fields are combined using-- the binary type constructor ':*:'.---- Now let us explain the additional tags being used in the complete representation:---- * The @'S1' ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness-- 'DecidedLazy)@ tag indicates several things. The @'Nothing@ indicates-- that there is no record field selector associated with this field of-- the constructor (if there were, it would have been marked @'Just-- \"recordName\"@ instead). The other types contain meta-information on-- the field's strictness:---- * There is no @{\-\# UNPACK \#-\}@ or @{\-\# NOUNPACK \#-\}@ annotation-- in the source, so it is tagged with @'NoSourceUnpackedness@.---- * There is no strictness (@!@) or laziness (@~@) annotation in the-- source, so it is tagged with @'NoSourceStrictness@.---- * The compiler infers that the field is lazy, so it is tagged with-- @'DecidedLazy@. Bear in mind that what the compiler decides may be-- quite different from what is written in the source. See-- 'DecidedStrictness' for a more detailed explanation.---- The @'MetaSel@ type is also an instance of the type class 'Selector',-- which can be used to obtain information about the field at the value-- level.---- * The @'C1' ('MetaCons \"Leaf\" 'PrefixI 'False)@ and-- @'C1' ('MetaCons \"Node\" 'PrefixI 'False)@ invocations indicate that the enclosed part is-- the representation of the first and second constructor of datatype @Tree@, respectively.-- Here, the meta-information regarding constructor names, fixity and whether-- it has named fields or not is encoded at the type level. The @'MetaCons@-- type is also an instance of the type class 'Constructor'. This type class can be used-- to obtain information about the constructor at the value level.---- * The @'D1' ('MetaData \"Tree\" \"Main\" \"package-name\" 'False)@ tag-- indicates that the enclosed part is the representation of the-- datatype @Tree@. Again, the meta-information is encoded at the type level.-- The @'MetaData@ type is an instance of class 'Datatype', which-- can be used to obtain the name of a datatype, the module it has been-- defined in, the package it is located under, and whether it has been-- defined using @data@ or @newtype@ at the value level.-- ** Derived and fundamental representation types---- |---- There are many datatype-generic functions that do not distinguish between positions that-- are parameters or positions that are recursive calls. There are also many datatype-generic-- functions that do not care about the names of datatypes and constructors at all. To keep-- the number of cases to consider in generic functions in such a situation to a minimum,-- it turns out that many of the type constructors introduced above are actually synonyms,-- defining them to be variants of a smaller set of constructors.-- *** Individual fields of constructors: 'K1'---- |---- The type constructor 'Rec0' is a variant of 'K1':---- @-- type 'Rec0' = 'K1' 'R'-- @---- Here, 'R' is a type-level proxy that does not have any associated values.---- There used to be another variant of 'K1' (namely @Par0@), but it has since-- been deprecated.-- *** Meta information: 'M1'---- |---- The type constructors 'S1', 'C1' and 'D1' are all variants of 'M1':---- @-- type 'S1' = 'M1' 'S'-- type 'C1' = 'M1' 'C'-- type 'D1' = 'M1' 'D'-- @---- The types 'S', 'C' and 'D' are once again type-level proxies, just used to create-- several variants of 'M1'.-- *** Additional generic representation type constructors---- |---- Next to 'K1', 'M1', ':+:' and ':*:' there are a few more type constructors that occur-- in the representations of other datatypes.-- **** Empty datatypes: 'V1'---- |---- For empty datatypes, 'V1' is used as a representation. For example,---- @-- data Empty deriving 'Generic'-- @---- yields---- @-- instance 'Generic' Empty where-- type 'Rep' Empty =-- 'D1' ('MetaData \"Empty\" \"Main\" \"package-name\" 'False) 'V1'-- @-- **** Constructors without fields: 'U1'---- |---- If a constructor has no arguments, then 'U1' is used as its representation. For example-- the representation of 'Bool' is---- @-- instance 'Generic' Bool where-- type 'Rep' Bool =-- 'D1' ('MetaData \"Bool\" \"Data.Bool\" \"package-name\" 'False)-- ('C1' ('MetaCons \"False\" 'PrefixI 'False) 'U1' ':+:' 'C1' ('MetaCons \"True\" 'PrefixI 'False) 'U1')-- @-- *** Representation of types with many constructors or many fields---- |---- As ':+:' and ':*:' are just binary operators, one might ask what happens if the-- datatype has more than two constructors, or a constructor with more than two-- fields. The answer is simple: the operators are used several times, to combine-- all the constructors and fields as needed. However, users /should not rely on-- a specific nesting strategy/ for ':+:' and ':*:' being used. The compiler is-- free to choose any nesting it prefers. (In practice, the current implementation-- tries to produce a more-or-less balanced nesting, so that the traversal of-- the structure of the datatype from the root to a particular component can be-- performed in logarithmic rather than linear time.)-- ** Defining datatype-generic functions---- |---- A datatype-generic function comprises two parts:---- 1. /Generic instances/ for the function, implementing it for most of the representation-- type constructors introduced above.---- 2. A /wrapper/ that for any datatype that is in `Generic`, performs the conversion-- between the original value and its `Rep`-based representation and then invokes the-- generic instances.---- As an example, let us look at a function @encode@ that produces a naive, but lossless-- bit encoding of values of various datatypes. So we are aiming to define a function---- @-- encode :: 'Generic' a => a -> [Bool]-- @---- where we use 'Bool' as our datatype for bits.---- For part 1, we define a class @Encode'@. Perhaps surprisingly, this class is parameterized-- over a type constructor @f@ of kind @* -> *@. This is a technicality: all the representation-- type constructors operate with kind @* -> *@ as base kind. But the type argument is never-- being used. This may be changed at some point in the future. The class has a single method,-- and we use the type we want our final function to have, but we replace the occurrences of-- the generic type argument @a@ with @f p@ (where the @p@ is any argument; it will not be used).---- > class Encode' f where-- > encode' :: f p -> [Bool]---- With the goal in mind to make @encode@ work on @Tree@ and other datatypes, we now define-- instances for the representation type constructors 'V1', 'U1', ':+:', ':*:', 'K1', and 'M1'.-- *** Definition of the generic representation types---- |---- In order to be able to do this, we need to know the actual definitions of these types:---- @-- data 'V1' p -- lifted version of Empty-- data 'U1' p = 'U1' -- lifted version of ()-- data (':+:') f g p = 'L1' (f p) | 'R1' (g p) -- lifted version of 'Either'-- data (':*:') f g p = (f p) ':*:' (g p) -- lifted version of (,)-- newtype 'K1' i c p = 'K1' { 'unK1' :: c } -- a container for a c-- newtype 'M1' i t f p = 'M1' { 'unM1' :: f p } -- a wrapper-- @---- So, 'U1' is just the unit type, ':+:' is just a binary choice like 'Either',-- ':*:' is a binary pair like the pair constructor @(,)@, and 'K1' is a value-- of a specific type @c@, and 'M1' wraps a value of the generic type argument,-- which in the lifted world is an @f p@ (where we do not care about @p@).-- *** Generic instances---- |---- The instance for 'V1' is slightly awkward (but also rarely used):---- @-- instance Encode' 'V1' where-- encode' x = undefined-- @---- There are no values of type @V1 p@ to pass (except undefined), so this is-- actually impossible. One can ask why it is useful to define an instance for-- 'V1' at all in this case? Well, an empty type can be used as an argument to-- a non-empty type, and you might still want to encode the resulting type.-- As a somewhat contrived example, consider @[Empty]@, which is not an empty-- type, but contains just the empty list. The 'V1' instance ensures that we-- can call the generic function on such types.---- There is exactly one value of type 'U1', so encoding it requires no-- knowledge, and we can use zero bits:---- @-- instance Encode' 'U1' where-- encode' 'U1' = []-- @---- In the case for ':+:', we produce 'False' or 'True' depending on whether-- the constructor of the value provided is located on the left or on the right:---- @-- instance (Encode' f, Encode' g) => Encode' (f ':+:' g) where-- encode' ('L1' x) = False : encode' x-- encode' ('R1' x) = True : encode' x-- @---- (Note that this encoding strategy may not be reliable across different-- versions of GHC. Recall that the compiler is free to choose any nesting-- of ':+:' it chooses, so if GHC chooses @(a ':+:' b) ':+:' c@, then the-- encoding for @a@ would be @[False, False]@, @b@ would be @[False, True]@,-- and @c@ would be @[True]@. However, if GHC chooses @a ':+:' (b ':+:' c)@,-- then the encoding for @a@ would be @[False]@, @b@ would be @[True, False]@,-- and @c@ would be @[True, True]@.)---- In the case for ':*:', we append the encodings of the two subcomponents:---- @-- instance (Encode' f, Encode' g) => Encode' (f ':*:' g) where-- encode' (x ':*:' y) = encode' x ++ encode' y-- @---- The case for 'K1' is rather interesting. Here, we call the final function-- @encode@ that we yet have to define, recursively. We will use another type-- class @Encode@ for that function:---- @-- instance (Encode c) => Encode' ('K1' i c) where-- encode' ('K1' x) = encode x-- @---- Note how we can define a uniform instance for 'M1', because we completely-- disregard all meta-information:---- @-- instance (Encode' f) => Encode' ('M1' i t f) where-- encode' ('M1' x) = encode' x-- @---- Unlike in 'K1', the instance for 'M1' refers to @encode'@, not @encode@.-- *** The wrapper and generic default---- |---- We now define class @Encode@ for the actual @encode@ function:---- @-- class Encode a where-- encode :: a -> [Bool]-- default encode :: (Generic a, Encode' (Rep a)) => a -> [Bool]-- encode x = encode' ('from' x)-- @---- The incoming @x@ is converted using 'from', then we dispatch to the-- generic instances using @encode'@. We use this as a default definition-- for @encode@. We need the @default encode@ signature because ordinary-- Haskell default methods must not introduce additional class constraints,-- but our generic default does.---- Defining a particular instance is now as simple as saying---- @-- instance (Encode a) => Encode (Tree a)-- @--#if 0-- /TODO:/ Add usage example?--#endif-- The generic default is being used. In the future, it will hopefully be-- possible to use @deriving Encode@ as well, but GHC does not yet support-- that syntax for this situation.---- Having @Encode@ as a class has the advantage that we can define-- non-generic special cases, which is particularly useful for abstract-- datatypes that have no structural representation. For example, given-- a suitable integer encoding function @encodeInt@, we can define---- @-- instance Encode Int where-- encode = encodeInt-- @-- *** Omitting generic instances---- |---- It is not always required to provide instances for all the generic-- representation types, but omitting instances restricts the set of-- datatypes the functions will work for:---- * If no ':+:' instance is given, the function may still work for-- empty datatypes or datatypes that have a single constructor,-- but will fail on datatypes with more than one constructor.---- * If no ':*:' instance is given, the function may still work for-- datatypes where each constructor has just zero or one field,-- in particular for enumeration types.---- * If no 'K1' instance is given, the function may still work for-- enumeration types, where no constructor has any fields.---- * If no 'V1' instance is given, the function may still work for-- any datatype that is not empty.---- * If no 'U1' instance is given, the function may still work for-- any datatype where each constructor has at least one field.---- An 'M1' instance is always required (but it can just ignore the-- meta-information, as is the case for @encode@ above).#if 0-- *** Using meta-information---- |---- TODO#endif-- ** Generic constructor classes---- |---- Datatype-generic functions as defined above work for a large class-- of datatypes, including parameterized datatypes. (We have used @Tree@-- as our example above, which is of kind @* -> *@.) However, the-- 'Generic' class ranges over types of kind @*@, and therefore, the-- resulting generic functions (such as @encode@) must be parameterized-- by a generic type argument of kind @*@.---- What if we want to define generic classes that range over type-- constructors (such as 'Data.Functor.Functor',-- 'Data.Traversable.Traversable', or 'Data.Foldable.Foldable')?-- *** The 'Generic1' class---- |---- Like 'Generic', there is a class 'Generic1' that defines a-- representation 'Rep1' and conversion functions 'from1' and 'to1',-- only that 'Generic1' ranges over types of kind @* -> *@. (More generally,-- it can range over types of kind @k -> *@, for any kind @k@, if the-- @PolyKinds@ extension is enabled. More on this later.)-- The 'Generic1' class is also derivable.---- The representation 'Rep1' is ever so slightly different from 'Rep'.-- Let us look at @Tree@ as an example again:---- @-- data Tree a = Leaf a | Node (Tree a) (Tree a)-- deriving 'Generic1'-- @---- The above declaration causes the following representation to be generated:---- @-- instance 'Generic1' Tree where-- type 'Rep1' Tree =-- 'D1' ('MetaData \"Tree\" \"Main\" \"package-name\" 'False)-- ('C1' ('MetaCons \"Leaf\" 'PrefixI 'False)-- ('S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- 'Par1')-- ':+:'-- 'C1' ('MetaCons \"Node\" 'PrefixI 'False)-- ('S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- ('Rec1' Tree)-- ':*:'-- 'S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- ('Rec1' Tree)))-- ...-- @---- The representation reuses 'D1', 'C1', 'S1' (and thereby 'M1') as well-- as ':+:' and ':*:' from 'Rep'. (This reusability is the reason that we-- carry around the dummy type argument for kind-@*@-types, but there are-- already enough different names involved without duplicating each of-- these.)---- What's different is that we now use 'Par1' to refer to the parameter-- (and that parameter, which used to be @a@), is not mentioned explicitly-- by name anywhere; and we use 'Rec1' to refer to a recursive use of @Tree a@.-- *** Representation of @* -> *@ types---- |---- Unlike 'Rec0', the 'Par1' and 'Rec1' type constructors do not-- map to 'K1'. They are defined directly, as follows:---- @-- newtype 'Par1' p = 'Par1' { 'unPar1' :: p } -- gives access to parameter p-- newtype 'Rec1' f p = 'Rec1' { 'unRec1' :: f p } -- a wrapper-- @---- In 'Par1', the parameter @p@ is used for the first time, whereas 'Rec1' simply-- wraps an application of @f@ to @p@.---- Note that 'K1' (in the guise of 'Rec0') can still occur in a 'Rep1' representation,-- namely when the datatype has a field that does not mention the parameter.---- The declaration---- @-- data WithInt a = WithInt Int a-- deriving 'Generic1'-- @---- yields---- @-- instance 'Generic1' WithInt where-- type 'Rep1' WithInt =-- 'D1' ('MetaData \"WithInt\" \"Main\" \"package-name\" 'False)-- ('C1' ('MetaCons \"WithInt\" 'PrefixI 'False)-- ('S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- ('Rec0' Int)-- ':*:'-- 'S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- 'Par1'))-- @---- If the parameter @a@ appears underneath a composition of other type constructors,-- then the representation involves composition, too:---- @-- data Rose a = Fork a [Rose a]-- @---- yields---- @-- instance 'Generic1' Rose where-- type 'Rep1' Rose =-- 'D1' ('MetaData \"Rose\" \"Main\" \"package-name\" 'False)-- ('C1' ('MetaCons \"Fork\" 'PrefixI 'False)-- ('S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- 'Par1'-- ':*:'-- 'S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- ([] ':.:' 'Rec1' Rose)))-- @---- where---- @-- newtype (':.:') f g p = 'Comp1' { 'unComp1' :: f (g p) }-- @-- *** Representation of @k -> *@ types---- |---- The 'Generic1' class can be generalized to range over types of kind-- @k -> *@, for any kind @k@. To do so, derive a 'Generic1' instance with the-- @PolyKinds@ extension enabled. For example, the declaration---- @-- data Proxy (a :: k) = Proxy deriving 'Generic1'-- @---- yields a slightly different instance depending on whether @PolyKinds@ is-- enabled. If compiled without @PolyKinds@, then @'Rep1' Proxy :: * -> *@, but-- if compiled with @PolyKinds@, then @'Rep1' Proxy :: k -> *@.-- *** Representation of unlifted types---- |---- If one were to attempt to derive a Generic instance for a datatype with an-- unlifted argument (for example, 'Int#'), one might expect the occurrence of-- the 'Int#' argument to be marked with @'Rec0' 'Int#'@. This won't work,-- though, since 'Int#' is of an unlifted kind, and 'Rec0' expects a type of-- kind @*@.---- One solution would be to represent an occurrence of 'Int#' with 'Rec0 Int'-- instead. With this approach, however, the programmer has no way of knowing-- whether the 'Int' is actually an 'Int#' in disguise.---- Instead of reusing 'Rec0', a separate data family 'URec' is used to mark-- occurrences of common unlifted types:---- @-- data family URec a p---- data instance 'URec' ('Ptr' ()) p = 'UAddr' { 'uAddr#' :: 'Addr#' }-- data instance 'URec' 'Char' p = 'UChar' { 'uChar#' :: 'Char#' }-- data instance 'URec' 'Double' p = 'UDouble' { 'uDouble#' :: 'Double#' }-- data instance 'URec' 'Int' p = 'UFloat' { 'uFloat#' :: 'Float#' }-- data instance 'URec' 'Float' p = 'UInt' { 'uInt#' :: 'Int#' }-- data instance 'URec' 'Word' p = 'UWord' { 'uWord#' :: 'Word#' }-- @---- Several type synonyms are provided for convenience:---- @-- type 'UAddr' = 'URec' ('Ptr' ())-- type 'UChar' = 'URec' 'Char'-- type 'UDouble' = 'URec' 'Double'-- type 'UFloat' = 'URec' 'Float'-- type 'UInt' = 'URec' 'Int'-- type 'UWord' = 'URec' 'Word'-- @---- The declaration---- @-- data IntHash = IntHash Int#-- deriving 'Generic'-- @---- yields---- @-- instance 'Generic' IntHash where-- type 'Rep' IntHash =-- 'D1' ('MetaData \"IntHash\" \"Main\" \"package-name\" 'False)-- ('C1' ('MetaCons \"IntHash\" 'PrefixI 'False)-- ('S1' ('MetaSel 'Nothing-- 'NoSourceUnpackedness-- 'NoSourceStrictness-- 'DecidedLazy)-- 'UInt'))-- @---- Currently, only the six unlifted types listed above are generated, but this-- may be extended to encompass more unlifted types in the future.#if 0-- *** Limitations---- |---- /TODO/---- /TODO:/ Also clear up confusion about 'Rec0' and 'Rec1' not really indicating recursion.--#endif------------------------------------------------------------------------------- * Generic representation typesV1,U1(..),Par1(..),Rec1(..),K1(..),M1(..),(:+:)(..),(:*:)(..),(:.:)(..)-- ** Unboxed representation types,URec(..),typeUAddr,typeUChar,typeUDouble,typeUFloat,typeUInt,typeUWord-- ** Synonyms for convenience,Rec0,R,D1,C1,S1,D,C,S-- * Meta-information,Datatype(..),Constructor(..),Selector(..),Fixity(..),FixityI(..),Associativity(..),prec,SourceUnpackedness(..),SourceStrictness(..),DecidedStrictness(..),Meta(..)-- * Generic type classes,Generic(..),Generic1(..))where-- We use some base typesimportData.Either(Either(..))importData.Maybe(Maybe(..),fromMaybe)importData.Ord(Down(..))importGHC.Integer(Integer,integerToInt)importGHC.Prim(Addr#,Char#,Double#,Float#,Int#,Word#)importGHC.Ptr(Ptr)importGHC.Types-- Needed for instancesimportGHC.Ix(Ix)importGHC.Base(Alternative(..),Applicative(..),Functor(..),Monad(..),MonadPlus(..),NonEmpty(..),String,coerce,Semigroup(..),Monoid(..))importGHC.Classes(Eq(..),Ord(..))importGHC.Enum(Bounded,Enum)importGHC.Read(Read(..))importGHC.Show(Show(..),showString)-- Needed for metadataimportData.Proxy(Proxy(..))importGHC.TypeLits(KnownSymbol,KnownNat,symbolVal,natVal)---------------------------------------------------------------------------------- Representation types---------------------------------------------------------------------------------- | Void: used for datatypes without constructorsdataV1(p::k)deriving(Eq-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Read-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0,Generic1-- ^ @since 4.9.0.0)-- | @since 4.12.0.0instanceSemigroup(V1p)whereV1 pv<> :: V1 p -> V1 p -> V1 p<>V1 p_=V1 pv-- | Unit: used for constructors without argumentsdataU1(p::k)=U1deriving(Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | @since 4.9.0.0instanceEq(U1p)whereU1 p_== :: U1 p -> U1 p -> Bool==U1 p_=BoolTrue-- | @since 4.7.0.0instanceOrd(U1p)wherecompare :: U1 p -> U1 p -> OrderingcompareU1 p_U1 p_=OrderingEQ-- | @since 4.9.0.0derivinginstanceRead(U1p)-- | @since 4.9.0.0instanceShow(U1p)whereshowsPrec :: Int -> U1 p -> ShowSshowsPrecInt_U1 p_=String -> ShowSshowStringString"U1"-- | @since 4.9.0.0instanceFunctorU1wherefmap :: (a -> b) -> U1 a -> U1 bfmapa -> b_U1 a_=U1 bforall k (p :: k). U1 pU1-- | @since 4.9.0.0instanceApplicativeU1wherepure :: a -> U1 apurea_=U1 aforall k (p :: k). U1 pU1U1 (a -> b)_<*> :: U1 (a -> b) -> U1 a -> U1 b<*>U1 a_=U1 bforall k (p :: k). U1 pU1liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 cliftA2a -> b -> c_U1 a_U1 b_=U1 cforall k (p :: k). U1 pU1-- | @since 4.9.0.0instanceAlternativeU1whereempty :: U1 aempty=U1 aforall k (p :: k). U1 pU1U1 a_<|> :: U1 a -> U1 a -> U1 a<|>U1 a_=U1 aforall k (p :: k). U1 pU1-- | @since 4.9.0.0instanceMonadU1whereU1 a_>>= :: U1 a -> (a -> U1 b) -> U1 b>>=a -> U1 b_=U1 bforall k (p :: k). U1 pU1-- | @since 4.9.0.0instanceMonadPlusU1-- | @since 4.12.0.0instanceSemigroup(U1p)whereU1 p_<> :: U1 p -> U1 p -> U1 p<>U1 p_=U1 pforall k (p :: k). U1 pU1-- | @since 4.12.0.0instanceMonoid(U1p)wheremempty :: U1 pmempty=U1 pforall k (p :: k). U1 pU1-- | Used for marking occurrences of the parameternewtypePar1p=Par1{Par1 p -> punPar1::p}deriving(Eq-- ^ @since 4.7.0.0,Ord-- ^ @since 4.7.0.0,Read-- ^ @since 4.7.0.0,Show-- ^ @since 4.7.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | @since 4.9.0.0instanceApplicativePar1wherepure :: a -> Par1 apure=a -> Par1 aforall a. a -> Par1 aPar1<*> :: Par1 (a -> b) -> Par1 a -> Par1 b(<*>)=Par1 (a -> b) -> Par1 a -> Par1 bcoerceliftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 cliftA2=(a -> b -> c) -> Par1 a -> Par1 b -> Par1 ccoerce-- | @since 4.9.0.0instanceMonadPar1wherePar1ax>>= :: Par1 a -> (a -> Par1 b) -> Par1 b>>=a -> Par1 bf=a -> Par1 bfax-- | @since 4.12.0.0derivinginstanceSemigroupp=>Semigroup(Par1p)-- | @since 4.12.0.0derivinginstanceMonoidp=>Monoid(Par1p)-- | Recursive calls of kind @* -> *@ (or kind @k -> *@, when @PolyKinds@-- is enabled)newtypeRec1(f::k->Type)(p::k)=Rec1{Rec1 f p -> f punRec1::fp}deriving(Eq-- ^ @since 4.7.0.0,Ord-- ^ @since 4.7.0.0,Read-- ^ @since 4.7.0.0,Show-- ^ @since 4.7.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | @since 4.9.0.0derivinginstanceApplicativef=>Applicative(Rec1f)-- | @since 4.9.0.0derivinginstanceAlternativef=>Alternative(Rec1f)-- | @since 4.9.0.0instanceMonadf=>Monad(Rec1f)whereRec1f ax>>= :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b>>=a -> Rec1 f bf=f b -> Rec1 f bforall k (f :: k -> *) (p :: k). f p -> Rec1 f pRec1(f axf a -> (a -> f b) -> f bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=\aa->Rec1 f b -> f bforall k (f :: k -> *) (p :: k). Rec1 f p -> f punRec1(a -> Rec1 f bfaa))-- | @since 4.9.0.0derivinginstanceMonadPlusf=>MonadPlus(Rec1f)-- | @since 4.12.0.0derivinginstanceSemigroup(fp)=>Semigroup(Rec1fp)-- | @since 4.12.0.0derivinginstanceMonoid(fp)=>Monoid(Rec1fp)-- | Constants, additional parameters and recursion of kind @*@newtypeK1(i::Type)c(p::k)=K1{K1 i c p -> cunK1::c}deriving(Eq-- ^ @since 4.7.0.0,Ord-- ^ @since 4.7.0.0,Read-- ^ @since 4.7.0.0,Show-- ^ @since 4.7.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | @since 4.12.0.0instanceMonoidc=>Applicative(K1ic)wherepure :: a -> K1 i c apurea_=c -> K1 i c aforall k i c (p :: k). c -> K1 i c pK1cforall a. Monoid a => amemptyliftA2 :: (a -> b -> c) -> K1 i c a -> K1 i c b -> K1 i c cliftA2=\a -> b -> c_->(c -> c -> c) -> K1 i c a -> K1 i c b -> K1 i c ccoerce(c -> c -> cforall a. Monoid a => a -> a -> amappend::c->c->c)<*> :: K1 i c (a -> b) -> K1 i c a -> K1 i c b(<*>)=(c -> c -> c) -> K1 i c (a -> b) -> K1 i c a -> K1 i c bcoerce(c -> c -> cforall a. Monoid a => a -> a -> amappend::c->c->c)-- | @since 4.12.0.0derivinginstanceSemigroupc=>Semigroup(K1icp)-- | @since 4.12.0.0derivinginstanceMonoidc=>Monoid(K1icp)-- | @since 4.9.0.0derivinginstanceApplicativef=>Applicative(M1icf)-- | @since 4.9.0.0derivinginstanceAlternativef=>Alternative(M1icf)-- | @since 4.9.0.0derivinginstanceMonadf=>Monad(M1icf)-- | @since 4.9.0.0derivinginstanceMonadPlusf=>MonadPlus(M1icf)-- | @since 4.12.0.0derivinginstanceSemigroup(fp)=>Semigroup(M1icfp)-- | @since 4.12.0.0derivinginstanceMonoid(fp)=>Monoid(M1icfp)-- | Meta-information (constructor names, etc.)newtypeM1(i::Type)(c::Meta)(f::k->Type)(p::k)=M1{M1 i c f p -> f punM1::fp}deriving(Eq-- ^ @since 4.7.0.0,Ord-- ^ @since 4.7.0.0,Read-- ^ @since 4.7.0.0,Show-- ^ @since 4.7.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | Sums: encode choice between constructorsinfixr5:+:data(:+:)(f::k->Type)(g::k->Type)(p::k)=L1(fp)|R1(gp)deriving(Eq-- ^ @since 4.7.0.0,Ord-- ^ @since 4.7.0.0,Read-- ^ @since 4.7.0.0,Show-- ^ @since 4.7.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | Products: encode multiple arguments to constructorsinfixr6:*:data(:*:)(f::k->Type)(g::k->Type)(p::k)=fp:*:gpderiving(Eq-- ^ @since 4.7.0.0,Ord-- ^ @since 4.7.0.0,Read-- ^ @since 4.7.0.0,Show-- ^ @since 4.7.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | @since 4.9.0.0instance(Applicativef,Applicativeg)=>Applicative(f:*:g)wherepure :: a -> (:*:) f g apureaa=a -> f aforall (f :: * -> *) a. Applicative f => a -> f apureaaf a -> g a -> (:*:) f g aforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:a -> g aforall (f :: * -> *) a. Applicative f => a -> f apureaa(f (a -> b)f:*:g (a -> b)g)<*> :: (:*:) f g (a -> b) -> (:*:) f g a -> (:*:) f g b<*>(f ax:*:g ay)=(f (a -> b)ff (a -> b) -> f a -> f bforall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b<*>f ax)f b -> g b -> (:*:) f g bforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:(g (a -> b)gg (a -> b) -> g a -> g bforall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b<*>g ay)liftA2 :: (a -> b -> c) -> (:*:) f g a -> (:*:) f g b -> (:*:) f g cliftA2a -> b -> cf(f aa:*:g ab)(f bx:*:g by)=(a -> b -> c) -> f a -> f b -> f cforall (f :: * -> *) a b c.Applicative f =>(a -> b -> c) -> f a -> f b -> f cliftA2a -> b -> cff aaf bxf c -> g c -> (:*:) f g cforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:(a -> b -> c) -> g a -> g b -> g cforall (f :: * -> *) a b c.Applicative f =>(a -> b -> c) -> f a -> f b -> f cliftA2a -> b -> cfg abg by-- | @since 4.9.0.0instance(Alternativef,Alternativeg)=>Alternative(f:*:g)whereempty :: (:*:) f g aempty=f aforall (f :: * -> *) a. Alternative f => f aemptyf a -> g a -> (:*:) f g aforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:g aforall (f :: * -> *) a. Alternative f => f aempty(f ax1:*:g ay1)<|> :: (:*:) f g a -> (:*:) f g a -> (:*:) f g a<|>(f ax2:*:g ay2)=(f ax1f a -> f a -> f aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>f ax2)f a -> g a -> (:*:) f g aforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:(g ay1g a -> g a -> g aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>g ay2)-- | @since 4.9.0.0instance(Monadf,Monadg)=>Monad(f:*:g)where(f am:*:g an)>>= :: (:*:) f g a -> (a -> (:*:) f g b) -> (:*:) f g b>>=a -> (:*:) f g bf=(f amf a -> (a -> f b) -> f bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=\aa->(:*:) f g b -> f bforall k (f :: k -> *) (g :: k -> *) (p :: k). (:*:) f g p -> f pfstP(a -> (:*:) f g bfaa))f b -> g b -> (:*:) f g bforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:(g ang a -> (a -> g b) -> g bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=\aa->(:*:) f g b -> g bforall k (f :: k -> *) (g :: k -> *) (p :: k). (:*:) f g p -> g psndP(a -> (:*:) f g bfaa))wherefstP :: (:*:) f g p -> f pfstP(f pa:*:g p_)=f pasndP :: (:*:) f g p -> g psndP(f p_:*:g pb)=g pb-- | @since 4.9.0.0instance(MonadPlusf,MonadPlusg)=>MonadPlus(f:*:g)-- | @since 4.12.0.0instance(Semigroup(fp),Semigroup(gp))=>Semigroup((f:*:g)p)where(f px1:*:g py1)<> :: (:*:) f g p -> (:*:) f g p -> (:*:) f g p<>(f px2:*:g py2)=(f px1f p -> f p -> f pforall a. Semigroup a => a -> a -> a<>f px2)f p -> g p -> (:*:) f g pforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:(g py1g p -> g p -> g pforall a. Semigroup a => a -> a -> a<>g py2)-- | @since 4.12.0.0instance(Monoid(fp),Monoid(gp))=>Monoid((f:*:g)p)wheremempty :: (:*:) f g pmempty=f pforall a. Monoid a => amemptyf p -> g p -> (:*:) f g pforall k (f :: k -> *) (g :: k -> *) (p :: k).f p -> g p -> (:*:) f g p:*:g pforall a. Monoid a => amempty-- | Composition of functorsinfixr7:.:newtype(:.:)(f::k2->Type)(g::k1->k2)(p::k1)=Comp1{(:.:) f g p -> f (g p)unComp1::f(gp)}deriving(Eq-- ^ @since 4.7.0.0,Ord-- ^ @since 4.7.0.0,Read-- ^ @since 4.7.0.0,Show-- ^ @since 4.7.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0,Generic1-- ^ @since 4.9.0.0)-- | @since 4.9.0.0instance(Applicativef,Applicativeg)=>Applicative(f:.:g)wherepure :: a -> (:.:) f g apureax=f (g a) -> (:.:) f g aforall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).f (g p) -> (:.:) f g pComp1(g a -> f (g a)forall (f :: * -> *) a. Applicative f => a -> f apure(a -> g aforall (f :: * -> *) a. Applicative f => a -> f apureax))Comp1f (g (a -> b))f<*> :: (:.:) f g (a -> b) -> (:.:) f g a -> (:.:) f g b<*>Comp1f (g a)x=f (g b) -> (:.:) f g bforall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).f (g p) -> (:.:) f g pComp1((g (a -> b) -> g a -> g b) -> f (g (a -> b)) -> f (g a) -> f (g b)forall (f :: * -> *) a b c.Applicative f =>(a -> b -> c) -> f a -> f b -> f cliftA2g (a -> b) -> g a -> g bforall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b(<*>)f (g (a -> b))ff (g a)x)liftA2 :: (a -> b -> c) -> (:.:) f g a -> (:.:) f g b -> (:.:) f g cliftA2a -> b -> cf(Comp1f (g a)x)(Comp1f (g b)y)=f (g c) -> (:.:) f g cforall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).f (g p) -> (:.:) f g pComp1((g a -> g b -> g c) -> f (g a) -> f (g b) -> f (g c)forall (f :: * -> *) a b c.Applicative f =>(a -> b -> c) -> f a -> f b -> f cliftA2((a -> b -> c) -> g a -> g b -> g cforall (f :: * -> *) a b c.Applicative f =>(a -> b -> c) -> f a -> f b -> f cliftA2a -> b -> cf)f (g a)xf (g b)y)-- | @since 4.9.0.0instance(Alternativef,Applicativeg)=>Alternative(f:.:g)whereempty :: (:.:) f g aempty=f (g a) -> (:.:) f g aforall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).f (g p) -> (:.:) f g pComp1f (g a)forall (f :: * -> *) a. Alternative f => f aempty<|> :: (:.:) f g a -> (:.:) f g a -> (:.:) f g a(<|>)=(f (g a) -> f (g a) -> f (g a))-> (:.:) f g a -> (:.:) f g a -> (:.:) f g acoerce(f (g a) -> f (g a) -> f (g a)forall (f :: * -> *) a. Alternative f => f a -> f a -> f a(<|>)::f(ga)->f(ga)->f(ga))::foralla.(f:.:g)a->(f:.:g)a->(f:.:g)a-- | @since 4.12.0.0derivinginstanceSemigroup(f(gp))=>Semigroup((f:.:g)p)-- | @since 4.12.0.0derivinginstanceMonoid(f(gp))=>Monoid((f:.:g)p)-- | Constants of unlifted kinds---- @since 4.9.0.0datafamilyURec(a::Type)(p::k)-- | Used for marking occurrences of 'Addr#'---- @since 4.9.0.0datainstanceURec(Ptr())(p::k)=UAddr{URec (Ptr ()) p -> Addr#uAddr#::Addr#}deriving(Eq-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0,Generic1-- ^ @since 4.9.0.0)-- | Used for marking occurrences of 'Char#'---- @since 4.9.0.0datainstanceURecChar(p::k)=UChar{URec Char p -> Char#uChar#::Char#}deriving(Eq-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0,Generic1-- ^ @since 4.9.0.0)-- | Used for marking occurrences of 'Double#'---- @since 4.9.0.0datainstanceURecDouble(p::k)=UDouble{URec Double p -> Double#uDouble#::Double#}deriving(Eq-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0,Generic1-- ^ @since 4.9.0.0)-- | Used for marking occurrences of 'Float#'---- @since 4.9.0.0datainstanceURecFloat(p::k)=UFloat{URec Float p -> Float#uFloat#::Float#}deriving(URec Float p -> URec Float p -> Bool(URec Float p -> URec Float p -> Bool)-> (URec Float p -> URec Float p -> Bool) -> Eq (URec Float p)forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq aforall k (p :: k). URec Float p -> URec Float p -> Bool/= :: URec Float p -> URec Float p -> Bool$c/= :: forall k (p :: k). URec Float p -> URec Float p -> Bool== :: URec Float p -> URec Float p -> Bool$c== :: forall k (p :: k). URec Float p -> URec Float p -> BoolEq,Eq (URec Float p)Eq (URec Float p)-> (URec Float p -> URec Float p -> Ordering)-> (URec Float p -> URec Float p -> Bool)-> (URec Float p -> URec Float p -> Bool)-> (URec Float p -> URec Float p -> Bool)-> (URec Float p -> URec Float p -> Bool)-> (URec Float p -> URec Float p -> URec Float p)-> (URec Float p -> URec Float p -> URec Float p)-> Ord (URec Float p)URec Float p -> URec Float p -> BoolURec Float p -> URec Float p -> OrderingURec Float p -> URec Float p -> URec Float pforall a.Eq a-> (a -> a -> Ordering)-> (a -> a -> Bool)-> (a -> a -> Bool)-> (a -> a -> Bool)-> (a -> a -> Bool)-> (a -> a -> a)-> (a -> a -> a)-> Ord aforall k (p :: k). Eq (URec Float p)forall k (p :: k). URec Float p -> URec Float p -> Boolforall k (p :: k). URec Float p -> URec Float p -> Orderingforall k (p :: k). URec Float p -> URec Float p -> URec Float pmin :: URec Float p -> URec Float p -> URec Float p$cmin :: forall k (p :: k). URec Float p -> URec Float p -> URec Float pmax :: URec Float p -> URec Float p -> URec Float p$cmax :: forall k (p :: k). URec Float p -> URec Float p -> URec Float p>= :: URec Float p -> URec Float p -> Bool$c>= :: forall k (p :: k). URec Float p -> URec Float p -> Bool> :: URec Float p -> URec Float p -> Bool$c> :: forall k (p :: k). URec Float p -> URec Float p -> Bool<= :: URec Float p -> URec Float p -> Bool$c<= :: forall k (p :: k). URec Float p -> URec Float p -> Bool< :: URec Float p -> URec Float p -> Bool$c< :: forall k (p :: k). URec Float p -> URec Float p -> Boolcompare :: URec Float p -> URec Float p -> Ordering$ccompare :: forall k (p :: k). URec Float p -> URec Float p -> Ordering$cp1Ord :: forall k (p :: k). Eq (URec Float p)Ord,Int -> URec Float p -> ShowS[URec Float p] -> ShowSURec Float p -> String(Int -> URec Float p -> ShowS)-> (URec Float p -> String)-> ([URec Float p] -> ShowS)-> Show (URec Float p)forall a.(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show aforall k (p :: k). Int -> URec Float p -> ShowSforall k (p :: k). [URec Float p] -> ShowSforall k (p :: k). URec Float p -> StringshowList :: [URec Float p] -> ShowS$cshowList :: forall k (p :: k). [URec Float p] -> ShowSshow :: URec Float p -> String$cshow :: forall k (p :: k). URec Float p -> StringshowsPrec :: Int -> URec Float p -> ShowS$cshowsPrec :: forall k (p :: k). Int -> URec Float p -> ShowSShow,Functor-- ^ @since 4.9.0.0,(forall x. URec Float p -> Rep (URec Float p) x)-> (forall x. Rep (URec Float p) x -> URec Float p)-> Generic (URec Float p)forall x. Rep (URec Float p) x -> URec Float pforall x. URec Float p -> Rep (URec Float p) xforall a.(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic aforall k (p :: k) x. Rep (URec Float p) x -> URec Float pforall k (p :: k) x. URec Float p -> Rep (URec Float p) x$cto :: forall k (p :: k) x. Rep (URec Float p) x -> URec Float p$cfrom :: forall k (p :: k) x. URec Float p -> Rep (URec Float p) xGeneric,Generic1-- ^ @since 4.9.0.0)-- | Used for marking occurrences of 'Int#'---- @since 4.9.0.0datainstanceURecInt(p::k)=UInt{URec Int p -> Int#uInt#::Int#}deriving(Eq-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0,Generic1-- ^ @since 4.9.0.0)-- | Used for marking occurrences of 'Word#'---- @since 4.9.0.0datainstanceURecWord(p::k)=UWord{URec Word p -> Word#uWord#::Word#}deriving(Eq-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Functor-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0,Generic1-- ^ @since 4.9.0.0)-- | Type synonym for @'URec' 'Addr#'@---- @since 4.9.0.0typeUAddr=URec(Ptr())-- | Type synonym for @'URec' 'Char#'@---- @since 4.9.0.0typeUChar=URecChar-- | Type synonym for @'URec' 'Double#'@---- @since 4.9.0.0typeUDouble=URecDouble-- | Type synonym for @'URec' 'Float#'@---- @since 4.9.0.0typeUFloat=URecFloat-- | Type synonym for @'URec' 'Int#'@---- @since 4.9.0.0typeUInt=URecInt-- | Type synonym for @'URec' 'Word#'@---- @since 4.9.0.0typeUWord=URecWord-- | Tag for K1: recursion (of kind @Type@)dataR-- | Type synonym for encoding recursion (of kind @Type@)typeRec0=K1R-- | Tag for M1: datatypedataD-- | Tag for M1: constructordataC-- | Tag for M1: record selectordataS-- | Type synonym for encoding meta-information for datatypestypeD1=M1D-- | Type synonym for encoding meta-information for constructorstypeC1=M1C-- | Type synonym for encoding meta-information for record selectorstypeS1=M1S-- | Class for datatypes that represent datatypesclassDatatypedwhere-- | The name of the datatype (unqualified)datatypeName::td(f::k->Type)(a::k)->[Char]-- | The fully-qualified name of the module where the type is declaredmoduleName::td(f::k->Type)(a::k)->[Char]-- | The package name of the module where the type is declared---- @since 4.9.0.0packageName::td(f::k->Type)(a::k)->[Char]-- | Marks if the datatype is actually a newtype---- @since 4.7.0.0isNewtype::td(f::k->Type)(a::k)->BoolisNewtypet d f a_=BoolFalse-- | @since 4.9.0.0instance(KnownSymboln,KnownSymbolm,KnownSymbolp,SingInt)=>Datatype('MetaDatanmpnt)wheredatatypeName :: t ('MetaData n m p nt) f a -> StringdatatypeNamet ('MetaData n m p nt) f a_=Proxy n -> Stringforall (n :: Symbol) (proxy :: Symbol -> *).KnownSymbol n =>proxy n -> StringsymbolVal(Proxy nforall k (t :: k). Proxy tProxy::Proxyn)moduleName :: t ('MetaData n m p nt) f a -> StringmoduleNamet ('MetaData n m p nt) f a_=Proxy m -> Stringforall (n :: Symbol) (proxy :: Symbol -> *).KnownSymbol n =>proxy n -> StringsymbolVal(Proxy mforall k (t :: k). Proxy tProxy::Proxym)packageName :: t ('MetaData n m p nt) f a -> StringpackageNamet ('MetaData n m p nt) f a_=Proxy p -> Stringforall (n :: Symbol) (proxy :: Symbol -> *).KnownSymbol n =>proxy n -> StringsymbolVal(Proxy pforall k (t :: k). Proxy tProxy::Proxyp)isNewtype :: t ('MetaData n m p nt) f a -> BoolisNewtypet ('MetaData n m p nt) f a_=Sing nt -> DemoteRep Boolforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSing(Sing ntforall k (a :: k). SingI a => Sing asing::Singnt)-- | Class for datatypes that represent data constructorsclassConstructorcwhere-- | The name of the constructorconName::tc(f::k->Type)(a::k)->[Char]-- | The fixity of the constructorconFixity::tc(f::k->Type)(a::k)->FixityconFixityt c f a_=FixityPrefix-- | Marks if this constructor is a recordconIsRecord::tc(f::k->Type)(a::k)->BoolconIsRecordt c f a_=BoolFalse-- | @since 4.9.0.0instance(KnownSymboln,SingIf,SingIr)=>Constructor('MetaConsnfr)whereconName :: t ('MetaCons n f r) f a -> StringconNamet ('MetaCons n f r) f a_=Proxy n -> Stringforall (n :: Symbol) (proxy :: Symbol -> *).KnownSymbol n =>proxy n -> StringsymbolVal(Proxy nforall k (t :: k). Proxy tProxy::Proxyn)conFixity :: t ('MetaCons n f r) f a -> FixityconFixityt ('MetaCons n f r) f a_=Sing f -> DemoteRep FixityIforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSing(Sing fforall k (a :: k). SingI a => Sing asing::Singf)conIsRecord :: t ('MetaCons n f r) f a -> BoolconIsRecordt ('MetaCons n f r) f a_=Sing r -> DemoteRep Boolforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSing(Sing rforall k (a :: k). SingI a => Sing asing::Singr)-- | Datatype to represent the fixity of a constructor. An infix-- | declaration directly corresponds to an application of 'Infix'.dataFixity=Prefix|InfixAssociativityIntderiving(Eq-- ^ @since 4.6.0.0,Show-- ^ @since 4.6.0.0,Ord-- ^ @since 4.6.0.0,Read-- ^ @since 4.6.0.0,Generic-- ^ @since 4.7.0.0)-- | This variant of 'Fixity' appears at the type level.---- @since 4.9.0.0dataFixityI=PrefixI|InfixIAssociativityNat-- | Get the precedence of a fixity value.prec::Fixity->Intprec :: Fixity -> IntprecFixityPrefix=Int10prec(InfixAssociativity_Intn)=Intn-- | Datatype to represent the associativity of a constructordataAssociativity=LeftAssociative|RightAssociative|NotAssociativederiving(Eq-- ^ @since 4.6.0.0,Show-- ^ @since 4.6.0.0,Ord-- ^ @since 4.6.0.0,Read-- ^ @since 4.6.0.0,Enum-- ^ @since 4.9.0.0,Bounded-- ^ @since 4.9.0.0,Ix-- ^ @since 4.9.0.0,Generic-- ^ @since 4.7.0.0)-- | The unpackedness of a field as the user wrote it in the source code. For-- example, in the following data type:---- @-- data E = ExampleConstructor Int-- {\-\# NOUNPACK \#-\} Int-- {\-\# UNPACK \#-\} Int-- @---- The fields of @ExampleConstructor@ have 'NoSourceUnpackedness',-- 'SourceNoUnpack', and 'SourceUnpack', respectively.---- @since 4.9.0.0dataSourceUnpackedness=NoSourceUnpackedness|SourceNoUnpack|SourceUnpackderiving(Eq-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Read-- ^ @since 4.9.0.0,Enum-- ^ @since 4.9.0.0,Bounded-- ^ @since 4.9.0.0,Ix-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0)-- | The strictness of a field as the user wrote it in the source code. For-- example, in the following data type:---- @-- data E = ExampleConstructor Int ~Int !Int-- @---- The fields of @ExampleConstructor@ have 'NoSourceStrictness',-- 'SourceLazy', and 'SourceStrict', respectively.---- @since 4.9.0.0dataSourceStrictness=NoSourceStrictness|SourceLazy|SourceStrictderiving(Eq-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Read-- ^ @since 4.9.0.0,Enum-- ^ @since 4.9.0.0,Bounded-- ^ @since 4.9.0.0,Ix-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0)-- | The strictness that GHC infers for a field during compilation. Whereas-- there are nine different combinations of 'SourceUnpackedness' and-- 'SourceStrictness', the strictness that GHC decides will ultimately be one-- of lazy, strict, or unpacked. What GHC decides is affected both by what the-- user writes in the source code and by GHC flags. As an example, consider-- this data type:---- @-- data E = ExampleConstructor {\-\# UNPACK \#-\} !Int !Int Int-- @---- * If compiled without optimization or other language extensions, then the-- fields of @ExampleConstructor@ will have 'DecidedStrict', 'DecidedStrict',-- and 'DecidedLazy', respectively.---- * If compiled with @-XStrictData@ enabled, then the fields will have-- 'DecidedStrict', 'DecidedStrict', and 'DecidedStrict', respectively.---- * If compiled with @-O2@ enabled, then the fields will have 'DecidedUnpack',-- 'DecidedStrict', and 'DecidedLazy', respectively.---- @since 4.9.0.0dataDecidedStrictness=DecidedLazy|DecidedStrict|DecidedUnpackderiving(Eq-- ^ @since 4.9.0.0,Show-- ^ @since 4.9.0.0,Ord-- ^ @since 4.9.0.0,Read-- ^ @since 4.9.0.0,Enum-- ^ @since 4.9.0.0,Bounded-- ^ @since 4.9.0.0,Ix-- ^ @since 4.9.0.0,Generic-- ^ @since 4.9.0.0)-- | Class for datatypes that represent recordsclassSelectorswhere-- | The name of the selectorselName::ts(f::k->Type)(a::k)->[Char]-- | The selector's unpackedness annotation (if any)---- @since 4.9.0.0selSourceUnpackedness::ts(f::k->Type)(a::k)->SourceUnpackedness-- | The selector's strictness annotation (if any)---- @since 4.9.0.0selSourceStrictness::ts(f::k->Type)(a::k)->SourceStrictness-- | The strictness that the compiler inferred for the selector---- @since 4.9.0.0selDecidedStrictness::ts(f::k->Type)(a::k)->DecidedStrictness-- | @since 4.9.0.0instance(SingImn,SingIsu,SingIss,SingIds)=>Selector('MetaSelmnsussds)whereselName :: t ('MetaSel mn su ss ds) f a -> StringselNamet ('MetaSel mn su ss ds) f a_=String -> Maybe String -> Stringforall a. a -> Maybe a -> afromMaybeString""(Sing mn -> DemoteRep (Maybe Symbol)forall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSing(Sing mnforall k (a :: k). SingI a => Sing asing::Singmn))selSourceUnpackedness :: t ('MetaSel mn su ss ds) f a -> SourceUnpackednessselSourceUnpackednesst ('MetaSel mn su ss ds) f a_=Sing su -> DemoteRep SourceUnpackednessforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSing(Sing suforall k (a :: k). SingI a => Sing asing::Singsu)selSourceStrictness :: t ('MetaSel mn su ss ds) f a -> SourceStrictnessselSourceStrictnesst ('MetaSel mn su ss ds) f a_=Sing ss -> DemoteRep SourceStrictnessforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSing(Sing ssforall k (a :: k). SingI a => Sing asing::Singss)selDecidedStrictness :: t ('MetaSel mn su ss ds) f a -> DecidedStrictnessselDecidedStrictnesst ('MetaSel mn su ss ds) f a_=Sing ds -> DemoteRep DecidedStrictnessforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSing(Sing dsforall k (a :: k). SingI a => Sing asing::Singds)-- | 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' ≡ 'Prelude.id'-- 'to' . 'from' ≡ 'Prelude.id'-- @classGenericawhere-- | Generic representation typetypeRepa::Type->Type-- | Convert from the datatype to its representationfrom::a->(Repa)x-- | Convert from the representation to the datatypeto::(Repa)x->a-- | 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' ≡ 'Prelude.id'-- 'to1' . 'from1' ≡ 'Prelude.id'-- @classGeneric1(f::k->Type)where-- | Generic representation typetypeRep1f::k->Type-- | Convert from the datatype to its representationfrom1::fa->(Rep1f)a-- | Convert from the representation to the datatypeto1::(Rep1f)a->fa---------------------------------------------------------------------------------- Meta-data---------------------------------------------------------------------------------- | Datatype to represent metadata associated with a datatype (@MetaData@),-- constructor (@MetaCons@), or field selector (@MetaSel@).---- * In @MetaData n m p nt@, @n@ is the datatype's name, @m@ is the module in-- which the datatype is defined, @p@ is the package in which the datatype-- is defined, and @nt@ is @'True@ if the datatype is a @newtype@.---- * In @MetaCons n f s@, @n@ is the constructor's name, @f@ is its fixity,-- and @s@ is @'True@ if the constructor contains record selectors.---- * In @MetaSel mn su ss ds@, if the field uses record syntax, then @mn@ is-- 'Just' the record name. Otherwise, @mn@ is 'Nothing'. @su@ and @ss@ are-- the field's unpackedness and strictness annotations, and @ds@ is the-- strictness that GHC infers for the field.---- @since 4.9.0.0dataMeta=MetaDataSymbolSymbolSymbolBool|MetaConsSymbolFixityIBool|MetaSel(MaybeSymbol)SourceUnpackednessSourceStrictnessDecidedStrictness---------------------------------------------------------------------------------- Derived instances---------------------------------------------------------------------------------- | @since 4.6.0.0derivinginstanceGeneric[a]-- | @since 4.6.0.0derivinginstanceGeneric(NonEmptya)-- | @since 4.6.0.0derivinginstanceGeneric(Maybea)-- | @since 4.6.0.0derivinginstanceGeneric(Eitherab)-- | @since 4.6.0.0derivinginstanceGenericBool-- | @since 4.6.0.0derivinginstanceGenericOrdering-- | @since 4.6.0.0derivinginstanceGeneric(Proxyt)-- | @since 4.6.0.0derivinginstanceGeneric()-- | @since 4.6.0.0derivinginstanceGeneric((,)ab)-- | @since 4.6.0.0derivinginstanceGeneric((,,)abc)-- | @since 4.6.0.0derivinginstanceGeneric((,,,)abcd)-- | @since 4.6.0.0derivinginstanceGeneric((,,,,)abcde)-- | @since 4.6.0.0derivinginstanceGeneric((,,,,,)abcdef)-- | @since 4.6.0.0derivinginstanceGeneric((,,,,,,)abcdefg)-- | @since 4.12.0.0derivinginstanceGeneric(Downa)-- | @since 4.6.0.0derivinginstanceGeneric1[]-- | @since 4.6.0.0derivinginstanceGeneric1NonEmpty-- | @since 4.6.0.0derivinginstanceGeneric1Maybe-- | @since 4.6.0.0derivinginstanceGeneric1(Eithera)-- | @since 4.6.0.0derivinginstanceGeneric1Proxy-- | @since 4.6.0.0derivinginstanceGeneric1((,)a)-- | @since 4.6.0.0derivinginstanceGeneric1((,,)ab)-- | @since 4.6.0.0derivinginstanceGeneric1((,,,)abc)-- | @since 4.6.0.0derivinginstanceGeneric1((,,,,)abcd)-- | @since 4.6.0.0derivinginstanceGeneric1((,,,,,)abcde)-- | @since 4.6.0.0derivinginstanceGeneric1((,,,,,,)abcdef)-- | @since 4.12.0.0derivinginstanceGeneric1Down---------------------------------------------------------------------------------- Copied from the singletons package---------------------------------------------------------------------------------- | The singleton kind-indexed data family.datafamilySing(a::k)-- | A 'SingI' constraint is essentially an implicitly-passed singleton.classSingI(a::k)where-- | Produce the singleton explicitly. You will likely need the @ScopedTypeVariables@-- extension to use this method the way you want.sing::Singa-- | The 'SingKind' class is essentially a /kind/ class. It classifies all kinds-- for which singletons are defined. The class supports converting between a singleton-- type and the base (unrefined) type which it is built from.classSingKindkwhere-- | Get a base type from a proxy for the promoted kind. For example,-- @DemoteRep Bool@ will be the type @Bool@.typeDemoteRepk::Type-- | Convert a singleton to its unrefined version.fromSing::Sing(a::k)->DemoteRepk-- Singleton symbolsdatainstanceSing(s::Symbol)whereSSym::KnownSymbols=>Sings-- | @since 4.9.0.0instanceKnownSymbola=>SingIawheresing :: Sing asing=Sing aforall (a :: Symbol). KnownSymbol a => Sing aSSym-- | @since 4.9.0.0instanceSingKindSymbolwheretypeDemoteRepSymbol=StringfromSing :: Sing a -> DemoteRep SymbolfromSing(Sing aSSym::Sings)=Proxy a -> Stringforall (n :: Symbol) (proxy :: Symbol -> *).KnownSymbol n =>proxy n -> StringsymbolVal(Proxy aforall k (t :: k). Proxy tProxy::Proxys)-- Singleton booleansdatainstanceSing(a::Bool)whereSTrue::Sing'TrueSFalse::Sing'False-- | @since 4.9.0.0instanceSingI'Truewheresing :: Sing 'Truesing=Sing 'TrueSTrue-- | @since 4.9.0.0instanceSingI'Falsewheresing :: Sing 'Falsesing=Sing 'FalseSFalse-- | @since 4.9.0.0instanceSingKindBoolwheretypeDemoteRepBool=BoolfromSing :: Sing a -> DemoteRep BoolfromSingSing aSTrue=BoolDemoteRep BoolTruefromSingSing aSFalse=BoolDemoteRep BoolFalse-- Singleton MaybedatainstanceSing(b::Maybea)whereSNothing::Sing'NothingSJust::Singa->Sing('Justa)-- | @since 4.9.0.0instanceSingI'Nothingwheresing :: Sing 'Nothingsing=Sing 'Nothingforall a. Sing 'NothingSNothing-- | @since 4.9.0.0instanceSingIa=>SingI('Justa)wheresing :: Sing ('Just a)sing=Sing a -> Sing ('Just a)forall a (a :: a). Sing a -> Sing ('Just a)SJustSing aforall k (a :: k). SingI a => Sing asing-- | @since 4.9.0.0instanceSingKinda=>SingKind(Maybea)wheretypeDemoteRep(Maybea)=Maybe(DemoteRepa)fromSing :: Sing a -> DemoteRep (Maybe a)fromSingSing aSNothing=DemoteRep (Maybe a)forall a. Maybe aNothingfromSing(SJusta)=DemoteRep a -> Maybe (DemoteRep a)forall a. a -> Maybe aJust(Sing a -> DemoteRep aforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSingSing aa)-- Singleton FixitydatainstanceSing(a::FixityI)whereSPrefix::Sing'PrefixISInfix::Singa->Integer->Sing('InfixIan)-- | @since 4.9.0.0instanceSingI'PrefixIwheresing :: Sing 'PrefixIsing=Sing 'PrefixISPrefix-- | @since 4.9.0.0instance(SingIa,KnownNatn)=>SingI('InfixIan)wheresing :: Sing ('InfixI a n)sing=Sing a -> Integer -> Sing ('InfixI a n)forall (a :: Associativity) (n :: Nat).Sing a -> Integer -> Sing ('InfixI a n)SInfix(Sing aforall k (a :: k). SingI a => Sing asing::Singa)(Proxy n -> Integerforall (n :: Nat) (proxy :: Nat -> *).KnownNat n =>proxy n -> IntegernatVal(Proxy nforall k (t :: k). Proxy tProxy::Proxyn))-- | @since 4.9.0.0instanceSingKindFixityIwheretypeDemoteRepFixityI=FixityfromSing :: Sing a -> DemoteRep FixityIfromSingSing aSPrefix=DemoteRep FixityIFixityPrefixfromSing(SInfixan)=Associativity -> Int -> FixityInfix(Sing a -> DemoteRep Associativityforall k (a :: k). SingKind k => Sing a -> DemoteRep kfromSingSing aa)(Int# -> IntI#(Integer -> Int#integerToIntIntegern))-- Singleton AssociativitydatainstanceSing(a::Associativity)whereSLeftAssociative::Sing'LeftAssociativeSRightAssociative::Sing'RightAssociativeSNotAssociative::Sing'NotAssociative-- | @since 4.9.0.0instanceSingI'LeftAssociativewheresing :: Sing 'LeftAssociativesing=Sing 'LeftAssociativeSLeftAssociative-- | @since 4.9.0.0instanceSingI'RightAssociativewheresing :: Sing 'RightAssociativesing=Sing 'RightAssociativeSRightAssociative-- | @since 4.9.0.0instanceSingI'NotAssociativewheresing :: Sing 'NotAssociativesing=Sing 'NotAssociativeSNotAssociative-- | @since 4.0.0.0instanceSingKindAssociativitywheretypeDemoteRepAssociativity=AssociativityfromSing :: Sing a -> DemoteRep AssociativityfromSingSing aSLeftAssociative=DemoteRep AssociativityAssociativityLeftAssociativefromSingSing aSRightAssociative=DemoteRep AssociativityAssociativityRightAssociativefromSingSing aSNotAssociative=DemoteRep AssociativityAssociativityNotAssociative-- Singleton SourceUnpackednessdatainstanceSing(a::SourceUnpackedness)whereSNoSourceUnpackedness::Sing'NoSourceUnpackednessSSourceNoUnpack::Sing'SourceNoUnpackSSourceUnpack::Sing'SourceUnpack-- | @since 4.9.0.0instanceSingI'NoSourceUnpackednesswheresing :: Sing 'NoSourceUnpackednesssing=Sing 'NoSourceUnpackednessSNoSourceUnpackedness-- | @since 4.9.0.0instanceSingI'SourceNoUnpackwheresing :: Sing 'SourceNoUnpacksing=Sing 'SourceNoUnpackSSourceNoUnpack-- | @since 4.9.0.0instanceSingI'SourceUnpackwheresing :: Sing 'SourceUnpacksing=Sing 'SourceUnpackSSourceUnpack-- | @since 4.9.0.0instanceSingKindSourceUnpackednesswheretypeDemoteRepSourceUnpackedness=SourceUnpackednessfromSing :: Sing a -> DemoteRep SourceUnpackednessfromSingSing aSNoSourceUnpackedness=DemoteRep SourceUnpackednessSourceUnpackednessNoSourceUnpackednessfromSingSing aSSourceNoUnpack=DemoteRep SourceUnpackednessSourceUnpackednessSourceNoUnpackfromSingSing aSSourceUnpack=DemoteRep SourceUnpackednessSourceUnpackednessSourceUnpack-- Singleton SourceStrictnessdatainstanceSing(a::SourceStrictness)whereSNoSourceStrictness::Sing'NoSourceStrictnessSSourceLazy::Sing'SourceLazySSourceStrict::Sing'SourceStrict-- | @since 4.9.0.0instanceSingI'NoSourceStrictnesswheresing :: Sing 'NoSourceStrictnesssing=Sing 'NoSourceStrictnessSNoSourceStrictness-- | @since 4.9.0.0instanceSingI'SourceLazywheresing :: Sing 'SourceLazysing=Sing 'SourceLazySSourceLazy-- | @since 4.9.0.0instanceSingI'SourceStrictwheresing :: Sing 'SourceStrictsing=Sing 'SourceStrictSSourceStrict-- | @since 4.9.0.0instanceSingKindSourceStrictnesswheretypeDemoteRepSourceStrictness=SourceStrictnessfromSing :: Sing a -> DemoteRep SourceStrictnessfromSingSing aSNoSourceStrictness=DemoteRep SourceStrictnessSourceStrictnessNoSourceStrictnessfromSingSing aSSourceLazy=DemoteRep SourceStrictnessSourceStrictnessSourceLazyfromSingSing aSSourceStrict=DemoteRep SourceStrictnessSourceStrictnessSourceStrict-- Singleton DecidedStrictnessdatainstanceSing(a::DecidedStrictness)whereSDecidedLazy::Sing'DecidedLazySDecidedStrict::Sing'DecidedStrictSDecidedUnpack::Sing'DecidedUnpack-- | @since 4.9.0.0instanceSingI'DecidedLazywheresing :: Sing 'DecidedLazysing=Sing 'DecidedLazySDecidedLazy-- | @since 4.9.0.0instanceSingI'DecidedStrictwheresing :: Sing 'DecidedStrictsing=Sing 'DecidedStrictSDecidedStrict-- | @since 4.9.0.0instanceSingI'DecidedUnpackwheresing :: Sing 'DecidedUnpacksing=Sing 'DecidedUnpackSDecidedUnpack-- | @since 4.9.0.0instanceSingKindDecidedStrictnesswheretypeDemoteRepDecidedStrictness=DecidedStrictnessfromSing :: Sing a -> DemoteRep DecidedStrictnessfromSingSing aSDecidedLazy=DemoteRep DecidedStrictnessDecidedStrictnessDecidedLazyfromSingSing aSDecidedStrict=DemoteRep DecidedStrictnessDecidedStrictnessDecidedStrictfromSingSing aSDecidedUnpack=DemoteRep DecidedStrictnessDecidedStrictnessDecidedUnpack
[8]ページ先頭