!QB      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None&',-./=>?@AHSUVXekLA.  row-types)A lower fixity operator for type equality row-typesThere doesn't seem to be a ( =.?) :: Symbol -H Symbol -> Bool, so here it is in terms of other ghc-7.8 type functions row-typesKReturns the left list with all of the elements from the right list removed. row-types"Type level Row modification helper  row-typesfZips two rows together to create a Row of the pairs. The two rows must have the same set of labels.  row-typesCTake a row of type operators and apply each to the second argument.  row-typesnTake two rows with the same labels, and apply the type operator from the first row to the type of the second.  row-types%Map a type level function over a Row. row-types A type synonym for disjointness. row-types(Is the first row a subset of the second? row-types)Are all of the labels in this Row unique? row-types4A convenient way to provide common, easy constraints row-typesThe labels in a Row. row-typesA pair of constraints row-types"A null constraint of two arguments row-types!A null constraint of one argument row-typesA null constraint row-typesAny structure over two rows in which the elements of each row satisfy some constraints can be metamorphized into another structure over both of the rows. row-typesQA metamorphism is an anamorphism (an unfold) followed by a catamorphism (a fold). row-typesAny structure over a row in which every element is similarly constrained can be metamorphized into another structure over the same row. row-typesaA metamorphism is an anamorphism (an unfold) followed by a catamorphism (a fold). The parameter pM describes the output of the unfold and the input of the fold. For records, p = (,)l, because every entry in the row will unfold to a value paired with the rest of the record. For variants,  p = EitherE, because there will either be a value or future types to explore. 9 can be useful when the types in the row are unnecessary. row-typesA class wrapper for . row-typesBA dictionary of information that proves that extending a row-type r with a label l will necessarily put it to the front of the underlying row-type list. This is quite internal and should not generally be necessary. row-types+A type level way to create a singleton Row.  row-types Alias for  (r .! l) "H aK. It is a class rather than an alias, so that it can be partially applied.! row-types Alias for +K. It is a class rather than an alias, so that it can be partially applied." row-typesjThe overwriting union, where the left row overwrites the types of the right row where the labels overlap.# row-types!The minimum join of the two rows.$ row-typesType level Row append% row-types%Type level Row difference. That is, l % r? is the row remaining after removing any matching elements of r from l.& row-typesType level Row element removal' row-typesType level label fetching( row-typesType level row renaming) row-typesType level Row modification* row-typesType level Row extension+ row-types>Does the row lack (i.e. it does not have) the specified label?, row-types1Elements stored in a Row type are usually hidden.. row-typesType level version of empty/ row-typesA label1 row-typesOThe kind of elements of rows. Each element is a label and its associated type.3 row-typesThe kind of rows. This type is only used as a datakind. A row is a typelevel entity telling us which symbols are associated with which types.4 row-typesA row is a list of symbol-to-type pairs that should always be sorted lexically by the symbol. The constructor is exported here (because this is an internal module) but should not be exported elsewhere.5 row-types$A helper function for showing labels6 row-types0A helper function to turn a Label directly into .7 row-types*Return a list of the labels in a row type.8 row-typesDReturn a list of the labels in a row type and is specialized to the  constraint. row-types&The way to transform the empty element row-types The unfold row-typesThe fold row-typesThe input structure1  !"#$%&'()*+,-./012345678134/012.,-*)('&%$#"!+  7856 47"6#6$6%6&6'5+4None&',-.=>?@AHSUVXekm%G row-typesH can be used when a N constraint is necessary but there is no particular constraint we care about.H row-typesH can be used when a N constraint is necessary but there is no particular constraint we care about. row-typesAn internal type used by the  in R. row-typesAn internal type used by the  in Q.I row-typesA class to capture the idea of K3 so that it can be partially applied in a context.K row-typesLike O0, but here we know the underlying value is some f applied to the given type a.M row-typesA class to capture the idea of O3 so that it can be partially applied in a context.O row-types{This data type is used to for its ability to existentially bind a type variable. Particularly, it says that for the type a, there exists a t such that a ~ f t and c t holds.Q row-typesThis allows us to derive a Forall (Map f r) .. from a  Forall r ...R row-typesThis allows us to derive a Forall (ApSingle f r) .. from a  Forall f ...S row-types Allow any  over a row-type, be usable for .T row-typesIf we know that r has been extended with l .== t1, then we know that this extension at the label l must be t.U row-typesThis allows us to derive Map f r .! l "H f t from  r .! l "H tV row-typesThis allows us to derive Ap   .! l "H f t from   .! l "H f and   .! l "H tW row-typesThis allows us to derive ApSingle r x .! l "H f x from  r .! l "H fX row-typesProof that the  1 type family preserves labels and their ordering.Y row-typesProof that the  1 type family preserves labels and their ordering.Z row-typesProof that the  1 type family preserves labels and their ordering.[ row-typesProof that the  1 type family preserves labels and their ordering.\ row-types#Map preserves uniqueness of labels.] row-types"Ap preserves uniqueness of labels.^ row-types(ApSingle preserves uniqueness of labels._ row-types#Zip preserves uniqueness of labels.$GHIJKLMNOPQRSTUVWXYZ[\]^_$\]^_TUVWXYZ[HGSQRMNOPIJKLNone%&',-.=>?@AHSUVXegk; row-typesxConversion helper to bring a record back into a Haskell type. Note that the native Haskell type must be an instance of Generic. row-typesxConversion helper to bring a record back into a Haskell type. Note that the native Haskell type must be an instance of Generic. row-typesConversion helper to turn a Haskell record into a row-types extensible record. Note that the native Haskell type must be an instance of Generic. row-typesGRZipPair is used internally as a type level lambda for zipping records. row-typesHRMap is used internally as a type level lambda for defining record maps.f row-typesA record with row r.g row-types?A pattern version of record union, for use in pattern matching.h row-typesA pattern for the singleton record; can be used to both destruct a record when in a pattern position or construct one in an expression position.i row-typesThe empty recordj row-typesThe singleton recordk row-types<Turns a singleton record into a pair of the label and value.l row-types~Record extension. The row may already contain the label, in which case the origin value can be obtained after restriction (&) with the label.m row-types+Update the value associated with the label.n row-types-Focus on the value associated with the label.o row-typesFocus on a sub-recordp row-typesRename a label.q row-typesRecord selectionr row-types7Record restriction. Remove the label l from the record.s row-types#Record disjoint union (commutative)t row-typesRecord overwrite.The operation r .// r' creates a new record such that:Any label that is in both r and r'N is in the resulting record with the type and value given by the fields in r, Any label that is only found in r is in the resulting record. Any label that is only found in r' is in the resulting record.This can be thought of as r "overwriting" r'.u row-types$Split a record into two sub-records.v row-typesEArbitrary record restriction. Turn a record into a subset of itself.w row-typesIRemoves a label from the record but does not remove the underlying value.,This is faster than regular record removal (&), but it has two downsides: DIt may incur a performance penalty during a future merge operation ($), and^It will keep the reference to the value alive, meaning that it will not get garbage collected.Thus, it's great when one knows ahead of time that no future merges will happen and that the whole record will be GC'd soon, for instance, during the catamorphism function of . row-typesThis is the same as (lazyRemove l r, r .! l).x row-types Kind of like  for functions over records.y row-typesThis function allows one to do partial application on a function of a record. Note that this also means that arguments can be supplied in arbitrary order. For instance, if one had a function like !xtheny r = (r .! #x) <> (r .! #y)and a record like -greeting = #x .== "hello " .+ #y .== "world!",Then all of the following would be possible:xtheny greeting"hello world!"2xtheny .$ (#x, greeting) .$ (#y, greeting) $ empty"hello world!"2xtheny .$ (#y, greeting) .$ (#x, greeting) $ empty"hello world!";xtheny .$ (#y, greeting) .$ (#x, #x .== "Goodbye ") $ empty"Goodbye world!"z row-typesA standard fold{ row-typesA fold with labels| row-types+A fold over two row type structures at once} row-typesTurns a record into a D from values representing the labels to the values of the record.~ row-types3A function to map over a record given a constraint. row-types5A function to map over a Ap record given constraints. row-types4A function to map over a record given no constraint. row-typeswLifts a natural transformation over a record. In other words, it acts as a record transformer to convert a record of f a values to a record of g aQ values. If no constraint is needed, instantiate the first type argument with  or use . row-types A version of ! for when there is no constraint. row-typesZip together two records that are the same up to the type being mapped over them, combining their constituent fields with the given function. row-types A version of ! for when there is no constraint. row-types~Traverse a function over a record. Note that the fields of the record will be accessed in lexicographic order by the labels. row-typesTraverse a function over a Mapped record. Note that the fields of the record will be accessed in lexicographic order by the labels. row-types A version of  in which the constraint for  can be chosen. row-types%Applicative sequencing over a record. row-types'This function acts as the inversion of 6, allowing one to move a functor level into a record. row-types A version of  in which the constraint for  can be chosen. row-typesConvert from a record where two functors have been mapped over the types to one where the composition of the two functors is mapped over the types. row-types A version of  in which the constraint for  can be chosen. row-typesConvert from a record where the composition of two functors have been mapped over the types to one where the two functors are mapped individually one at a time over the types. row-types4Coerce a record to a coercible representation. The ; in the context indicates that the type of every field in r1< can be coerced to the type of the corresponding fields in r2.*Internally, this is implemented just with :, but we provide the following implementation as a proof: newtype ConstR a b = ConstR (Rec a) newtype FlipConstR a b = FlipConstR { unFlipConstR :: Rec b } coerceRec :: forall r1 r2. BiForall r1 r2 Coercible => Rec r1 -> Rec r2 coerceRec = unFlipConstR . biMetamorph @_ @_ @r1 @r2 @Coercible @(,) @ConstR @FlipConstR @Const Proxy doNil doUncons doCons . ConstR where doNil _ = FlipConstR empty doUncons l (ConstR r) = bimap ConstR Const $ lazyUncons l r doCons :: forall ! 1 2 1 2. (KnownSymbol !, Coercible 1 2) => Label ! -> (FlipConstR 1 2, Const 1 2) -> FlipConstR (Extend ! 1 1) (Extend ! 2 2) doCons l (FlipConstR r, Const v) = FlipConstR $ extend l (coerce @1 @2 v) r row-types;Zips together two records that have the same set of labels. row-types7Initialize a record with a default value at each label. row-typesFInitialize a record with a default value at each label; works over an  . row-typeshInitialize a record, where each value is determined by the given function over the label at that value. row-typesInitialize a record, where each value is determined by the given function over the label at that value. This function works over an  . row-typesInitialize a record over a  . row-types Converts a f into a  of  s. row-types Produces a f from a  of  s. row-types,Convert a Haskell record to a row-types Rec. row-types<Convert a record to an exactly matching native Haskell type. row-types*Convert a record to a native Haskell type. row-types.Every field in a row-types based record has a   instance.R  !"$&'()*+./0378bcdefghijklmnopqrstuvwxyz{|}~R/0f3. ijhkl*!+&rwvumno)p( 'q$sg"txydcbe ~z{|} 78g6h7j7r6s6y2None%&',-./=>?@AHSUVX_efgk6 -  row-typesConversion helper to turn a Haskell variant into a row-types extensible variant. Note that the native Haskell type must be an instance of Generic.  row-typesConversion helper to turn a Haskell variant into a row-types extensible variant. Note that the native Haskell type must be an instance of Generic. row-typesyConversion helper to bring a variant back into a Haskell type. Note that the native Haskell type must be an instance of Generic. row-typesIVMap is used internally as a type level lambda for defining variant maps. row-typesThe variant type. row-typesA pattern for variants; can be used to both destruct a variant when in a pattern position or construct one in an expression position. row-types)A Variant with no options is uninhabited. row-types2A quick constructor to create a singleton variant. row-types*A quick destructor for singleton variants. row-types*Make the variant arbitrarily more diverse. row-typesA weaker version of , but it's helpful for  as it explicitly uses *. row-types_If the variant exists at the given label, update it to the given value. Otherwise, do nothing. row-typeshIf the variant exists at the given label, focus on the value associated with it. Otherwise, do nothing. row-typesRename the given label. row-typesConvert a variant into either the value at the given label or a variant without that label. This is the basic variant destructor. row-types A version of # that ignores the leftover variant. row-typesA trial over multiple types row-typesXA convenient function for using view patterns when dispatching variants. For example:  myShow :: Var ("y" '::= String :| "x" '::= Int :| Empty) -> String myShow (view x -> Just n) = "Int of "++show n myShow (view y -> Just s) = "String of "++s row-types&Split a variant into two sub-variants. row-typesGArbitrary variant restriction. Turn a variant into a subset of itself. row-typesA standard fold row-typesA fold with labels row-types*A fold over two variants at once. A call eraseZipGeneral f x y will return f (Left (show l, a, b)) when x and y$ both have values at the same label l and will return &f (Right ((show l1, a), (show l2, b))), when they have values at different labels l1 and l2 respectively. row-types(A simpler fold over two variants at once row-types4A function to map over a variant given a constraint. row-types5A function to map over a variant given no constraint. row-typeszLifts a natrual transformation over a variant. In other words, it acts as a variant transformer to convert a variant of f a values to a variant of g aQ values. If no constraint is needed, instantiate the first type argument with . row-types A form of  transformC# that doesn't have a constraint on a row-types#Traverse a function over a variant. row-types*Traverse a function over a Mapped variant. row-types@Applicative sequencing over a variant with arbitrary constraint. row-types%Applicative sequencing over a variant row-typesConvert from a variant where two functors have been mapped over the types to one where the composition of the two functors is mapped over the types. row-types A version of % that allows an arbitrary constraint. row-typesConvert from a variant where the composition of two functors have been mapped over the types to one where the two functors are mapped individually one at a time over the types. row-types5Coerce a variant to a coercible representation. The : in the context indicates that the type of any option in r1< can be coerced to the type of the corresponding option in r2.*Internally, this is implemented just with :, but we provide the following implementation as a proof: /newtype ConstV a b = ConstV { unConstV :: Var a } newtype ConstV a b = FlipConstV { unFlipConstV :: Var b } coerceVar :: forall r1 r2. BiForall r1 r2 Coercible => Var r1 -> Var r2 coerceVar = unFlipConstV . biMetamorph @_ @_ @r1 @r2 @Coercible @Either @ConstV @FlipConstV @Const Proxy doNil doUncons doCons . ConstV where doNil = impossible . unConstV doUncons l = bimap ConstV Const . flip trial l . unConstV doCons :: forall ! 1 2 1 2. (KnownSymbol !, Coercible 1 2, AllUniqueLabels (Extend ! 2 2)) => Label ! -> Either (FlipConstV 1 2) (Const 1 2) -> FlipConstV (Extend ! 1 1) (Extend ! 2 2) doCons l (Left (FlipConstV v)) = FlipConstV $ extend @2 l v doCons l (Right (Const x)) = FlipConstV $ IsJust l (coerce @1 @2 x) \\ extendHas @2 @! @2 row-typesInitialize a variant from a producer function that accepts labels. If this function returns more than one possibility, then one is chosen arbitrarily to be the value in the variant. row-typesInitialize a variant over a  . row-types A version of K that works even when the row-type of the variant argument is of the form  ApSingle fs x. row-types'Performs a functorial-like map over an  U variant. In other words, it acts as a variant transformer to convert a variant of f x values to a variant of f yP values. If no constraint is needed, instantiate the first type argument with . row-types A version of N that works even when the row-types of the variant arguments are of the form  ApSingle fs x. row-types+Convert a variant to a native Haskell type. row-types-Convert a Haskell variant to a row-types Var. row-types-Convert a Haskell variant to a row-types Var. row-types6Every possibility of a row-types based variant has an  instance.@  !#$%&'()+./037@/03. +!#$)('&% 7None&'-.=>?@ACHUVXek@ row-typesLike Const$ but for two ignored type arguments. row-types!A pair of a record and a variant. row-typesLA simple class that we use to provide a constraint for function application. row-typesA  and a f can combine if their rows line up properly. Given a Variant along with a Record of functions from each possible value of the variant to a single output type, apply the correct function to the value in the variant. row-types The same as % but with the argument order reversedNone &'.UVXegkA?*  !"#$%&'+./037GHfghijqrst*/0f3. !+$#%"HGijh&r'qsgt7       !"#$%&''()*+,-./012345567789:;<=>?@ABCDEFGHIJKLMNOPQRRSTUUVWXYZ[\]^_`abcdefghijklmn(opqrst0/-+uvwxyz{|}~ihjopqrtuvz{|~(row-types-1.0.0.0-ENQ3sIzuOF8CnkPoEn9mMSData.Row.InternalData.Row.DictionariesData.Row.RecordsData.Row.VariantsData.Row.SwitchData.Rowbase GHC.TypeLits KnownSymbol'constraints-0.12-9r4GNEjfdu11xgOuzOy6H1Data.Constraint\\withDictDictevidenceHasDictSub:-≈ZipApSingleApMapDisjointSubsetAllUniqueLabels WellBehavedLabels BiConstraintUnconstrained2Unconstrained1 UnconstrainedBiForall biMetamorphForall metamorph FrontExtendsfrontExtendsDictFrontExtendsDict.==HasTypeLacks.//.\/.+.\\.-.!RenameModifyExtend.\HideTypeEmptyLabelLT:->RowRshow'toKeylabelslabels' $fShowLabel$fUnconstrained$fUnconstrained1ka$fUnconstrained2kkab$fBiConstraintkkc1c2xy $fLackslr$fIsLabelxLabel$fFrontExtendskltr $fHasTypeklar$fBiForallk1k2RRc$fBiForallk1k2RRc1 $fForallkRc $fForallkRc0 $fEqLabel FreeBiForall FreeForallActsOnactsOnAs'IsAasAs mapForallapSingleForall freeForall extendHasmapHasapHas apSingleHas mapExtendSwap apExtendSwapapSingleExtendSwap zipExtendSwap uniqueMapuniqueApuniqueApSingle uniqueZip $fIsAkkcff $fActsOnkkctfToNativeGeneralToNative FromNative NativeRowRec:+:==empty unSingletonextendupdatefocus multifocusrenamesplitrestrict lazyRemovecurryRec.$eraseeraseWithLabelseraseZiperaseToHashMapmapmapFmap' transform transform' zipTransform zipTransform'traverse traverseMap sequence'sequence distributecompose'compose uncompose' uncompose coerceReczipdefault'defaultA fromLabels fromLabelsAfromLabelsMapA toDynamicMapfromDynamicMap fromNativetoNativetoNativeGeneral$fHasField'nameReca$fHasFieldnameRecRecab $fNFDataRec $fBoundedRec$fOrdRec$fEqRec $fShowRec $fGenericRecR$fGenericRecR0$fGenericRecR1 $fGenericRec$fFromNativeGk:*:$fFromNativeGkM1$fFromNativeGkU1$fFromNativeGkM10$fFromNativeGkM11$fToNativeGk:*:$fToNativeGkM1$fToNativeGkU1$fToNativeGkM10$fToNativeGkM11$fToNativeGeneralGk:*:ρ$fToNativeGeneralGkM1ρ$fToNativeGeneralGkU1ρ$fToNativeGeneralGkM1ρ0$fToNativeGeneralGkM1ρ1FromNativeGeneralVarIsJust impossible singleton diversifytrialtrial' multiTrialvieweraseZipGeneral coerceVar fromLabelsMap eraseSingle mapSingleeraseZipSinglefromNativeGeneral$fAsConstructor'nameVara$fAsConstructornameVarVarab $fNFDataVar$fOrdVar$fEqVar $fShowVar $fGenericVarR$fGenericVarR0$fGenericVarR1 $fGenericVar$fToNativeGk:+:$fToNativeGkV1$fFromNativeGk:+:$fFromNativeGkV1$fFromNativeGeneralGk:+:ρ$fFromNativeGeneralGkM1ρ$fFromNativeGeneralGkV1ρ$fFromNativeGeneralGkM1ρ0 AppliesToapplyToswitchcaseon$fAppliesTor->x<=.?DiffModifyRData.Functor.ConstConst text-1.2.3.1Data.Text.InternalTextApSingleForall MapForallToNativeGeneralG ToNativeG FromNativeGRecPairRMap lazyUncons Data.Tuplecurry4unordered-containers-0.2.12.0-7BikmbtnebBBqNM33KNnUdData.HashMap.InternalHashMap Unsafe.Coerce unsafeCoerceGHC.Base Applicative Data.DynamicDynamic+generic-lens-2.0.0.0-FdRq0lHcLqu71RVUKyEbFmData.Generics.Product.FieldsHasFieldFromNativeGeneralGVMapData.Generics.Sum.Constructors AsConstructorConst2 SwitchData