h*      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij0.3.1# Safe-Inferred%vk large-anon Optionally  qualified import declarationl large-anonOptional package namem large-anonOptional package namenolpqrkstuvwxyz{|}~  Safe-Inferred large-anonFresh name generation Safe-Inferredh large-anonDump generated code large-anonIntegrate with typelet for truly O(1) coresize large-anonOmit the call to  applyDiff   Safe-Inferred%&  large-anon"Named required for code generation#All names are expected to be exact.   Safe-Inferred%&'(!a large-anon Experimental support for typeletSee documentation of  letRecordT and  letInsertAs. large-anonConstruct simple lambdaConstructs lambda of the form \x -> e large-anonFresh var for the proxy large-anonFresh var for each insert  Safe-Inferred" large-anonGiven a set of equivalent pairs, map every value to canonical valueExample with two classes:.constructEquivClasses [(1, 2), (4, 5), (2, 3)](fromList [(1,1),(2,1),(3,1),(4,4),(5,4)].Adding one element that connects both classes:6constructEquivClasses [(1, 2), (4, 5), (2, 3), (3, 4)](fromList [(1,1),(2,1),(3,1),(4,1),(5,1)]  Safe-Inferred%&(1#'uyz{    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  Safe-Inferred66+ large-anonRecord field nameA fieldname carries its own hash, which is computed by the plugin at compile time.+ large-anonFrom +This happens at compile time in the plugin.+ large-anonConvenience constructor for +*This function is primarily for use in the +< instance and for debugging. Other applications should use  fieldNameVal instead, so that the hash is computed at compile time instead.+++++ Safe-Inferred%&16+ large-anon3Names we need to parse constraints or generate coreListed alphabetically.++++++++++++++++++++ Safe-Inferred%&'19;9(+ large-anon2Context-free information about a field in a recordIn other words, we do not know the index of the field here, as that depends the context (the particular record it is part of).+ large-anon Construct + from just a stringNOTE: This involves a hash computation. This is unavoidable as long as large-generics does not precompute those.+ large-anon,Name of the field as a term-level expression+ large-anonType-level pair '(n, a) or  '(n, f a)+++++++ Safe-Inferred%&(S,+ large-anon)Classified canonical equality constraints*The first step in the construction of the + is to classify the available canonical equalities as one of three categories, defined below.+ large-anon!" Obviously " productive mappings An equality var := TyCon args is productive, because as soon as we apply it, we are done: we have successfully recognized a type as being an application of a concrete type constructor (note that we only ever apply the substitution to the head t of a type t args, never to the arguments).+ large-anon%Extend equivalence class of variables An equality  var1 := var2 we will regard as extending the equivalence classes of variables (see )., large-anon)Substitutions we need to reconsider later An equality var1 := var2 args (with args a non-empty list of arguments) is most problematic. Applying it may allow us to make progress, but it may not (consider for example var := var arg7). We will reconsider such equalities at the end (see ,).+ large-anonSubstitution for recognizing u applications modulo equalitiesDuring constraint solving the set of " given " constraints includes so-called "canonical equalities": equalities of the form var ~ typ (CTyEqCan) var ~ TyCon arg1 .. argN (CFunEqCan, the TyCon will be a type family)The problem we want to solve is recognizing if some type  is of the form "TyCon arg1 arg2 .. argN (0 <= N)modulo those canonical equalities. We limit the scope of what we try to do:o We are only interested in recognizing types of the form above (as opposed to general parsing-modulo-equalities). o We will only use the canonical equalities as-is: we will not attempt to derive any additional equalities from them (i.e. if, say, we know that x ~ T1 and x ~ T2>, we will not attempt to use the fact that this means that T1 ~ T2+, nor any derived conclusions thereof). We will however try to apply the canononical equalities as often as is necessary (e.g., first applying x ~ T y, then applying y ~ T2).(We solve this problem by constructing a +: a possibly non-deterministic substitution mapping type variables to types of the form above (that is, a type constructor applied to some arguments).We detail the construction of this substitution below (see documentation of + and ,), but once we have this substitution, the recognition problem becomes easy: 1Without loss of generality, let  be of the form t arg1 arg2 .. argNIf t is a u , we're done.Otherwise, if t is a variable x , lookup x in the substitution; if there is one (or more) mappings for x, then we have successfully recognized  to be of the form above. There is no need to apply the substitution repeatedly.The substitution is non-deterministic because there might be multiple matches. For example, if we have !type family Foo where Foo = Int#then we might well have equalities x ~ Int, x ~ Foo in scope, and so a type x would match two different u8s. What we do know, however, is that if  matches both t arg1 .. argN and t' arg1' .. argM' (possibly N /= M), then "t arg1 .. argN ~ t' arg1' .. argM'If t == t'7, we can conclude that the arguments are equal only if t is injective., large-anon&Mapping from (canonical) variables to u applications, large-anon1Map each variable to the canonical representativeSee +2 for a detailed discussion of canonical variables., large-anonEmpty substitutionThe canonical variables map is established once when the initial substitution is generated and not updated thereafter., large-anon%Lookup a variable in the substitution, large-anon%Extend substitution with new bindings, large-anon#Classify a set of given constraintsSee + for details., large-anon Construct u2 substitution from classified equality constraintsThe difficult part in constructing this substitution are the equalities of the form var1 ~ var2 args, which we ear-marked as "to reconsider" during classification.We will do this iteratively:o We first construct a set of variable equivalence classes based on + (using ), and use that along with the "obviously productive" equalities (+0) as the initial value of the accumulator (a +). o We then repeatedly consider the remaining equalities. Whenever there is a substitution available in the accumulator for var2+ which turns it into a type of the form  TyCon args' , we add var1 := TyCon args' args to the accumulator. o We keep doing this until we can make no more progress.The functions for working with + take the variable equivalence classes into acocunt, so we do not need to do that here.Two observations:o This process must terminate: there are a finite number of constraints to consider, and whenever we apply a substitution from the accumulator, we get an "obviously productive" substitution: we do not create new work in the loop. o We may end up ignoring some substitutions: if there is a substitution var1 := var2 args9 and we don't have any (productive) substitutions for var2, we will just ignore it.A note on recursive bindings: a direct or indirect recursive binding =x := x args1 x := y args1 y := x args2where  args1, args2# are non-empty lists of arguments, cannot be relevant: if they were, that would imply that there is some type constructor (regular datatype or type family) which can be applied to an arbitrary number of arguments. Such datatypes or type families cannot be defined in Haskell. We therefore take no special care in handling recursive bindings, other than to note (as we did above) that the process must terminate., large-anon Construct +*This is the main function that builds the + from the set of " given " constraints. The actual work is done by , and ,., large-anonLike ., but taking canonical equalities into accountSee + for a detailed discussion., large-anonAttempt to apply a non-deterministic function to a list of valuesReturns the successful results as well as the inputs on which the function failed.+,, Safe-Inferred9W , large-anonParse successful, large-anonDifferent constraint than we're looking for (does not imply an error), large-anonConstraint of the shape we're looking for, but something is wrong, large-anon>Apply parser to each value in turn, bailing at the first error, large-anon Variation on , which rules out the error case, large-anon/Bundle the parse result with the original value, large-anonGeneric constraint parserTODO: If we add some parsing infra to ghc-tcplugin-api, maybe a (form of) this function could live there too., large-anonSpecialization of ,, just checking the class name, large-anonParse #x ': xs == (':) x xs == ((':) x) xs, large-anonParse '[], large-anon2Parse application of an injective type constructor, large-anon)Do we want to try and match against this? large-anonParser for the class arguments large-anonConstraint to parse, large-anon"Predicate we want to match against large-anonParser for the class arguments large-anonConstraint to parse ,,,,,,,,,,,, Safe-Inferred%&1X, large-anonParsed form of an KnownFieldLabel f constraint, large-anonThe underlying  FastString when the label is a literal., large-anonThe raw type argument to the KnownFieldLabel constraint.,,,,,, Safe-InferredY, large-anonAlter an existing keyReturns , if the key does not exist.O(1)., large-anonCannot derive , because the , instance for , is wrong (not strict) ,,,,,,,,, Safe-Inferred%&9;b , large-anon%Reason why we cannot failed to prove SubRow, large-anon.We do not support records with shadowed fieldsSince these fields can only come from the source record, and shadowed fields in the source record are invisible, shadowed fields in the target could only be duplicates of the same field in the source. This is not particularly useful, so we don't support it. Moreover, since we actually create lenses from these subrows, it is important that every field in the source record corresponds to at most one field in the target., large-anon3Some fields in the target are missing in the source, large-anonField in a known row, large-anon"Record with statically known shape, large-anonInformation about each field in the record, in user-specified order.Order matters, because records with the same fields in a different order are not considered equal by the library (merely isomorphic).0May contain duplicates (if fields are shadowed)., large-anon2"Most recent" position of each field in the record-Shadowed fields are not included in this map. Invariant:  HashMap.lookup n knownRecordNames == Just i ==> knownFieldName (knownRecordVector V.! i) == n, large-anon&Are all fields in this record visible?, if some fields are shadowed., large-anonDrop index information, large-anonAdd index information, large-anon List of all fields, in row order This may NOT- be the order in which the fields are stored., large-anon)List of all fields, ordered by fieldIndex, large-anon'Check if one row is a subrow of another?If it is, returns the paired information from both records. If a is a subrow of b, then we can project from b to a+; for improved clarity, we therefore mark a as the target and b as the source.0Results are returned in row order of the target.See ," for some discussion of shadowing., large-anon>Fields of the record in the order they appear in the row types?In other words, fields earlier in the list shadow later fields., large-anonTarget large-anonSource,,,,,,,,,,,,,,,,,,,,,,,,,,,,, Safe-Inferred%&c, large-anon$Return map from field name to type, if all fields are statically known, large-anonParse (x := y),,,,,,, Safe-Inferred%&'(dS, large-anonFunctor argument, if any, large-anon Parsed fields, large-anon%Known record, if all fields are known, Safe-Inferred%&1e, large-anonParsed form of SubRow 1SubRow (r :: [(Symbol, k)]) (r' :: [(Symbol, k)]), large-anonFields on the LHS, large-anonFields on the RHS, large-anonLeft-hand side (r), large-anonRight-hand side (r'), large-anonFunctor argument kind (k) ,,,,,,,,, Safe-Inferred%&1h, large-anonParsed form of a RowHasField n r with  r :: Row k constraint, large-anonLabel we're looking for (n), large-anon%Fields of the record (parsed form of r)=These may be fully or partially known, or completely unknown., large-anon Row kind (k), large-anonRecord field (n), large-anonRow (r), large-anon,Type of the record field we're looking for (a) Although a will be of the form f a' for some a', we do not enforce that here (but instead generate a new wanted equality constraint to enforce this)., large-anon Field index ,,,,,,,,,, Safe-Inferred%&'1jP, large-anonParsed form of a $KnownFields (r :: [(Symbol, Kind)])  constraint, large-anonFields of the record, large-anonType of the record fields (r), large-anonKind of the type information (k), large-anonConstruct evidenceFor each field we need an evidence variable corresponding to the evidence that that field name satisfies KnownSymbol.,,,,,,, Safe-Inferred%&1le, large-anonParsed form of  AllFields c r, large-anon%Fields of the record (parsed form of r), large-anonType of the fields (r), large-anon$Constraint required for each field (c), large-anonConstraint argument kind (the k in c :: k -> Constraint), large-anonConstruct evidenceFor each field we need an evidence variable corresponding to the evidence that that fields satisfies the constraint.,,,,,,,, Safe-Inferred%&1l, Safe-Inferredm, large-anonThe large-anon pluginsThis consists of two plugins: The type checker plugin forms the heart of this package. It solves the various constraints we have on rows, and computes type-level metadata.The source plugin offers syntactic sugar for record construction., Safe-Inferredr, large-anonIndex from the end of the arrayReverseIndex 0 points to the final element., large-anonCompute 0-based index from i, given the size of the array, large-anon Strict vector"Implemented as a wrapper around a ,.NOTE: The operations on Vector do bounds checking only if the debug flag is enabled.NOTE: Vector$ is implemented as a newtype around ,, which in turn is defined as .data SmallArray a = SmallArray (SmallArray# a) Furthermore,  Canonical is a newtype around Vector, which is then used in Record as data Record (f :: k -> Type) (r :: Row k) = Record { recordCanon :: {-# UNPACK #-} !(Canonical f) , .. }This means that Record will have direct access (no pointers) to the  'SmallArray#'., large-anonArray to update large-anonIndices into the original array and their new value (the order of this list is irrelevant)- large-anonArray to take values from large-anonList of indices into the source array, in the order they must appear in the result array,-,---,--------,---- Safe-Inferred%&'06}h - large-anonCanonical record representation3Canonicity here refers to the fact that we have no Diff to apply (see #Data.Record.Anonymous.Internal.Diff).Order;The record is represented as a strict vector in row order ( large-anon is strict by default; lazy records can be achieved using boxing). This order is important: it makes it possible to define functions such as mapM, (for which ordering must be well-defined).Indices1 into the array however are interpreted from the end of the array. This ensures that when we insert new elements into the record, the indices of the already existing fields do not change; see Diff for further discussion. ShadowingType level shadowing is reflected at the term level: if a record has duplicate fields in its type, it will have multiple entries for that field in the vector.TODO: Currently we have no way of recovering the value of shadowed fields, adding an API for that is future work. The work by Daan Leijen on scoped labels might offer some inspiration there.Note on complexity9When we cite the algorithmic complexity of operations on -, we assume that HashMap inserts and lookups are O(1), which they are in practice (especially given the relatively small size of typical records), even if theoretically they are O(log n)!. See also the documentation of Data.HashMap.Strict.- large-anonTo strict vector- large-anon Get field at the specified indexO(1).- large-anon#Set fields at the specified indicesO(n) in the size of the record (independent of the number of field updates) O(1)! if the list of updates is empty.- large-anon From list of fields in row orderO(n).- large-anonAll fields in row order O(n)- large-anon7Given the length of the array, all indices in row order- large-anonInsert fields into the recordIt is the responsibility of the caller to make sure that the linear concatenation of the new fields to the existing record matches the row order of the new record.O(n)7 in the number of inserts and the size of the record. O(1)! if the list of inserts is empty.- large-anon-Project out some fields in the selected orderIt is the responsibility of the caller that the list of indices is in row order of the new record.O(n) (in both directions)- large-anonZip two records7Precondition: the two records must have the same shape.- large-anonApplicative zip of two records7Precondition: the two records must have the same shape.----------------- Safe-Inferred %&06 - large-anonRecord changes to a (- ) record.Unlike  ! and -, "! and "#) deal with a single field at a time, at O(1)% cost. This is the raison d'tre of -: amortize the cost of repeated updates/inserts. Specifically, a series of inserts or updates will build a - which will take O(n) to apply, but that - should be executed( only when we do an operation which is O(n)$ anyway, thereby absorbing the cost.This is also the reason that - is name based, not index based: inserting a new field would increase all indices of existing fields by 1, an inherently O(n) operation. NOTE: As for -7, when citing algorithmic complexity of operations on -, we assume that HashMap inserts and lookups are O(1). See -! for more detailed justification. NOTE: Since  large-anon currently only supports records with strict fields, we use strict HashMap here.- large-anonNew values of existing fieldsIndices refer to the  canonical( record. Since new fields are inserted after old fields, field indices do not change as we insert new fields. This is key to the soundness of having a - and - pair.- large-anon0List of new fields, most recently inserted firstMay contain duplicates: fields inserted later shadow earlier fields.- large-anon$Values for the newly inserted fieldsIf the field is shadowed, the list will have multiple entries. Entries in the lists are from new to old, so the head of the list is the "currently visible" entry.- large-anonEmpty differencePostcondition: apply empty c == c- large-anon Get fieldPrecondition: field must be present in the diff or in the record. Postcondition: .Diff.get f d c == Canon.get f (Diff.apply d c)O(1).- large-anonUpdate existing fieldPrecondition: field must be present in the diff or in the record. Postcondition: Diff.apply (Diff.set f x c d) c == Canon.set [(f, x)] (apply d c)It is useful to spell out what happens when inserts and updated are mixed:When a field is inserted and then updated, we just update the corresponding entry in -.When an existing field is first updated and then a new field with the same name is added, an entry is added to - but - will also contain an entry for this field. This doesn't matter: when the diff is applied, the new field will shadow the old, and when we -' the value of a field, we similarly first check -. When the same field is inserted more than once, updates to that field will effectively affect all of them (since we store only a single value), but only the first value will matter as it will shadow all the others.O(1).- large-anonInsert new fieldPrecondition: none (if the field already exists, it will be shadowed). Postcondition: Diff.apply (Diff.insert f x d) c = Canon.insert [(f, x)] (apply d c)(1).- large-anon;All new fields (including shadowed fields), from new to oldO(n).- large-anon Apply diffO(n) in the size of the - and the - in general. O(1) if the - is empty. ---------- Safe-Inferred0-,-----------,---+----------------------------------------------------------------,----................................................................................................................................///////////////////////////////////////////   $ Safe-InferredD,% Safe-Inferred)*/010 / large-anonIn order of the fields in the target record, the index in the source large-anon SubrecordsIf  SubRow r r'* holds, we can project (or create a lens) r to r'. See & for detailed discussion.  large-anon:Symbol (type-level string) with compile-time computed hash0Instances are computed on the fly by the plugin." large-anonMerge two rowsSee ' for detailed discussion.# large-anon Require that c x holds for every (n := x) in r./ large-anon$Vector of dictionaries, in row order$ large-anonLike %., but for the simple API (no functor argument)  SimpleFieldTypes [ "a" := Int, "b" := Bool ] == [ '("a", Int), '("b", Bool) ]% large-anonType-level metadata  FieldTypes Maybe [ "a" := Int, "b" := Bool ] == [ '("a", Maybe Int), '("b", Maybe Bool) ]& large-anon Require that all field names in r are known' large-anonSpecialized form of HasFieldRowHasField n r a holds if there is an (n := a) in r.( large-anonRow: type-level list of field names and corresponding field types/ large-anonPair of values8This is used exclusively promoted to the type level, in (./ large-anonConstruct evidence for the # classFor reasons currently unclear, must' be marked NOINLINE, otherwise we get  -dcore-lint errors in ghc 9.6./)('///&////%$#////// !/"////( Safe-Inferred)*/* large-anonEvidence of some constraint c This is like )#, but without the functor argument.*+////* Safe-Inferred%&'()*/01B, large-anonDiscovered row variableSee + for detailed discussion.. large-anon#Existential type ("there exists an x such that f x")0 large-anon InRow r a$ is evidence that there exists some n s.t. (n := a) in r.2 large-anonProxy for a field name, with / instanceThe /$ instance makes it possible to write #footo mean Field (Proxy @"foo")3 large-anonAnonymous record/ large-anonConstruct canonical form of the record (i.e., apply the internal -)This is O(n)>, and should be done only for operations on records that are O(n) anyway#, so that the cost can be absorbed./ large-anon Construct 3 from - representation (empty -)This function is unsafe because we cannot verify whether the record matches it's row specification r./ large-anonCompile-time construction of a +/ large-anonLow level field accessorIt is the responsibility of the plugin to ensure that the field index and the field type match./ large-anonLow level field updateSee comments in getField./ large-anonProject out subrecordThis is just the / getter./ large-anonInject subrecordThis is just the / setter./ large-anon!Introduce type variable for a row/ large-anonInsert field into a record and introduce type variable for the result/ large-anon+ instance relies on the / instance/ large-anon&Type of the record we are constructing large-anonNew field to be inserted large-anonValue of the new field large-anonRecord constructed so far large-anon8Assign type variable to new partial record, and continue.32/////////////////////////////////01//./,-///, Safe-Inferred%&'14 large-anonAnonymous recordA Record r has a field n of type x for every (n := x) in r.To construct a 4, use # and - , or use the ANON syntax. See # for examples./To access fields of the record, either use the ./ instances (possibly using the record-dot-preprocessor ), or using 0 and !.Remember to enable the plugin when working with anonymous records: 4{-# OPTIONS_GHC -fplugin=Data.Record.Anon.Plugin #-}NOTE: For some applications it is useful to have an additional functor parameter f, so that every field has type f x instead. See Data.Record.Anon.Advanced./ large-anonGet field from the recordThis is just a wrapper around getField./ large-anonUpdate field in the recordThis is just a wrapper around setField./ large-anon!Introduce type variable for a row/ large-anonInsert field into a record and introduce type variable for the result/ large-anon&Type of the record we are constructing large-anonNew field to be inserted large-anonValue of the new field large-anonRecord constructed so far large-anon8Assign type variable to new partial record, and continue42//////////////// Safe-Inferred9$)("#&'2 !%$./*+ $)("#&'2 !%$./*+  Safe-Inferred /01%5 large-anon Empty record6 large-anonInsert new field:{3example :: Record Maybe [ "a" := Bool, "b" := Int ] example = insert #a (Just True) $ insert #b Nothing $ empty:}Instead of using 6 and 5, you can also write this as >example = ANON_F { a = Just True , b = Nothing }7 large-anonApplicative insert This is a simple wrapper around 6, but can be quite useful when constructing records. Consider code like:{2example :: Applicative m => m a -> m b -> m (a, b)!example ma mb = (,) <$> ma <*> mb:}We cannot really extend this to the world of named records, but we can2 do something comparable using anonymous records::{ example :: Applicative m> => m (f a) -> m (f b) -> m (Record f [ "a" := a, "b" := b ])example ma mb = insertA #a ma $ insertA #b mb $ Prelude.pure empty:}As for regular 61, this example too can instead be written using ANON_F and H (or I). example ma mb = sequenceA $ ANON_F { a = Comp ma , b = Comp mb }8 large-anon'Apply all pending changes to the recordUpdates to a record are stored in a hashtable. As this hashtable grows, record field access and update will become more expensive. Applying the updates, resulting in a flat vector, is an O(n)= operation. This will happen automatically whenever another O(n) operation is applied (for example, mapping a function over the record). However, occassionally it is useful to explicitly apply these changes, for example after constructing a record or updating a lot of fields.9 large-anonGet field from the recordThis is just a wrapper around getField.:{example :: Record Maybe [ "a" := Bool, "b" := Int ] -> Maybe Boolexample r = get #a r:} If using record-dot-preprocessor$, you can also write this example as example r = r.aIf the field does not exist, you will get a type error about an unsolvable ' constraint::{absentField :: Record Maybe [ "a" := Bool, "b" := Int ] -> Maybe CharabsentField r = get #c r:}...'...No instance for...RowHasField "c"......3Type mismatches will result in regular type errors::{wrongType :: Record Maybe [ "a" := Bool, "b" := Int ] -> Maybe CharwrongType r = get #a r:}..."...Couldn't match...Char...Bool......When part of the record is not known, it might not be possible to resolve a ( constraint until later. For example, in:{unknownField :: Record Maybe [ x := Bool, "b" := Int ] -> Maybe IntunknownField r = get #b r:}...'...No instance for...RowHasField "b"...... (Note that x here is a variable, not a string.) It is important that the constraint remains unsolved in this example, because if x == "b", the first field would shadow the second, and the result type should be  Maybe Bool instead of  Maybe Int.: large-anonUpdate field in the recordThis is just a wrapper around setField.:{ example ::- Record Maybe [ "a" := Bool, "b" := Int ]- -> Record Maybe [ "a" := Bool, "b" := Int ]!example r = set #a (Just False) r:} If using record-dot-preprocessor , can also write this example as example r = r{a = Just False}; large-anon"Project from one record to anotherBoth the source record and the target record must be fully known.The target record can omit fields from the source record, as well as rearrange them::{ example ::6 Record f [ "a" := Char, "b" := Int, "c" := Bool ]* -> Record f [ "c" := Bool, "a" := Char ]example = project:}!Of course, it is not possible to add fields::{ example ::* Record f [ "c" := Bool, "a" := Char ]6 -> Record f [ "a" := Char, "b" := Int, "c" := Bool ]example = project:}......No instance for...SubRow......Type inference will work through projections: field types are unified based on their name::{ example ::6 Record f [ "a" := Char, "b" := Int, "c" := Bool ]' -> Record f [ "c" := _, "a" := Char ]example = project:}... ...Found type wildcard...Bool...... As we saw in >, ; can also flatten "d rows.< large-anon(Inject smaller record into larger recordThis is just the = setter.= large-anonLens from one record to anotherSee ; for examples (;/ is just the lens getter, without the setter).> large-anonMerge two recordsThe " type family does not reduce::{5example :: Record Maybe (Merge '[ "a" := Bool ] '[])3example = merge (insert #a (Just True) empty) empty:}:If you want to flatten the row after merging, you can use ;::{)example :: Record Maybe '[ "a" := Bool ]=example = project $ merge (insert #a (Just True) empty) empty:} constraints can be resolved for merged records, subject to the same condition discussed in 90: all fields in the record must be fully known::{example :: Record f (Merge '[ "a" := Bool ] '[ "b" := Char ]) -> f Charexample r = get #b r:}5If parts in the record are unknown we get type error::{8example :: Record I (Merge r '[ "b" := Char ]) -> I Charexample r = get #b r:}...'...No instance for...RowHasField "b"......? large-anon Analogue to -@ large-anon Analogue to 12A large-anonConstrained form of ?B large-anonConstrained form of AC large-anon Analogue of 13D large-anonConstrained form of CE large-anon Analogue of -F large-anon Analogue of 45G large-anonLike F, but also include field namesH large-anon Analogue of 16I large-anonSimplified form of HJ large-anon Distribute#This is a higher kinded version of  distribute from  0https://hackage.haskell.org/package/distributive, and inverse to H."Be careful with this function: if f allows effects, then those effects will be duplicated whenever any field of the resulting record is accessed. Using this with  f == Vector or  f == Maybe> is fine, but you almost certainly don't want to use it with f == IO, for example.K large-anonSimplified form of J.L large-anon Analogue of 17M large-anon Analogue of 18N large-anon Analogue of 9:O large-anonConstrained form of MP large-anonConstrained form of NQ large-anonRecord of dictionariesThis reifies an # constraint as a record. Inverse to T.R large-anon Establish # from a record of dictionaries Inverse to S.S large-anonRecord of field namesThis reifies a & constraint as a record. Inverse to R.T large-anon Establish & from a record of field names Inverse to Q.U large-anon Record over r'& with evidence that every field is in r.This reifies a  constraint. Inverse to V.V large-anon Establish  from a record of evidence. Inverse to U.W large-anon;Construct record with existentially quantified row variableExistentially quantified records arise for example when parsing JSON values as records. Pattern matching on the result of W= brings into scope an existentially quantified row variable r, along with a record over r; every field in record contains the value specified, as well as evidence that that that field is indeed an element of r.For such a record to be useful, you will probably want to prove additional constraints  AllFields r c; you can do this using R), provided that you carefully pick your f$ such that you can define a function ,fieldSatisfiesC :: forall c. f x -> Dict c x for every c you want to prove.It is also possible to do a runtime check to see if the existential row r. can be projected to some concrete known row r'7. To do this, construct a record of evidence with type Record (InRow r) r'and then call V. To construct this record of evidence you will need to do a runtime type check to verify that the types of the fields in concrete row match the types of the corresponding fields in the inferred row (the inferred row may contain fields that are not present in the concrete row, of course). An obvious candidate for doing this is ;<, but for specific applications (with specific subsets of types of interest) other choices may be possible also.The  large-anon test suite contains examples of doing both of these things; see Test.Infra.DynRecord.Simple (or Test.Infra.DynRecord.Advanced for rows over kind other than Type7) for examples of proving additional constraints, and Test.Infra.Discovery8 for an example of how you could do a projection check.X large-anon!Introduce type variable for a row%This can be used in conjunction with Y::{=example :: Record I '[ "a" := Int, "b" := Char, "c" := Bool ](example = letRecordT $ \p -> castEqual $. letInsertAs p #c (I True) empty $ \xs02 ->. letInsertAs p #b (I 'X' ) xs02 $ \xs01 ->. letInsertAs p #a (I 1 ) xs01 $ \xs00 -> castEqual xs00:}Y large-anonInsert field into a record and introduce type variable for the resultY large-anon&Type of the record we are constructing large-anonNew field to be inserted large-anonValue of the new field large-anonRecord constructed so far large-anon8Assign type variable to new partial record, and continue+356789:;<=>?ACDEFG@BHIJKLMNOPQRST01UV,-WXYZ+356789:;<=>?ACDEFG@BHIJKLMNOPQRST01UV,-WXYZ Safe-Inferred1ק[ large-anon Empty record\ large-anonInsert new field:{-example :: Record [ "a" := Bool, "b" := Int ] example = insert #a True $ insert #b 1 $ empty:}Instead of using \ and [, you can also write this as 1example = ANON { a = True , b = 1 }] large-anonApplicative insert This is a simple wrapper around \, but can be quite useful when constructing records. Consider code like:{2example :: Applicative m => m a -> m b -> m (a, b)!example ma mb = (,) <$> ma <*> mb:}We cannot really extend this to the world of named records, but we can2 do something comparable using anonymous records::{example :: Applicative m => m a -> m b -> m (Record [ "a" := a, "b" := b ])example ma mb = insertA #a ma $ insertA #b mb $ pure empty:}However, it may be more convenient to use the advanced API for this. See =.^ large-anon'Apply all pending changes to the recordUpdates to a record are stored in a hashtable. As this hashtable grows, record field access and update will become more expensive. Applying the updates, resulting in a flat vector, is an O(n)= operation. This will happen automatically whenever another O(n) operation is applied (for example, mapping a function over the record). However, occassionally it is useful to explicitly apply these changes, for example after constructing a record or updating a lot of fields._ large-anonGet field from the recordThis is just a wrapper around getField.:{5example :: Record [ "a" := Bool, "b" := Int ] -> Boolexample r = get #a r:} If using record-dot-preprocessor$, you can also write this example as example r = r.aSee 0 for additional discussion.` large-anonUpdate field in the recordThis is just a wrapper around setField.:{ example ::' Record [ "a" := Bool, "b" := Int ]' -> Record [ "a" := Bool, "b" := Int ]example r = set #a False r:} If using record-dot-preprocessor , can also write this example as example r = r{a = False}a large-anon"Project from one record to anotherBoth the source record and the target record must be fully known.The target record can omit fields from the source record, as well as rearrange them::{ example ::4 Record [ "a" := Char, "b" := Int, "c" := Bool ]( -> Record [ "c" := Bool, "a" := Char ]example = project:} As we saw in d, a can also flatten " d rows. See & for additional discussion.b large-anon(Inject smaller record into larger recordThis is just the c setter.c large-anonLens from one record to anotherSee a for examples (a/ is just the lens getter, without the setter).d large-anonMerge two recordsThe " type family does not reduce::{/example :: Record (Merge '[ "a" := Bool ] '[]),example = merge (insert #a True empty) empty:}:If you want to flatten the row after merging, you can use a::{#example :: Record '[ "a" := Bool ]6example = project $ merge (insert #a True empty) empty:}See ' for additional discussion.e large-anon.Move from the simple to the advanced interface This is an O(1) operation.f large-anon.Move from the advanced to the simple interface This is an O(1) operation.g large-anonSequence all actionsh large-anon!Introduce type variable for a row%This can be used in conjunction with i::{;example :: Record '[ "a" := Int, "b" := Char, "c" := Bool ](example = letRecordT $ \p -> castEqual $* letInsertAs p #c True empty $ \xs02 ->* letInsertAs p #b 'X' xs02 $ \xs01 ->* letInsertAs p #a 1 xs01 $ \xs00 -> castEqual xs00:}i large-anonInsert field into a record and introduce type variable for the resulti large-anon&Type of the record we are constructing large-anonNew field to be inserted large-anonValue of the new field large-anonRecord constructed so far large-anon8Assign type variable to new partial record, and continue4[\]^_`abcdefghij4[\]^_`abcdefghij/>?@>AB>AC>AD>AE>AF>GH>IJ>KL>MN>MN>OP>QR>QSTUVTUWTUXTUXTUYTUYTUZT[\T]^T]_T]`Ta)Ta)b./b.cde%f%g%h%i%j%k%l%m%n%o%p(q(q*r*r*s*s*t*t*u*v,v-#=w0!&xy'z2{|3}~5678:+-#=w0!&xy'6                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -                                                                                                                                                       !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''('('('('('('('('('('('('('('('('('('('(((((((('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('('(')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')')))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + + + +>++ + + ++++++++++++++++++++++H++++++++++++++++++++,,,,,,,,,,,,,,,,,,,>,,,>,,,,,,,-,,#5,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,82:,,,,,,,#y8:--z26~"-----0!#-",,-,,-,,-,,-,,-,,-,,-,,-,,-,,-,,->,->,-,,---->+->+->+->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->-->--,,-,--,--,--,--,--,--,--,-->,->-->-->-->-->-->-->--,--,--,-->,->,->,->,->,->,>,->,->,->,3>,->,->,->,->,->,->,->,->-->-->-->4->4->4,>4->4->4->4->4->4->4->4->4->4->-->-->-->-->-->-->-->-->-->-->-->-->-->-.>-.>-.>-.>-.>-.>-.>-.>-.>..>..>..>..>..>..>..>..>-.>-.>-.>-.>-.>-.>-.>-.>-.>-.>-.>-.>-.>-.>-.>..>.,>.2>.6>..>+.>..>..>-.>-.>,.>,.>,.>,z>.,>..>,.>..,..>..>.8>-.>..>..>..>..>..>..>..>4.>.7>..>-.,-.,-.,-.>..>..>,.>,.>,.>,.>,.>,.>,.>..>..>..>..>..>..>..>..>..>..>..>..>..>..>..>..>..>..>..>..>4.>4.>4.>4.>4.>4.>..>..>..>..>..>+.>+.>+.>+.>-.>-.>-.>-.>..>..>-.>-.>-.>..>..>4/>4/>//>//>//>//>-/>-/>./>./>./>./>./>./>./>./>./%/%/%S%,%/%/%/%/%/%,%/%/%/%/%/%/%/%/%/((((/>?/*/*/*/*/*/*&*y*x***/*u*-*#*=*0*!*'*w*z*{*3*}*~**5*2*|*6****7*8*:*********+,0,!,,,-,#,=,',y,&,x,w,/,,,6/'large-anon-0.3.1-L8vxztoSha0EvmyaApIrN0Data.Record.Anon.OverloadingData.Record.AnonData.Record.Anon.AdvancedData.Record.Anon.Simple large-anon/Data.Record.Anon.Internal.Plugin.Source.GhcShim.Data.Record.Anon.Internal.Plugin.Source.FreshT/Data.Record.Anon.Internal.Plugin.Source.Options-Data.Record.Anon.Internal.Plugin.Source.Names'Data.Record.Anon.Internal.Plugin.Source0Data.Record.Anon.Internal.Plugin.TC.EquivClasses2Data.Record.Anon.Internal.Plugin.TC.GhcTcPluginAPI(Data.Record.Anon.Internal.Core.FieldName2Data.Record.Anon.Internal.Plugin.TC.NameResolution2Data.Record.Anon.Internal.Plugin.TC.Row.KnownField.Data.Record.Anon.Internal.Plugin.TC.TyConSubst+Data.Record.Anon.Internal.Plugin.TC.Parsing9Data.Record.Anon.Internal.Plugin.TC.Constraints.KnownHash+Data.Record.Anon.Internal.Util.SmallHashMap0Data.Record.Anon.Internal.Plugin.TC.Row.KnownRow1Data.Record.Anon.Internal.Plugin.TC.Row.ParsedRow,Data.Record.Anon.Internal.Plugin.TC.Rewriter6Data.Record.Anon.Internal.Plugin.TC.Constraints.SubRow;Data.Record.Anon.Internal.Plugin.TC.Constraints.RowHasField;Data.Record.Anon.Internal.Plugin.TC.Constraints.KnownFields9Data.Record.Anon.Internal.Plugin.TC.Constraints.AllFields*Data.Record.Anon.Internal.Plugin.TC.Solver Data.Record.Anon.Internal.Plugin*Data.Record.Anon.Internal.Util.StrictArray(Data.Record.Anon.Internal.Core.Canonical#Data.Record.Anon.Internal.Core.DiffCanonsetDiffinsertData.Record.Anon.Plugin(Data.Record.Anon.Plugin.Internal.Runtimeprojectmerge$Data.Record.Anon.Internal.ReflectionDict"Data.Record.Anon.Internal.Advanced someRecord Data.Record.Anon.Internal.SimpleemptyGHC.Records.CompatHasFieldgetPreludemapMpure Data.FoldabletoList sequenceAzipzipWith Control.MonadzipWithM Data.TypeableTypeableinsertAbaseGHC.OverloadedLabels fromLabel Control.Arrowarrfirstapp|||loop Data.String fromString GHC.RecordsgetField GHC.TypeLits KnownSymbol Data.ProxyProxyControl.Category>>>Data.Functor.ProductProductPair'sop-core-0.5.0.2-6frQFsrp1xOFEhJrxT1beuData.SOP.BasicFunctors:.:CompIKunIData.SOP.ConstraintComposeData.SOP.Classes-.->FnapFn Data.SOP.Dict,record-hasfield-1.0.1-AU1qjxg0qv0AHLzjqYmWt4hasField ifThenElsesetFieldSubRow KnownHashhashValMerge AllFieldsSimpleFieldTypes FieldTypes KnownFields RowHasFieldRow:= Reflected SomeRecordSomeInRowFieldRecord applyPendinginjectlensmapcmapcmapMcpureapcollapse sequenceA' distribute distribute'czipWith czipWithMreifyAllFieldsreflectAllFieldsreifyKnownFieldsreflectKnownFields reifySubRow reflectSubRow letRecordT letInsertAs castEqual toAdvanced fromAdvanced importDecl lookupName lookupOccName HasDefaultExtdefExt NameCacheIOhscNameCacheIOtakeUniqFromNameCacheIO issueWarningmkLabelghcGHC.Core.TyConTyCon tyConTyVars tyConKind tyConArityGHC.Unit.TypesModuleGHC.Core.TyCo.RepTypeGHC.Types.NameNameLanguage.Haskell.Syntax.Decls DerivStrategy StockStrategyAnyclassStrategyNewtypeStrategy ViaStrategyKindInjectivityAnnXInjectivityAnnRuleBndr RuleBndrSig XRuleBndrFunDepXFunDepLanguage.Haskell.Syntax.TypeBangTypeLanguage.Haskell.Syntax.ExprStmtMatchXMatchm_extm_ctxtm_patsm_grhssLanguage.Haskell.Syntax.PatPatWildPatVarPatLazyPatAsPatParPatBangPatListPatTuplePatSumPatConPatViewPat SplicePatLitPatNPat NPlusKPatSigPatXPat pat_con_extpat_conpat_argsGHC.Types.SrcLocSrcLoc RealSrcLoc UnhelpfulLocGHC.Types.FixityFixityGHC.Driver.BackendBackend#Language.Haskell.Syntax.Module.Name ModuleNameGHC.Utils.Panic GhcExceptionSignal UsageError CmdLineErrorPanicPprPanicSorryPprSorryInstallationError ProgramErrorPprProgramErrorGHC.Parser.Annotation AnnKeywordIdAnnOpen AnnHeaderAnnValAnnCloseAnnType AnnBackquoteAnnTilde AnnPattern AnnDotdotAnnComma AnnModule AnnImportAnnSafe AnnQualifiedAnnPackageNameAnnAs AnnHidingAnnSemi AnnDcolon AnnForallAnnDot AnnDarrow AnnRarrowAnnBangAnnUnitAnnEqual AnnDefaultAnnInfix AnnInstanceAnnVbar AnnLarrowAnnWhereAnnFunIdAnnRole AnnForeign AnnExport AnnDerivingAnnStock AnnNewtypeAnnData AnnFamilyAnnOpenP AnnClosePAnnClassAnnThenAnnByAnnGroupAnnUsingAnnLetAnnRec Annlarrowtail Annrarrowtail AnnLarrowtail AnnRarrowtailAnnOpenB AnnCloseBAnnLamAnnCaseAnnOfAnnCasesAnnIfAnnElseAnnInAnnDoAnnColonAnnMinusAnnOpenE AnnOpenEQ AnnCloseQAnnProc AnnStatic AnnAnyclass AnnCloseBU AnnCloseC AnnCloseQU AnnClosePH AnnCloseS AnnCommaTuple AnnDarrowU AnnDcolonU AnnForallU AnnLarrowU AnnLollyUAnnMdoAnnName AnnOpenBUAnnOpenC AnnOpenEQUAnnOpenS AnnOpenPH AnnDollarAnnDollarDollar AnnPercent AnnPercentOne AnnRarrowUAnnSimpleQuote AnnSignature AnnThTyQuote AnnValStrAnnViaAnnlarrowtailUAnnrarrowtailUAnnLarrowtailUAnnRarrowtailUAnnDecl HsAnnotationXAnnDeclLanguage.Haskell.Syntax.ImpExpIEIEVar IEThingAbs IEThingAll IEThingWithIEModuleContentsIEGroupIEDoc IEDocNamedXIEGHC.ByteCode.Types ModBreaksmodBreaks_flagsmodBreaks_locsmodBreaks_varsmodBreaks_decls modBreaks_ccsmodBreaks_breakInfoHsExprHsUntypedSplice HsOverLitHsLitHsPragEHsVar HsUnboundVarHsRecSel HsOverLabelHsIPVarHsLam HsLamCaseHsApp HsAppTypeOpAppNegAppHsParSectionLSectionR ExplicitTuple ExplicitSumHsCaseHsIf HsMultiIfHsLetHsDo ExplicitList RecordCon RecordUpd HsGetField HsProjection ExprWithTySigArithSeqHsTypedBracketHsUntypedBracket HsTypedSpliceHsProcHsStaticXExprrcon_extrcon_con rcon_fldsrupd_ext rupd_expr rupd_fldsgf_extgf_exprgf_fieldproj_ext proj_fldsGHC.Types.Name.ReaderRdrNameUnqualQualExact GHC.Types.VarId!Language.Haskell.Syntax.Extension NoExtFieldGHC.Driver.SessionDynFlagsbackendghcModeghcLinkghcNameVersion fileSettingstargetPlatform toolSettings platformMisc rawSettingstmpDir llvmOptLevel verbosity debugLevel simplPhasesmaxSimplIterations ruleCheckstrictnessBefore parMakeCountenableTimeStats ghcHeapSizemaxRelevantBindsmaxValidHoleFitsmaxRefHoleFitsrefLevelHoleFitsmaxUncoveredPatternsmaxPmCheckModelssimplTickFactor dmdUnboxWidthspecConstrThresholdspecConstrCountspecConstrRecursivebinBlobThresholdliberateCaseThreshold floatLamArgsliftLamsRecArgsliftLamsNonRecArgs liftLamsKnowncmmProcAlignment historySize importPathsmainModuleNameIs mainFunIsreductionDepthsolverIterations homeUnitId_homeUnitInstanceOf_homeUnitInstantiations_workingDirectorythisPackageName hiddenModulesreexportedModules targetWays_ splitInfo objectDirdylibInstallNamehiDirhieDirstubDirdumpDir objectSuf_hcSufhiSuf_hieSuf dynObjectSuf_ dynHiSuf_ outputFile_dynOutputFile_outputHi dynOutputHi dynLibLoader dynamicNow dumpPrefixdumpPrefixForceldInputs includePaths libraryPathsframeworkPathscmdlineFrameworksrtsOptsrtsOptsEnabledrtsOptsSuggestionshpcDirpluginModNamespluginModNameOptsfrontendPluginOptsexternalPluginSpecs depMakefiledepIncludePkgDepsdepIncludeCppDepsdepExcludeMods depSuffixespackageDBFlagsignorePackageFlags packageFlagspluginPackageFlags trustFlags packageEnv dumpFlags generalFlags warningFlagsfatalWarningFlagslanguage safeHaskell safeInfer safeInferredthOnLoc newDerivOnLocderiveViaOnLocoverlapInstLocincoherentOnLoc pkgTrustOnLoc warnSafeOnLocwarnUnsafeOnLoctrustworthyOnLoc extensionsextensionFlags unfoldingOpts maxWorkerArgs ghciHistSizeflushOutghcVersionFilehaddockOptions ghciScripts pprUserLengthpprCols useUnicodeuseColor canUseColor colSchemeprofAutocallerCcFiltersinteractivePrint sseVersion bmiVersionavxavx2avx512cdavx512eravx512favx512pfrtldInfortccInfo rtasmInfomaxInlineAllocSizemaxInlineMemcpyInsnsmaxInlineMemsetInsns reverseErrors maxErrors initialUniqueuniqueIncrement cfgWeights ghci-9.6.3GHCi.RemoteTypes ForeignHValueHValueLanguage.Haskell.Syntax.BasicSrcUnpackedness SrcUnpack SrcNoUnpack NoSrcUnpack SrcStrictnessSrcLazy SrcStrict NoSrcStrictNoGhcTcXXIEWrappedNameXIEType XIEPatternXIENameXXIE XIEDocNamedXIEDocXIEGroupXIEModuleContents XIEThingWith XIEThingAll XIEThingAbsXIEVarImportDeclPkgQual XXImportDecl XCImportDecl XXFieldOcc XCFieldOccXXConDeclField XConDeclField XXTyVarBndr XKindedTyVar XUserTyVarXXHsForAllTelescopeXHsForAllInvis XHsForAllVisXXTyLitXCharTyXStrTyXNumTyXXType XWildCardTyXTyLitXExplicitTupleTyXExplicitListTyXRecTyXBangTyXDocTy XSpliceTyXKindSigXStarTy XIParamTyXParTyXOpTyXSumTyXTupleTyXListTyXFunTy XAppKindTyXAppTyXTyVarXQualTy XForAllTyXXHsPatSigTypeXHsPSXXHsWildCardBndrsXHsWC XXHsSigTypeXHsSigXXHsOuterTyVarBndrsXHsOuterExplicitXHsOuterImplicit XXLHsQTyVarsXHsQTvs XHsFieldBindXXPatXCoPatXSigPat XNPlusKPatXNPatXLitPat XSplicePatXViewPatXConPatXSumPat XTuplePatXListPatXBangPatXParPatXAsPatXLazyPatXVarPatXWildPat XXOverLitXOverLitXXLit XHsDoublePrim XHsFloatPrimXHsRat XHsInteger XHsWord64Prim XHsInt64Prim XHsWordPrim XHsIntPrimXHsInt XHsStringPrim XHsString XHsCharPrimXHsCharXXApplicativeArgXApplicativeArgManyXApplicativeArgOneXXParStmtBlock XParStmtBlockXXCmdXCmdWrapXCmdDoXCmdLetXCmdIf XCmdLamCaseXCmdCaseXCmdParXCmdLamXCmdApp XCmdArrForm XCmdArrAppXXStmtLRXRecStmt XTransStmtXParStmtXLetStmt XBodyStmtXApplicativeStmt XBindStmt XLastStmtXXGRHSXCGRHSXXGRHSsXCGRHSsXXMatchXCMatch XXMatchGroupXMGXXCmdTopXCmdTopXXQuoteXVarBrXTypBrXDecBrGXDecBrLXPatBrXExpBrXXUntypedSplice XQuasiQuoteXUntypedSpliceExprXXTupArgXMissingXPresentXXAmbiguousFieldOcc XAmbiguous XUnambiguousXXPragEXSCC XXDotFieldOcc XCDotFieldOccXXExprXPragEXBinTickXTickXStaticXProcXUntypedSplice XTypedSpliceXUntypedBracket XTypedBracket XArithSeqXExprWithTySig XProjection XGetField XRecordUpd XRecordCon XExplicitListXDoXLetXMultiIfXIfXCase XExplicitSumXExplicitTuple XSectionR XSectionLXParXNegAppXOpApp XAppTypeEXAppXLamCaseXLamXLitE XOverLitEXIPVar XOverLabelXRecSel XUnboundVarXVarXXModuleXCModuleXXInjectivityAnnXCInjectivityAnnXXRoleAnnotDeclXCRoleAnnotDecl XXAnnDecl XHsAnnotation XXWarnDeclXWarning XXWarnDecls XWarnings XXRuleBndr XRuleBndrSig XCRuleBndr XXRuleDeclXHsRule XXRuleDecls XCRuleDeclsXXForeignExportXCExportXXForeignImportXCImport XXForeignDeclXForeignExportXForeignImport XXDefaultDecl XCDefaultDecl XViaStrategyXNewtypeStrategyXAnyClassStrategyXStockStrategy XXDerivDecl XCDerivDecl XXInstDecl XTyFamInstD XDataFamInstD XClsInstD XXClsInstDecl XCClsInstDeclXXTyFamInstDeclXCTyFamInstDeclXXFamEqnXCFamEqn XXConDecl XConDeclH98 XConDeclGADTXXDerivClauseTys XDctMulti XDctSingleXXHsDerivingClauseXCHsDerivingClause XXHsDataDefn XCHsDataDefn XXFamilyDecl XCFamilyDeclXXFamilyResultSig XTyVarSig XCKindSigXNoSig XXTyClGroup XCTyClGroupXXFunDepXCFunDep XXTyClDecl XClassDecl XDataDeclXSynDeclXFamDecl XXSpliceDecl XSpliceDecl XXHsGroup XCHsGroupXXHsDecl XRoleAnnotDXDocDXSpliceDXRuleDXAnnD XWarningDXForDXDefD XKindSigDXSigDXValDXDerivDXInstDXTyClDXXStandaloneKindSigXStandaloneKindSig XXFixitySig XFixitySigXXSigXCompleteMatchSig XSCCFunSig XMinimalSig XSpecInstSigXSpecSig XInlineSigXFixSigXIdSig XClassOpSig XPatSynSigXTypeSigXXIPBindXCIPBind XXHsIPBindsXIPBinds XXPatSynBindXPSB XXHsBindsLR XPatSynBindXVarBindXPatBindXFunBind XXValBindsLR XValBindsXXHsLocalBindsLRXEmptyLocalBinds XHsIPBinds XHsValBindsLIdPIdPWrapXRecwrapXRecMapXRecmapXRecUnXRecunXRecAnnoXRecDataConCantHappenIsBootInterfaceNotBootIsBootUnitGHC.Utils.Outputable NamePprCtx QueryQualifyqueryQualifyNamequeryQualifyModulequeryQualifyPackagequeryPromotionTick NamedThing getOccNamegetNameTyVarGHC.Types.TyThingTyThingAnIdAConLikeATyConACoAxiom ThetaTypePredTypeMult Language.Haskell.Syntax.Concrete LayoutInfoExplicitBraces VirtualBraces NoLayoutInfo HsUniToken HsNormalTok HsUnicodeTokHsTokenHsTok LHsUniTokenLHsToken RealLocatedLocated GenLocatedLSrcSpan RealSrcSpan UnhelpfulSpan srcSpanFileGHC.Types.SafeHaskellSafeHaskellModeSf_None Sf_UnsafeSf_TrustworthySf_SafeSf_SafeInferred Sf_Ignore LexicalFixityPrefixInfixFixityDirectionInfixLInfixRInfixNGHC.Hs.DocStringHsDocStringChunkLHsDocStringChunkHsDocStringDecoratorHsDocStringNextHsDocStringPreviousHsDocStringNamedHsDocStringGroup HsDocStringMultiLineDocStringNestedDocStringGeneratedDocString LHsDocStringGHC.Driver.Flags GeneralFlagOpt_DumpToFileOpt_DumpWithWaysOpt_D_dump_minimal_importsOpt_DoCoreLintingOpt_DoLinearCoreLintingOpt_DoStgLintingOpt_DoCmmLintingOpt_DoAsmLintingOpt_DoAnnotationLintingOpt_DoBoundsCheckingOpt_NoLlvmMangler Opt_FastLlvmOpt_NoTypeableBindsOpt_DistinctConstructorTablesOpt_InfoTableMapOpt_InfoTableMapWithFallbackOpt_InfoTableMapWithStackOpt_WarnIsErrorOpt_ShowWarnGroupsOpt_HideSourcePathsOpt_PrintExplicitForallsOpt_PrintExplicitKindsOpt_PrintExplicitCoercionsOpt_PrintExplicitRuntimeRepsOpt_PrintEqualityRelationsOpt_PrintAxiomIncompsOpt_PrintUnicodeSyntaxOpt_PrintExpandedSynonymsOpt_PrintPotentialInstances Opt_PrintRedundantPromotionTicksOpt_PrintTypecheckerElaboration Opt_CallArityOpt_ExitificationOpt_StrictnessOpt_LateDmdAnalOpt_KillAbsenceOpt_KillOneShotOpt_FullLaziness Opt_FloatInOpt_LocalFloatOutOpt_LocalFloatOutTopLevelOpt_LateSpecialiseOpt_SpecialiseOpt_SpecialiseAggressivelyOpt_CrossModuleSpecialiseOpt_PolymorphicSpecialisationOpt_InlineGenericsOpt_InlineGenericsAggressively Opt_StaticArgumentTransformationOpt_CSE Opt_StgCSEOpt_StgLiftLamsOpt_LiberateCaseOpt_SpecConstrOpt_SpecConstrKeenOpt_DoLambdaEtaExpansionOpt_IgnoreAssertsOpt_DoEtaReduction Opt_CaseMergeOpt_CaseFoldingOpt_UnboxStrictFieldsOpt_UnboxSmallStrictFieldsOpt_DictsCheapOpt_EnableRewriteRulesOpt_EnableThSpliceWarnings Opt_RegsGraphOpt_RegsIterativeOpt_PedanticBottoms Opt_LlvmTBAAOpt_LlvmFillUndefWithGarbageOpt_IrrefutableTuples Opt_CmmSinkOpt_CmmStaticPredOpt_CmmElimCommonBlocksOpt_CmmControlFlowOpt_AsmShortcuttingOpt_OmitYieldsOpt_FunToThunkOpt_DictsStrictOpt_DmdTxDictSelOpt_LoopificationOpt_CfgBlocklayoutOpt_WeightlessBlocklayout Opt_CprAnalOpt_WorkerWrapperOpt_WorkerWrapperUnliftOpt_SolveConstantDictsOpt_AlignmentSanitisationOpt_CatchNonexhaustiveCasesOpt_NumConstantFoldingOpt_CoreConstantFoldingOpt_FastPAPCallsOpt_DoTagInferenceChecksOpt_SimplPreInliningOpt_IgnoreInterfacePragmasOpt_OmitInterfacePragmasOpt_ExposeAllUnfoldingsOpt_WriteInterface Opt_WriteHieOpt_AutoSccsOnIndividualCafsOpt_ProfCountEntriesOpt_ProfLateInlineCcsOpt_ProfLateCcsOpt_ProfManualCcsOpt_PpOpt_ForceRecompOpt_IgnoreOptimChangesOpt_IgnoreHpcChangesOpt_ExcessPrecisionOpt_EagerBlackHoling Opt_NoHsMainOpt_SplitSections Opt_StgStatsOpt_HideAllPackagesOpt_HideAllPluginPackagesOpt_PrintBindResult Opt_HaddockOpt_HaddockOptionsOpt_BreakOnExceptionOpt_BreakOnErrorOpt_PrintEvldWithShowOpt_PrintBindContentsOpt_GenManifestOpt_EmbedManifestOpt_SharedImplibOpt_BuildingCabalPackageOpt_IgnoreDotGhciOpt_GhciSandboxOpt_GhciHistoryOpt_GhciLeakCheckOpt_ValidateHieOpt_LocalGhciHistoryOpt_NoItOpt_HelpfulErrorsOpt_DeferTypeErrorsOpt_DeferTypedHolesOpt_DeferOutOfScopeVariablesOpt_PICOpt_PIEOpt_PICExecutableOpt_ExternalDynamicRefs Opt_TickyOpt_Ticky_Allocd Opt_Ticky_LNEOpt_Ticky_Dyn_Thunk Opt_Ticky_Tag Opt_Ticky_APOpt_CmmThreadSanitizer Opt_RPathOpt_RelativeDynlibPathsOpt_CompactUnwindOpt_HpcOpt_FamAppCacheOpt_ExternalInterpreterOpt_OptimalApplicativeDoOpt_VersionMacrosOpt_WholeArchiveHsLibsOpt_SingleLibFolderOpt_ExposeInternalSymbols Opt_KeepCAFs Opt_KeepGoing Opt_ByteCodeOpt_ByteCodeAndObjectCode Opt_LinkRtsOpt_ErrorSpansOpt_DeferDiagnosticsOpt_DiagnosticsShowCaretOpt_PprCaseAsLetOpt_PprShowTicksOpt_ShowHoleConstraintsOpt_ShowValidHoleFitsOpt_SortValidHoleFitsOpt_SortBySizeHoleFitsOpt_SortBySubsumHoleFitsOpt_AbstractRefHoleFitsOpt_UnclutterValidHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowDocsOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowMatchesOfHoleFitsOpt_ShowLoadedModulesOpt_HexWordLiteralsOpt_SuppressCoercionsOpt_SuppressCoercionTypesOpt_SuppressVarKindsOpt_SuppressModulePrefixesOpt_SuppressTypeApplicationsOpt_SuppressIdInfoOpt_SuppressUnfoldingsOpt_SuppressTypeSignaturesOpt_SuppressUniquesOpt_SuppressStgExtsOpt_SuppressStgRepsOpt_SuppressTicksOpt_SuppressTimestampsOpt_SuppressCoreSizesOpt_ShowErrorContextOpt_AutoLinkPackagesOpt_ImplicitImportQualifiedOpt_KeepHscppFilesOpt_KeepHiDiffsOpt_KeepHcFilesOpt_KeepSFilesOpt_KeepTmpFilesOpt_KeepRawTokenStreamOpt_KeepLlvmFilesOpt_KeepHiFilesOpt_KeepOFilesOpt_BuildDynamicTooOpt_WriteIfSimplifiedCore Opt_UseBytecodeRatherThanObjectsOpt_DistrustAllPackagesOpt_PackageTrustOpt_PluginTrustworthyOpt_G_NoStateHackOpt_G_NoOptCoercionGHC.Unit.Module.Location ModLocation ml_hs_file ml_hi_fileml_dyn_hi_file ml_obj_fileml_dyn_obj_file ml_hie_fileGHC.Types.BreakInfo BreakInfobreakInfo_modulebreakInfo_numberGHC.Types.PkgQualPkgQual NoPkgQualThisPkgOtherPkgLPatLHsExpr SyntaxExprGRHSsXGRHSsgrhssExt grhssGRHSsgrhssLocalBinds MatchGroupMG XMatchGroupmg_extmg_altsHsUntypedSpliceExpr HsQuasiQuote PromotionFlag NotPromoted IsPromotedGHC.Driver.PhasesPhaseGHC.Types.Basic SuccessFlag SucceededFailedGHC.Core.DataConDataConNoEpAnnsEpAnnCO AnnSortKey NoAnnSortKey AnnPragmaapr_open apr_closeapr_rest NameAdornment NameParensNameParensHashNameBackquotes NameSquareNameAnn NameAnnCommas NameAnnBars NameAnnOnly NameAnnRArrow NameAnnQuoteNameAnnTrailingnann_adornment nann_open nann_name nann_close nann_trailing nann_commas nann_bars nann_quote nann_quoted AnnContext ac_darrowac_openac_close ParenType AnnParens AnnParensHashAnnParensSquareAnnParen ap_adornmentap_openap_closeAnnList al_anchoral_openal_closeal_rest al_trailing AnnListItem lann_trailing TrailingAnn AddSemiAnn AddCommaAnn AddVbarAnn LocatedAn SrcSpanAnnC SrcSpanAnnP SrcSpanAnnL SrcSpanAnnN SrcSpanAnnALocatedCLocatedPLocatedLLocatedNLocatedASrcAnn SrcSpanAnn' SrcSpanAnnannlocA LEpaComment EpAnnComments EpaCommentsEpaCommentsBalanced priorCommentsfollowingCommentsAnchorOperationUnchangedAnchor MovedAnchorAnchoranchor anchor_opEpAnn EpAnnNotUsedentryannscommentsDeltaPosSameLine DifferentLine deltaColumn deltaLine TokenLocation NoTokenLocTokenLoc EpaLocationEpaSpanEpaDeltaAddEpAnn EpaCommentTok EpaDocComment EpaDocOptionsEpaLineCommentEpaBlockComment EpaEofComment EpaCommentac_tok ac_prior_tokHasENoEIsUnicodeSyntax UnicodeSyntax NormalSyntaxGHC.Hs.ExtensionOutputableBndrId NoGhcTcPassIdGhcPIsPassghcPassGhcTcGhcRnGhcPsPassParsedRenamed TypecheckedGhcPass IsSrcSpanAnn GHC.Hs.DocExtractedTHDocsethd_mod_headerethd_decl_docs ethd_arg_docsethd_inst_docsDocs docs_mod_hdr docs_decls docs_argsdocs_structuredocs_named_chunksdocs_haddock_opts docs_languagedocs_extensions DocStructureDocStructureItemDsiSectionHeading DsiDocChunkDsiNamedChunkRef DsiExports DsiModExportLHsDocWithHsDocIdentifiers hsDocStringhsDocIdentifiersHsDocLIEWrappedName IEWrappedNameIEName IEPatternIETypeXIEWrappedName IEWildcard NoIEWildcardLIEImportListInterpretationExactly EverythingBut ImportDecl XImportDeclideclExt ideclName ideclPkgQual ideclSource ideclSafeideclQualifiedideclAsideclImportListImportDeclQualifiedStyle QualifiedPre QualifiedPost NotQualified LImportDecl GHC.Hs.ImpExpEpAnnImportDeclimportDeclAnnImportimportDeclAnnPragmaimportDeclAnnSafeimportDeclAnnQualifiedimportDeclAnnPackageimportDeclAnnAsXImportDeclPassideclAnnideclSourceText ideclImplicitGHC.Core.ClassClassLanguage.Haskell.Syntax.Lit OverLitVal HsIntegral HsFractional HsIsStringOverLitol_extol_valHsChar HsCharPrimHsString HsStringPrimHsInt HsIntPrim HsWordPrim HsInt64Prim HsWord64Prim HsIntegerHsRat HsFloatPrim HsDoublePrimXLitGHC.Types.ErrorSeverity SevIgnore SevWarningSevErrorGHC.Utils.LoggerLoggerStrictnessMark MarkedStrictNotMarkedStrict HsImplBangHsLazyHsStrictHsUnpack HsSrcBangAmbiguousFieldOcc Unambiguous AmbiguousXAmbiguousFieldOccLAmbiguousFieldOccFieldOcc XFieldOccfoExtfoLabel LFieldOcc LHsTypeArgHsArgHsValArg HsTypeArgHsArgPar HsConDetails PrefixConRecConInfixCon ConDeclField cd_fld_ext cd_fld_names cd_fld_type cd_fld_doc LConDeclField HsTupleSortHsUnboxedTupleHsBoxedOrConstraintTupleHsScaledHsLinearArrowTokensHsPct1HsLollyHsArrowHsUnrestrictedArrow HsLinearArrowHsExplicitMultHsTyLitHsNumTyHsStrTyHsCharTyHsType HsForAllTyHsQualTyHsTyVarHsAppTy HsAppKindTyHsFunTyHsListTy HsTupleTyHsSumTyHsOpTyHsParTy HsIParamTyHsStarTy HsKindSig HsSpliceTyHsDocTyHsBangTyHsRecTyHsExplicitListTyHsExplicitTupleTy HsWildCardTyXHsType hst_xforallhst_telehst_body hst_xqualhst_ctxt HsTyVarBndr UserTyVar KindedTyVar XTyVarBndrHsIPName HsSigTypeHsSig XHsSigTypesig_ext sig_bndrssig_body LHsSigWcType LHsWcType LHsSigType HsPatSigTypeHsPS XHsPatSigTypehsps_ext hsps_bodyHsWildCardBndrsHsWCXHsWildCardBndrshswc_ext hswc_bodyHsOuterFamEqnTyVarBndrsHsOuterSigTyVarBndrsHsOuterTyVarBndrsHsOuterImplicitHsOuterExplicitXHsOuterTyVarBndrs hso_ximplicit hso_xexplicit hso_bndrs LHsQTyVarsHsQTvs XLHsQTyVarshsq_ext hsq_explicit LHsTyVarBndrHsForAllTelescope HsForAllVis HsForAllInvisXHsForAllTelescopehsf_xvis hsf_vis_bndrs hsf_xinvishsf_invis_bndrsLHsKindHsKindLHsType HsContext LHsContext LBangType HsFieldBindhfbAnnhfbLHShfbRHShfbPun HsRecUpdField HsRecFieldLHsRecUpdField LHsRecField LHsFieldBindRecFieldsDotDotunRecFieldsDotDot HsRecFieldsrec_flds rec_dotdotHsConPatDetails HsConPatTyArgConLikePLanguage.Haskell.Syntax.Binds HsPatSynDirUnidirectionalImplicitBidirectionalExplicitBidirectionalRecordPatSynFieldrecordPatSynFieldrecordPatSynPatVarHsPatSynDetails FixitySig LFixitySigSigTypeSig PatSynSig ClassOpSigFixSig InlineSigSpecSig SpecInstSig MinimalSig SCCFunSigCompleteMatchSigXSigLSigIPBindXIPBindLIPBind HsIPBindsIPBinds PatSynBindPSBpsb_extpsb_idpsb_argspsb_defpsb_dirHsBindLRFunBindPatBindVarBind XHsBindsLRfun_extfun_id fun_matchespat_extpat_lhspat_rhsvar_extvar_idvar_rhs LHsBindLR LHsBindsLRHsBindLHsBindsLHsBind HsValBindsLRValBinds XValBindsLR HsValBindsLHsLocalBindsLRHsLocalBindsLREmptyLocalBindsXHsLocalBindsLR LHsLocalBinds HsLocalBinds RoleAnnotDeclXRoleAnnotDeclLRoleAnnotDecl AnnProvenanceValueAnnProvenanceTypeAnnProvenanceModuleAnnProvenanceLAnnDeclWarnDeclWarning XWarnDecl LWarnDecl WarnDeclsWarnings XWarnDeclswd_ext wd_warnings LWarnDeclsDocDeclDocCommentNextDocCommentPrevDocCommentNamedDocGroupLDocDecl LRuleBndrRuleDeclHsRule XRuleDeclrd_extrd_namerd_actrd_tyvsrd_tmvsrd_lhsrd_rhs LRuleDecl RuleDeclsHsRules XRuleDeclsrds_ext rds_rules LRuleDecls ForeignExportCExport CImportSpecCLabel CFunctionCWrapper ForeignImportCImport ForeignDecl XForeignDeclfd_i_extfd_name fd_sig_tyfd_fifd_e_extfd_fe LForeignDecl DefaultDecl XDefaultDecl LDefaultDeclLDerivStrategy DerivDecl XDerivDecl deriv_ext deriv_typederiv_strategyderiv_overlap_mode LDerivDeclInstDeclClsInstD DataFamInstD TyFamInstD XInstDecl cid_d_extcid_instdfid_ext dfid_insttfid_ext tfid_inst LInstDecl ClsInstDecl XClsInstDeclcid_ext cid_poly_ty cid_bindscid_sigscid_tyfam_instscid_datafam_instscid_overlap_mode LClsInstDeclFamEqnXFamEqnfeqn_ext feqn_tycon feqn_bndrs feqn_pats feqn_fixityfeqn_rhsDataFamInstDecldfid_eqnLDataFamInstDecl TyFamInstDeclXTyFamInstDecltfid_xtntfid_eqnLTyFamInstDeclLTyFamDefltDeclTyFamDefltDecl TyFamInstEqnHsTyPats LTyFamInstEqnHsConDeclGADTDetails PrefixConGADT RecConGADTHsConDeclH98DetailsConDecl ConDeclGADT ConDeclH98XConDecl con_g_ext con_names con_dcolon con_bndrs con_mb_cxt con_g_args con_res_tycon_doccon_extcon_name con_forall con_ex_tvscon_argsLConDecl DataDefnCons NewTypeCon DataTypeCons NewOrDataDataTypeNewTypeStandaloneKindSigLStandaloneKindSigDerivClauseTys DctSingleDctMultiXDerivClauseTysLDerivClauseTysHsDerivingClauseXHsDerivingClausederiv_clause_extderiv_clause_strategyderiv_clause_tysLHsDerivingClause HsDeriving HsDataDefn XHsDataDefndd_extdd_ctxtdd_cType dd_kindSigdd_cons dd_derivs FamilyInfo DataFamilyOpenTypeFamilyClosedTypeFamilyLInjectivityAnn FamilyDecl XFamilyDeclfdExtfdInfo fdTopLevelfdLNamefdTyVarsfdFixity fdResultSigfdInjectivityAnn LFamilyDeclFamilyResultSigNoSigKindSigTyVarSigXFamilyResultSigLFamilyResultSig TyClGroup XTyClGroup group_ext group_tyclds group_roles group_kisigs group_instds LHsFunDepTyClDeclFamDeclSynDeclDataDecl ClassDecl XTyClDecltcdFExttcdFamtcdSExttcdLName tcdTyVars tcdFixitytcdRhstcdDExt tcdDataDefntcdCExt tcdLayouttcdCtxttcdFDstcdSigstcdMethstcdATs tcdATDefstcdDocs LTyClDeclSpliceDecoration DollarSplice BareSplice SpliceDecl LSpliceDeclHsGroupXHsGrouphs_exths_valds hs_splcds hs_tyclds hs_derivdshs_fixdshs_defdshs_fords hs_warndshs_annds hs_ruledshs_docsHsDeclTyClDInstDDerivDValDSigDKindSigDDefDForDWarningDAnnDRuleDSpliceDDocD RoleAnnotDXHsDeclLHsDecl HsDoFlavourDoExprMDoExpr GhciStmtCtxtListComp MonadCompHsArrowMatchContextProcExpr ArrowCaseAltArrowLamCaseAlt KappaExpr HsStmtContextHsDoStmtPatGuard ParStmtCtxt TransStmtCtxt ArrowExprHsMatchContextFunRhs LambdaExprCaseAlt LamCaseAltIfAltArrowMatchCtxt PatBindRhs PatBindGuardsRecUpdStmtCtxt ThPatSplice ThPatQuotePatSynmc_fun mc_fixity mc_strictness ArithSeqInfoFromFromThenFromTo FromThenToHsQuoteExpBrPatBrDecBrLDecBrGTypBrVarBrXQuoteApplicativeArgApplicativeArgOneApplicativeArgManyXApplicativeArgxarg_app_arg_oneapp_arg_patternarg_expr is_body_stmtxarg_app_arg_many app_stmts final_expr bv_pattern stmt_context FailOperator ParStmtBlock TransFormThenForm GroupFormStmtLRLastStmtBindStmtApplicativeStmtBodyStmtLetStmtParStmt TransStmtRecStmtXStmtLRtrS_exttrS_form trS_stmts trS_bndrs trS_usingtrS_bytrS_rettrS_bindtrS_fmaprecS_ext recS_stmtsrecS_later_ids recS_rec_ids recS_bind_fn recS_ret_fn recS_mfix_fnGhciStmt GhciLStmt GuardStmt GuardLStmtExprStmt ExprLStmtCmdStmtCmdLStmtLStmtLRLStmtGRHSXGRHSLGRHSLMatch HsRecordBindsHsCmdTop LHsCmdTop HsArrAppTypeHsHigherOrderAppHsFirstOrderAppHsCmd HsCmdArrApp HsCmdArrFormHsCmdAppHsCmdLamHsCmdPar HsCmdCase HsCmdLamCaseHsCmdIfHsCmdLetHsCmdDoXCmdLHsCmdLamCaseVariantLamCaseLamCasesHsTupArgPresentMissingXTupArg LHsTupArg HsPragSCCXHsPragE DotFieldOcc XDotFieldOccdfoExtdfoLabel LHsRecUpdProj RecUpdProj LHsRecProjRecProjFieldLabelStringsLFieldLabelStrings GHC.Hs.ExprHsUntypedSpliceResultHsUntypedSpliceTopHsUntypedSpliceNestedutsplice_result_finalizersutsplice_resultThModFinalizersSplicePointNameLanguage.Haskell.SyntaxHsModuleXModulehsmodExt hsmodName hsmodExports hsmodImports hsmodDeclsGHC.Runtime.Eval.TypesHistoryhistoryBreakInfohistoryEnclosingDeclsResume resumeStmt resumeContextresumeBindingsresumeFinalIds resumeApStackresumeBreakInfo resumeSpan resumeDecl resumeCCS resumeHistoryresumeHistoryIx ExecResult ExecComplete ExecBreak execResultexecAllocation breakNames breakInfo SingleStepRunToCompletionRunAndLogSteps ExecOptionsexecSingleStepexecSourceFileexecLineNumberexecWrapGHC.Core.FamInstEnvFamInst BreakIndex GHC.Hs.TypeOutputableBndrFlagHsCoreTyHsPSRn hsps_nwcs hsps_imp_tvs EpAnnForallTyGhcLinkNoLink LinkBinary LinkInMemory LinkDynLib LinkStaticLib LinkMergedObjGhcModeOneShot CompManagerMkDependGHC.Core.InstEnvClsInstGHC.Types.TargetTargetId TargetModule TargetFileTargettargetIdtargetAllowObjCode targetUnitIdtargetContents GHC.Hs.Lit OverLitTc$sel:ol_rebindable:OverLitTc$sel:ol_type:OverLitTc$sel:ol_witness:OverLitTc OverLitRn$sel:ol_from_fun:OverLitRn$sel:ol_rebindable:OverLitRn GHC.Hs.Binds TcSpecPragSpecPrag LTcSpecPrag TcSpecPragsIsDefaultMethod SpecPragsAnnSigasDcolonasRestIdSigunIdSigABExportABEabe_polyabe_monoabe_wrap abe_pragsAbsBindsabs_tvs abs_ev_vars abs_exports abs_ev_binds abs_bindsabs_sig NHsValBindsLR NValBinds GHC.Hs.PatConPatTc cpt_arg_tyscpt_tvs cpt_dicts cpt_bindscpt_wrapHsPatExpansion HsPatExpanded XXPatGhcTcCoPat ExpansionPat co_cpt_wrap co_pat_inner co_pat_ty EpAnnSumPat sumPatParenssumPatVbarsBeforesumPatVbarsAfter GHC.Hs.Decls HsRuleAnn ra_tyanns ra_tmannsra_restHsRuleRnXViaStrategyPs DataDeclRn tcdDataCusktcdFVsPendingTcSplicePendingRnSpliceUntypedSpliceFlavourUntypedExpSpliceUntypedPatSpliceUntypedTypeSpliceUntypedDeclSplice DelayedSplice XBindStmtTc xbstc_bindOpxbstc_boundResultTypexbstc_boundResultMult xbstc_failOp XBindStmtRn xbsrn_bindOp xbsrn_failOp RecStmtTc recS_bind_tyrecS_later_rets recS_rec_rets recS_ret_tyGrhsAnnga_vbarga_sep MatchGroupTc mg_arg_tys mg_res_ty mg_originCmdTopTcCmdSyntaxTable HsExpansion HsExpanded XXExprGhcTcWrapExpr ExpansionExpr ConLikeTcHsTick HsBinTickAnnsIfaiIfaiThenaiElse aiThenSemi aiElseSemi AnnProjectionapOpenapClose AnnFieldLabelafDotAnnExplicitSumaesOpen aesBarsBefore aesBarsAfteraesCloseEpAnnUnboundVarhsUnboundBackquotes hsUnboundHole EpAnnHsCase hsCaseAnnCase hsCaseAnnOfhsCaseAnnsRest HsBracketTc hsb_quotehsb_tyhsb_wrap hsb_splicesHsWrap SyntaxExprTcNoSyntaxExprTcsyn_expr syn_arg_wraps syn_res_wrap SyntaxExprRnNoSyntaxExprRn SyntaxExprGhc PostTcTable PostTcExpr GHC.Hs.Utils CollectPass collectXXPatcollectXXHsBindsLRcollectXSplicePat CollectFlagCollNoDictBindersCollWithDictBindersGHC.HsHsParsedModule hpm_module hpm_src_files AnnsModuleam_mainam_decls XModulePshsmodAnn hsmodLayouthsmodDeprecMessagehsmodHaddockModHeaderGHC.Unit.Module.ModIface ModIface_ModIface mi_module mi_sig_of mi_hsc_srcmi_deps mi_usages mi_exports mi_used_th mi_fixitiesmi_warnsmi_annsmi_declsmi_extra_decls mi_globalsmi_insts mi_fam_instsmi_rulesmi_hpcmi_trust mi_trust_pkgmi_complete_matchesmi_docs mi_final_exts mi_ext_fields mi_src_hashGHC.Runtime.ContextInteractiveImportIIDeclIIModuleGHC.Unit.Module.ModSummary ModSummaryms_mod ms_hsc_src ms_location ms_hs_hash ms_obj_datems_dyn_obj_date ms_iface_date ms_hie_date ms_srcimpsms_textual_impsms_ghc_prim_import ms_parsed_mod ms_hspp_file ms_hspp_opts ms_hspp_bufGHC.Unit.Module.Graph ModuleGraphGHC.Driver.Env.TypesHscEnv hsc_dflags hsc_targets hsc_mod_graphhsc_IChsc_NChsc_FChsc_type_env_vars hsc_interp hsc_plugins hsc_unit_env hsc_logger hsc_hooks hsc_tmpfshsc_llvm_configGHC.Driver.Monad WarnErrLoggerGhcTGhcGhcMonad getSession setSessionGHC.Parser.LexerToken GHC.Tc.Module TcRnExprModeTM_Inst TM_DefaultGHC.Runtime.EvalGetDocsFailureNameHasNoModule NoDocsInIfaceInteractiveNameGHC.Driver.Make LoadHowMuchLoadAllTargetsLoadUpToLoadDependenciesOfGHC GhcApiError ModuleInfo CoreModule cm_modulecm_typescm_bindscm_safeTypecheckedSource RenamedSource ParsedSourceDesugaredModuledm_typechecked_moduledm_core_moduleTypecheckedModuletm_parsed_moduletm_renamed_sourcetm_typechecked_sourcetm_checked_module_info tm_internals_ ParsedModulepm_mod_summarypm_parsed_sourcepm_extra_src_filesTypecheckedMod renamedSourcetypecheckedSource moduleInfo ParsedMod parsedSource succeededfailed srcLocFile moduleName moduleUnit GHC.Core.Type funResultTyrunGhctopSortModuleGraph initGhcMonad noExtFielddataConCantHappenstableModuleNameCmp moduleNameFSmoduleNameString mkModuleNamemkModuleNameFSmoduleNameSlashesmoduleNameColonsparseModuleName alwaysQualifyshowGhcExceptionwithSignalHandlersmkSrcLocnoSrcLoc srcLocLine srcLocCol noSrcSpan srcLocSpan mkSrcSpan isGoodSrcSpansrcSpanStartLinesrcSpanEndLinesrcSpanStartCol srcSpanEndCol srcSpanStart srcSpanEndunLocgetLocnoLocmkGeneralLocated combineLocsaddCLoc eqLocated cmpLocatedrightmost_smallestleftmost_smallestleftmost_largestspans isSubspanOfgetRealSrcSpan unRealSrcSpan maxPrecedence defaultFixity negateFixity compareFixitypprWithDocStringmkHsDocStringChunk mkHsDocStringChunkUtf8ByteString unpackHDSCmkGeneratedHsDocStringisEmptyDocStringdocStringChunkspprHsDocStringpprHsDocStringsexactPrintHsDocStringrenderHsDocStringrenderHsDocStringsmkModule pprModule isPromoteddataConFieldLabels dataConTyCon nameSrcSpanisExternalName nameModule isLocalId isGlobalId isExportedIdtypeKind unicodeAnndeltaPos getDeltaLineepaLocationRealSrcSpanepaLocationFromSrcAnn spanAsAnchorrealSpanAsAnchor emptyComments parenTypeKwstrailingAnnToAddEpAnnaddTrailingAnnToLaddTrailingAnnToAaddTrailingCommaToNl2nn2lla2nala2lal2lna2lareLocreLocAreLocLreLocCreLocN realSrcSpan srcSpan2ela2eextraToAnnListreAnnreAnnCreAnnL getLocAnngetLocAnoLocA noAnnSrcSpan noSrcSpanAnoAnnaddAnnsaddAnnsA widenSpan widenAnchor widenAnchorRwidenLocatedAn epAnnAnnsL epAnnAnnsannParen2AddEpAnn epAnnComments sortLocatedAmapLocA combineLocsAcombineSrcSpansAaddCLocA addCLocAAgetFollowingCommentssetFollowingCommentssetPriorComments noCommentsplaceholderRealSpancommentaddCommentsToSrcAnnsetCommentsSrcAnnaddCommentsToEpAnnsetCommentsEpAnn transferAnnsA commentsOnlyAremoveCommentsApprIfPspprIfRnpprIfTcnoHsTok noHsUniTokhsDocIds pprWithDocpprMaybeWithDoc pprHsDocDebug emptyDocsimportDeclQualifiedStyleisImportDeclQualifiedsimpleImportDeclieNameieNamesieWrappedLName ieWrappedNamelieWrappedNameieLWrappedNamereplaceWrappedNamereplaceLWrappedName pprImpExp classMethodsclassATs classSCTheta classTvsFds pprFundeps isPrimTyCon isNewTyConisTypeSynonymTyCon isFamilyTyConisOpenFamilyTyConisTypeFamilyTyConisOpenTypeFamilyTyCon tyConDataConssynTyConDefn_maybesynTyConRhs_maybe isClassTyContyConClass_maybeGHC.Builtin.Types.Prim alphaTyVarssplitForAllTyCoVarsnegateOverLitValGHC.Core.TyCo.Ppr pprParendTypepprThetaArrowTy pprForAll pprTypeApp getLogger pushLogHook popLogHookGHC.Utils.ErrorprettyPrintGhcErrors ncgBackend llvmBackend viaCBackendinterpreterBackend noBackendisMarkedStrictdataConIsInfixdataConSrcBangsdataConWrapperTypeisVanillaDataCon hsQTvExplicit hsPatSigTypemapHsOuterImplicit hsIPNameFSisHsKindedTyVarhsMult hsScaledThing noTypeArgs hsConPatArgs hsRecFieldshsRecFieldsArgs hsRecFieldSelpprLPat isFixityLSig isTypeLSig isSpecLSigisSpecInstLSig isPragLSig isInlineLSig isMinimalLSig isSCCFunSigisCompleteMatchSighsGroupInstDecls isDataDecl isSynDecl isClassDecl isFamilyDeclisTypeFamilyDeclisOpenTypeFamilyInfoisClosedTypeFamilyInfoisDataFamilyDecltyClDeclTyVarstyClGroupTyClDeclstyClGroupInstDeclstyClGroupRoleDeclstyClGroupKindSigsdataDefnConsNewOrDataisTypeDataDefnConscollectRuleBndrSigTys docDeclDocannProvenanceName_maybe isInfixMatch isPatSynCtxtqualifiedDoModuleName_maybeisComprehensionContextisDoComprehensionContextisMonadStmtContextisMonadDoStmtContextisMonadCompContextisMonadDoCompContext pprFunBind pprPatBindpprUntypedSplicepprTypedSplicepprExprpprLExpr GHC.Types.IdidTyperecordSelectorTyConisRecordSelectorisClassOpId_maybe isPrimOpId isFCallIdisDataConWorkId idDataCon isImplicitId isDeadBinder isDeadEndId pprParendExprGHC.Types.TyThing.Ppr pprFamInstexprType getBangTypegetBangStrictnessfromMaybeContextmkHsForAllVisTelemkHsForAllInvisTelemkHsQTvs emptyLHsQTvs hsSigWcType dropWildCardshsOuterTyVarNameshsOuterExplicitBndrsmkHsOuterImplicitmkHsOuterExplicitmkHsImplicitSigTypemkHsExplicitSigTypemkHsWildCardBndrsmkHsPatSigTypemkEmptyWildCardBndrshsTyVarBndrFlagsetHsTyVarBndrFlaghsTvbAllKindedhsLinearhsUnrestrictedisUnrestricted arrowToHsType pprHsArrow hsWcScopedTvs hsScopedTvs hsTyVarName hsLTyVarName hsLTyVarNameshsExplicitLTyVarNameshsAllLTyVarNameshsLTyVarLocNamehsLTyVarLocNames hsTyKindSig ignoreParensmkAnonWildCardTymkHsOpTy mkHsAppTy mkHsAppTys mkHsAppKindTysplitHsFunTypehsTyGetAppHead_maybelhsTypeArgSrcSpannumVisibleArgs pprHsArgsAppsplitLHsPatSynTysplitLHsSigmaTyInvissplitLHsGadtTysplitLHsForAllTyInvissplitLHsForAllTyInvis_KPsplitLHsQualTysplitLHsInstDeclTygetLHsInstDeclHeadgetLHsInstDeclClass_maybe mkFieldOccmkAmbiguousFieldOccrdrNameAmbiguousFieldOccselectorAmbiguousFieldOccunambiguousFieldOccambiguousFieldOccpprAnonWildCardpprHsOuterFamEqnTyVarBndrspprHsOuterSigTyVarBndrs pprHsForAll pprLHsContextpprConDeclFields pprHsTypehsTypeNeedsParensparenthesizeHsTypeparenthesizeHsContextgoptinstanceDFunId pprInstancepprInstanceHdr pprXOverLit overLitTypehsOverLitNeedsParenshsLitNeedsParens convertLit pmPprHsLit pprLHsBindspprLHsBindsForUser pprDeclListemptyLocalBindseqEmptyLocalBindsisEmptyValBindsemptyValBindsInemptyValBindsOut emptyLHsBindsisEmptyLHsBindsplusHsValBinds ppr_monobindpprTicksisEmptyIPBindsPRisEmptyIPBindsTc noSpecPrags hasSpecPragsisDefaultMethodppr_sighsSigDocextractSpecPragName pragBracketspragSrcBrackets pprVarSigpprSpecpprTcSpecPrags pprMinimalSig hsRecFieldIdhsRecUpdFieldRdrhsRecUpdFieldIdhsRecUpdFieldOcc pprParendLPat pprConArgsmkPrefixConPatmkNilPat mkCharLitPat isBangedLPatlooksLazyPatBindisIrrefutableHsPat isSimplePatpatNeedsParensgParPatparenthesizePatcollectEvVarsPatscollectEvVarsPatpartitionBindsAndSigs emptyRdrGroup emptyRnGrouphsGroupTopLevelFixitySigs appendGroupstyFamInstDeclNametyFamInstDeclLName tyClDeclLNamecountTyClDeclstcdName hsDeclHasCuskpp_vanilla_decl_headpprTyClDeclFlavourfamilyDeclLNamefamilyDeclNamefamResultKindSignatureresultVariableNamederivStrategyNamestandaloneKindSigName getConNamesgetRecConArgs_maybehsConDeclThetappDataDefnHeaderpprTyFamInstDeclpprDataFamInstFlavourpprHsFamInstLHSinstDeclDataFamInstsnewOrDataToFlavour anyLConIsGadtfoldDerivStrategymapDerivStrategyflattenRuleDeclspprFullRuleNameroleAnnotDeclNamenoExpr noSyntaxExpr mkSyntaxExprmkRnSyntaxExpr tupArgPresent isQuietHsExprpprBinds ppr_lexprppr_exprppr_infix_exprppr_infix_expr_rnppr_infix_expr_tcppr_appspprDebugParendExprpprParendLExprhsExprNeedsParensgHsParparenthesizeHsExprstripParensLHsExprstripParensHsExprisAtomicHsExprpprLCmdpprCmd isQuietHsCmdppr_lcmdppr_cmd pprCmdArgisEmptyMatchGroupisSingletonMatchGroupmatchGroupArity hsLMatchPats pprMatchespprMatchpprGRHSspprGRHSpp_rhspprStmt pprBindStmtpprArgpprTransformStmt pprTransStmtpprBypprDo pprArrowExprppr_module_name_prefix ppr_do_stmtspprComppprQualspprPendingSplice ppr_quasi ppr_splice thBrackets thTyBracketsppr_with_pending_tc_splices pp_dotdotlamCaseKeywordpprExternalSrcLoc pprHsArrTypematchContextErrStringmatchArrowContextErrStringmatchDoContextErrStringpprMatchInCtxt pprStmtInCtxtmatchSeparatorpprMatchContextpprMatchContextNounpprMatchContextNounspprArrowMatchContextNounpprArrowMatchContextNounspprAStmtContextpprStmtContext pprStmtCatpprAHsDoFlavourpprHsDoFlavourprependQualifiedpprFieldLabelStringspprPrefixFastStringmkHsPar mkSimpleMatchunguardedGRHSs unguardedRHS mkMatchGroupmkLamCaseMatchGroup mkLocatedListmkHsApp mkHsAppWithmkHsApps mkHsAppsWith mkHsAppType mkHsAppTypesmkHsLammkHsLams mkHsCaseAlt nlHsTyApp nlHsTyAppsmkLHsParmkParPatnlParPat mkRecStmt mkHsIntegralmkHsFractional mkHsIsStringmkHsDo mkHsDoAnnsmkHsComp mkHsCompAnnsmkHsIf mkHsCmdIfmkNPat mkNPlusKPatemptyTransStmtmkTransformStmtmkTransformByStmtmkGroupUsingStmtmkGroupByUsingStmt mkLastStmt mkBodyStmt mkPsBindStmt mkRnBindStmt mkTcBindStmt unitRecStmtTc emptyRecStmtemptyRecStmtNameemptyRecStmtId mkLetStmt mkHsOpApp mkHsString mkHsStringFSmkHsStringPrimLitmkHsCharPrimLit mkConLikeTcnlHsVarnl_HsVar nlHsDataConnlHsLit nlHsIntLitnlVarPatnlLitPatnlHsAppnlHsSyntaxAppsnlHsApps nlHsVarApps nlConVarPatnlConVarPatName nlInfixConPatnlConPat nlConPatNamenlNullaryConPat nlWildConPat nlWildPat nlWildPatNamenlHsDo nlHsOpAppnlHsLamnlHsParnlHsIfnlHsCasenlList nlHsAppTy nlHsTyVar nlHsFunTy nlHsParTy nlHsTyConApp nlHsAppKindTymkLHsTupleExpr mkLHsVarTuple nlTuplePat missingTupArgmkBigLHsVarTup mkBigLHsTupmkBigLHsVarPatTupmkBigLHsPatTuphsTypeToHsSigTypehsTypeToHsSigWcType mkHsSigEnv mkClassOpSigs mkLHsWrapmkHsWrap mkHsWrapCo mkHsWrapCoR mkLHsWrapCo mkHsCmdWrap mkLHsCmdWrap mkHsWrapPat mkHsWrapPatCo mkHsDictLet mkFunBind mkTopFunBind mkHsVarBind mkVarBind mkPatSynBindisInfixFunBindspanHsLocaLBindsmkSimpleGeneratedFunBindmkPrefixFunRhsmkMatchisUnliftedHsBindisBangedHsBindcollectLocalBinderscollectHsIdBinderscollectHsValBinderscollectHsBindBinderscollectHsBindsBinderscollectHsBindListBinderscollectMethodBinderscollectLStmtsBinderscollectStmtsBinderscollectLStmtBinderscollectStmtBinderscollectPatBinderscollectPatsBindershsGroupBindershsTyClForeignBindershsLTyClDeclBindershsForeignDeclsBindershsPatSynSelectorsgetPatSynBindshsDataFamInstBinderslStmtsImplicitshsValBindsImplicits lPatImplicits ms_mod_namemapMGmgModSummariesmgLookupModuleemptyMG mkModuleGraphGHC.Types.SourceErrorhandleSourceError getNamePprCtxgetSessionDynFlags modifyLogger pushLogHookM popLogHookMputMsgM putLogMsgMprintExceptiondefaultWarnErrLogger dataConType getContext parseModuleGHC.Parser.UtilsisStmt hasImportisImportisDecl getGHCiMonadrunTcInteractivegetResumeContextgetHistoryModulegetHistorySpan execOptionsexecStmt execStmt'runDeclsrunDeclsWithLocationrunParsedDeclsparseImportDecl resumeExecsetupBreakpointbackforwardabandon abandonAll setContextmoduleIsInterpretedgetInfogetNamesInScopegetRdrNamesInScope parseNamegetDocsgetInstancesForTypeparseInstanceHead parseExpr compileExprcompileExprRemotecompileParsedExprRemotecompileParsedExprdynCompileExpr showModulemoduleIsBootOrNotObjectLinkableobtainTermFromValobtainTermFromIdreconstructTypedepanaldepanalEload loadWithCachecyclicModuleErr coreModuledefaultErrorHandlerdefaultCleanupHandlerrunGhcTwithCleanupSessionsetSessionDynFlagssetUnitDynFlagssetTopSessionDynFlagssetProgramDynFlagsgetProgramDynFlagssetInteractiveDynFlagsgetInteractiveDynFlagsparseDynamicFlagsparseTargetFiles setTargets getTargets addTarget removeTarget guessTargetworkingDirectoryChanged getModSummarytypecheckModule desugarModulecompileToCoreModulecompileToCoreSimplifiedgetModuleGraphisLoadedisLoadedModule getBindingsgetInsts getModuleInfomodInfoTyThingsmodInfoTopLevelScopemodInfoExportsmodInfoExportsWithSelectorsmodInfoInstancesmodInfoIsExportedNamemkNamePprCtxForModulemodInfoLookupName modInfoIface modInfoRdrEnv modInfoSafemodInfoModBreaks isDictonaryIdlookupGlobalNamefindGlobalAnnsgetGREgetNameToInstancesIndexpprParenSymNamegetTokenStreamgetRichTokenStreamaddSourceToTokensshowRichTokenStream findModulefindQualifiedModulerenamePkgQualMrenameRawPkgQualM lookupModulelookupQualifiedModuleisModuleTrustedmoduleTrustReqs setGHCiMonadparserinterpretPackageEnvGHC.Data.FastString FastStringGHC.Driver.Main getHscEnvmkInternalNameGHC.Types.Name.Occurrence HasOccNameoccNameOccName occNameFS occNameSpaceGHC.Data.FastString.Env FastStringEnv TidyOccEnvOccSetOccEnv NameSpace mkVarOccFSmkRecFldSelOcc emptyFsEnv extendFsEnv lookupFsEnvmkFsEnvtcNameclsName tcClsNamedataName srcDataNametvNamevarNameisDataConNameSpaceisTcClsNameSpace isTvNameSpaceisVarNameSpaceisValNameSpace pprNameSpacepprNonVarNameSpacepprNameSpaceBrief pprOccName mkOccName mkOccNameFSmkVarOcc mkDataOcc mkDataOccFS mkTyVarOcc mkTyVarOccFSmkTcOcc mkTcOccFSmkClsOcc mkClsOccFS demoteOccNamepromoteOccName emptyOccEnv unitOccEnv extendOccEnvextendOccEnvList lookupOccEnvmkOccEnv elemOccEnv foldOccEnvnonDetOccEnvElts plusOccEnv plusOccEnv_CextendOccEnv_CextendOccEnv_Acc mapOccEnv mkOccEnv_C delFromOccEnvdelListFromOccEnv filterOccEnv alterOccEnv minusOccEnv minusOccEnv_C pprOccEnv emptyOccSet unitOccSetmkOccSet extendOccSetextendOccSetList unionOccSetsunionManyOccSets minusOccSet elemOccSet isEmptyOccSetintersectOccSet filterOccSet occSetToEnv occNameStringsetOccNameSpaceisVarOccisTvOccisTcOccisValOcc isDataOcc isDataSymOccisSymOcc parenSymOccstartsWithUnderscoreisDerivedOccNameisDefaultMethodOccisTypeableBindOccmkDataConWrapperOcc mkWorkerOcc mkMatcherOcc mkBuilderOccmkDefaultMethodOccmkClassOpAuxOcc mkDictOccmkIPOcc mkSpecOccmkForeignExportOcc mkRepEqOccmkClassDataConOcc mkNewTyCoOcc mkInstTyCoOcc mkEqPredCoOcc mkCon2TagOcc mkTag2ConOcc mkMaxTagOcc mkDataTOcc mkDataCOcc mkTyConRepOccmkGenRmkGen1RmkDataConWorkerOccmkSuperDictAuxOccmkSuperDictSelOcc mkLocalOcc mkInstTyTcOcc mkDFunOcc mkMethodOccemptyTidyOccEnvinitTidyOccEnvdelTidyOccEnvListavoidClashesOccEnv tidyOccName rdrNameOcc mkRdrUnqual mkRdrQualGHC.Types.Unique.SupplytakeUniqFromSupplySDocIsDocLinevcat$$linelines_dualDocIsLinetext<>char<+>ftextztexthcathsepsepfsepdualLineIsOutputdocWithContextHDocHLineOutputableBndrpprBndr pprPrefixOcc pprInfixOccbndrIsJoin_maybe BindingSite LambdaBindCaseBind CasePatBindLetBindPDoc OutputablePpdoc Outputableppr SDocContextSDC sdocStyle sdocColSchemesdocLastColoursdocShouldUseColorsdocDefaultDepthsdocLineLengthsdocCanUseUnicodesdocHexWordLiterals sdocPprDebugsdocPrintUnicodeSyntaxsdocPrintCaseAsLetsdocPrintTypecheckerElaborationsdocPrintAxiomIncompssdocPrintExplicitKindssdocPrintExplicitCoercionssdocPrintExplicitRuntimeRepssdocPrintExplicitForallssdocPrintPotentialInstancessdocPrintEqualityRelationssdocSuppressTickssdocSuppressTypeSignaturessdocSuppressTypeApplicationssdocSuppressIdInfosdocSuppressCoercionssdocSuppressCoercionTypessdocSuppressUnfoldingssdocSuppressVarKindssdocSuppressUniquessdocSuppressModulePrefixessdocSuppressStgExtssdocSuppressStgRepssdocErrorSpanssdocStarIsTypesdocLinearTypessdocListTuplePunssdocPrintTypeAbbreviationssdocUnitIdForUser QualifyName NameUnqualNameQualNameNotInScope1NameNotInScope2IsEmptyOrSingleton PromotedItemPromotedItemListSyntaxPromotedItemTupleSyntaxPromotedItemDataConPromotionTickContext PromTickCtxptcListTuplePunsptcPrintRedundantPromTicksQueryPromotionTickQueryQualifyPackageQueryQualifyModuleQueryQualifyNameDepth AllTheWayPartWay DefaultDepthPprStylePprUserPprDumpPprCodecommacolonintwordintegerfloatdoublequoteparensisEmptyptextsemispaceequalslparenrparenlbrackrbracklbracerbracerationalquotes doubleQuotesbracketsbracesnesthang hangNotEmpty punctuate$+$catfcatisListEmptyOrSingletonreallyAlwaysQualifyNamesalwaysQualifyNamesneverQualifyNamesalwaysQualifyModulesneverQualifyModulesalwaysQualifyPackagesneverQualifyPackagesalwaysPrintPromTickreallyAlwaysQualify neverQualifydefaultUserStyledefaultDumpStyle mkDumpStyledefaultErrStyle mkErrStylecmdlineParserStyle mkUserStyle withUserStyle withErrStylesetStyleColouredrunSDocdefaultSDocContexttraceSDocContext withPprStyle pprDeeper pprDeeperList pprSetDepth getPprStylesdocWithContext sdocOptionupdSDocContextqualName qualModule qualPackagepromTick queryQual codeStyle dumpStyle userStyle getPprDebug ifPprDebug whenPprDebug printSDoc printSDocLnbufLeftRenderSDocpprCoderenderWithContextshowSDocOneLineshowSDocUnsafe showPprUnsafepprDebugAndThen docToSDoc doublePrec angleBracketscparen blankLinedcolonarrowlollipoplarrowdarrowarrowtlarrowtarrowttlarrowttlambda underscoredotvbar forAllLitbullet unicodeSyntaxppWhenppUnless ppWhenOptionppUnlessOptioncolouredkeyword pprModuleName pprHsChar pprHsString pprHsBytesprimCharSuffixprimFloatSuffix primIntSuffixprimDoubleSuffixprimWordSuffixprimInt8SuffixprimWord8SuffixprimInt16SuffixprimWord16SuffixprimInt32SuffixprimWord32SuffixprimInt64SuffixprimWord64Suffix pprPrimChar pprPrimInt pprPrimWord pprPrimInt8 pprPrimInt16 pprPrimInt32 pprPrimInt64 pprPrimWord8 pprPrimWord16 pprPrimWord32 pprPrimWord64 pprPrefixVar pprInfixVarpprFastFilePathpprFilePathString pprWithCommas pprWithBarsspaceIfSingleQuote interppSP interpp'SP interpp'SP' pprQuotedListquotedListWithOrquotedListWithNor intWithCommasspeakNthspeakNspeakNOfpluralsingularisOrAredoOrDoes itsOrTheir thisOrThese hasOrHavebPutHDocGHC.Driver.Errors printMessageshandleFlagWarningsprintOrThrowDiagnosticsmkDriverPsHeaderMessageHscGHC.Types.SourceText SourceText NoSourceTextFreshT runFreshT runFreshHscfreshfreshVardebugtypeletnoapplyOptions parseOptsModeAdvancedSimple parseModeLargeAnonNameslargeAnon_emptylargeAnon_insertlargeAnon_applyPendinglargeAnon_letRecordTlargeAnon_letInsertAstypelet_castEqualgetLargeAnonNamesrecordWithTypelet simpleLam sourcePluginconstructEquivClasses canonicalizeArityGHC.Core.PredicatePred ClassPredEqPred IrredPred ForAllPredCoercionGHC.Types.UniqueUniqueGHC.Tc.Solver.InertSetInertSet GHC.Tc.TypesTcGblEnvRoleNominalRepresentationalPhantomBoxityBoxedUnboxedGHC.Tc.Types.OriginCtOriginUnitIdunitIdFSTcTyVarGHC.Tc.Utils.TcType MetaDetailsGHC.CoreCoreExprCoreBndrExprVarUnivCoProvenanceGHC.Types.Unique.FMUniqFMGHC.Types.Unique.DFMUniqDFM TupleSort BoxedTuple UnboxedTupleConstraintTupleEvVarCoVar classTyCon CoercionHole ch_co_varch_refEqRelNomEqReprEqGHC.Core.Reduction ReductionreductionCoercionreductionReducedType MonadThings lookupThinglookupId lookupDataCon lookupTyCon FamInstEnvTcLevelMetaInfoTcType TcTyThingTcLclEnvGHC.Tc.Types.EvidenceEvExprEvTermEvBindeb_lhseb_rhs EvBindsVarInstEnvsGHC.Unit.Finder.Types FindResultFound NoPackage FoundMultipleNotFoundfr_pathsfr_pkgfr_mods_hiddenfr_pkgs_hidden fr_unusablesfr_suggestionsGHC.Tc.Types.ConstraintCtLoc CtFlavour CtEvidence ctev_pred ctev_evarctev_loc ctev_destTcEvDest EvVarDestHoleDestQCInstCtTcPluginRewriteResultTcPluginNoRewriteTcPluginRewriteTotcPluginReductiontcRewriterNewWantedsTcPluginSolveResult TcPluginOkTcPluginContradictiontcPluginInsolubleCtstcPluginSolvedCtstcPluginNewCts0ghc-tcplugin-api-0.11.0.0-AUb9nqZrIGoDfhcM40UAT5GHC.TcPlugin.API.InternalTcPlugin tcPluginInit tcPluginSolvetcPluginRewrite tcPluginStop TcPluginMTcPluginRewriterTcPluginSolver RewriteEnvGHC.Tc.Solver.MonadTcSTcPluginErrorMessageTxt PrintType:|::-:MonadTcPluginWork MonadTcPlugin TcPluginStageStopInitSolveRewriteManyTyOneTyGHC.Tc.Utils.MonadnewNameGHC.TcPlugin.API newUnique mkTyConTyGHC.Utils.Panic.PlainpanicunpackFSfsLitpprPanic isMetaTyVar mkForAllTyemptyUFM listToUFM lookupUDFMlookupUDFM_DirectlyelemUDFMstringToUnitIdpromoteDataConmkTyVargetTyVar_maybetyConAppTyCon_maybesplitTyConApp_maybe mkCoercionTy mkTyConAppmkAppTy isCoercionTyGHC.Core.Coercion mkTransComkSymComkUnivComkReflCo mkTyVarTy mkTyVarTys mkInvisFunTy mkInvisFunTysmkVisFunTyManymkVisFunTysMany mkForAllTysmkPiTymkPiTys isTyVarTymkAppTyssplitAppTy_maybe splitAppTys mkNumLitTy isNumLitTy mkStrLitTy isStrLitTytyConAppTyConPicky_maybeisCoercionTy_maybeGHC.Core.TyCo.CompareeqTypemkPrimEqPredRoleclassifyPredType mkClassPred classDataCon mkLocalId isSkolemTyVar lookupEvBind evCoercionevCast evDataConAppmkNonCanonical ctEvidencectLocctOriginctPred ctFlavourctEqRelctEvExprbumpCtLocDepthfindImportedModulegetEnvs readTcRef writeTcRef setCtLocMgetTcEvBindsMapsetTcEvBindsMapnewEvVar newWantednewCoercionHoleGHC.Tc.Utils.TcMTypeisFilledMetaTyVar_maybewriteMetaTyVar newFlexiTyVarzonkCt zonkTcType lookupOrigtcLookupGlobaltcLookupDataCon tcLookupClass tcLookupTyContcLookup tcLookupId getInstEnvsgetFamInstEnvs setEvBindmatchFam tcPluginIO tcPluginTraceisTouchableTcPluginMnewGiven askEvBinds askDeriveds askRewriteEnv mkTcPluginmkTcPluginErrorTypkgQualToPkgName resolveImportrewriteEnvCtLocsetCtLocRewriteMmkPluginUnivComkPluginUnivEvTermmkTyFamAppReduction getInertSet setInertSet Uniquable getUniquehasKeyGHC.Builtin.NamesallNameStringsallNameStringListitName mkUnboundName isUnboundNamebasicKnownKeyNamesgenericTyConNamespRELUDEgHC_PRIMgHC_PRIM_PANIC gHC_TYPES gHC_MAGICgHC_MAGIC_DICT gHC_CSTRING gHC_CLASSESgHC_PRIMOPWRAPPERSgHC_BASEgHC_ENUMgHC_GHCIgHC_GHCI_HELPERSgHC_SHOWgHC_READgHC_NUM gHC_MAYBEgHC_NUM_INTEGERgHC_NUM_NATURALgHC_NUM_BIGNATgHC_LIST gHC_TUPLEgHC_TUPLE_PRIM dATA_EITHER dATA_LIST dATA_STRING dATA_FOLDABLEdATA_TRAVERSABLEgHC_CONCgHC_IOgHC_IO_ExceptiongHC_STgHC_IX gHC_STABLEgHC_PTRgHC_ERRgHC_REAL gHC_FLOATgHC_TOP_HANDLER sYSTEM_IOdYNAMICtYPEABLEtYPEABLE_INTERNALgENERICS rEAD_PREClEXgHC_INTgHC_WORDmONAD mONAD_FIX mONAD_ZIP mONAD_FAILaRROW gHC_DESUGARrANDOMgHC_EXTS gHC_IS_LISTcONTROL_EXCEPTION_BASE gHC_GENERICS gHC_TYPEERROR gHC_TYPELITSgHC_TYPELITS_INTERNAL gHC_TYPENATSgHC_TYPENATS_INTERNAL dATA_COERCE dEBUG_TRACE uNSAFE_COERCEfOREIGN_C_CONSTPTR gHC_SRCLOC gHC_STACKgHC_STACK_TYPES gHC_STATICPTRgHC_STATICPTR_INTERNALgHC_FINGERPRINT_TYPEgHC_OVER_LABELS gHC_RECORDS rOOT_MAINmkInteractiveModule pRELUDE_NAME mAIN_NAME mkPrimModulemkBignumModule mkBaseModule mkBaseModule_mkThisGhcModulemkThisGhcModule_ mkMainModule mkMainModule_main_RDR_Unqualeq_RDRge_RDRle_RDRlt_RDRgt_RDR compare_RDR ltTag_RDR eqTag_RDR gtTag_RDR eqClass_RDR numClass_RDR ordClass_RDR enumClass_RDRmonadClass_RDRmap_RDR append_RDR foldr_RDR build_RDR returnM_RDR bindM_RDR failM_RDRleft_RDR right_RDR fromEnum_RDR toEnum_RDR enumFrom_RDRenumFromTo_RDRenumFromThen_RDRenumFromThenTo_RDRratioDataCon_RDRintegerAdd_RDRintegerMul_RDR ioDataCon_RDRnewStablePtr_RDR bindIO_RDR returnIO_RDRfromInteger_RDRfromRational_RDR minus_RDR times_RDRplus_RDR toInteger_RDRtoRational_RDRfromIntegral_RDRfromString_RDR fromList_RDR fromListN_RDR toList_RDR compose_RDRand_RDRnot_RDR dataToTag_RDRsucc_RDRpred_RDR minBound_RDR maxBound_RDR range_RDR inRange_RDR index_RDRunsafeIndex_RDRunsafeRangeSize_RDR readList_RDRreadListDefault_RDRreadListPrec_RDRreadListPrecDefault_RDR readPrec_RDR parens_RDR choose_RDRlexP_RDR expectP_RDR readField_RDRreadFieldHash_RDRreadSymField_RDRpunc_RDR ident_RDR symbol_RDRstep_RDRalt_RDR reset_RDRprec_RDR pfail_RDR showsPrec_RDR shows_RDRshowString_RDR showSpace_RDRshowCommaSpace_RDR showParen_RDR error_RDR u1DataCon_RDRpar1DataCon_RDRrec1DataCon_RDR k1DataCon_RDR m1DataCon_RDR l1DataCon_RDR r1DataCon_RDRprodDataCon_RDRcomp1DataCon_RDR unPar1_RDR unRec1_RDRunK1_RDR unComp1_RDRfrom_RDR from1_RDRto_RDRto1_RDRdatatypeName_RDRmoduleName_RDRpackageName_RDRisNewtypeName_RDR selName_RDR conName_RDR conFixity_RDRconIsRecord_RDRprefixDataCon_RDRinfixDataCon_RDRleftAssocDataCon_RDRrightAssocDataCon_RDRnotAssocDataCon_RDRuAddrDataCon_RDRuCharDataCon_RDRuDoubleDataCon_RDRuFloatDataCon_RDRuIntDataCon_RDRuWordDataCon_RDR uAddrHash_RDR uCharHash_RDRuDoubleHash_RDRuFloatHash_RDR uIntHash_RDR uWordHash_RDRfmap_RDR replace_RDRpure_RDRap_RDR liftA2_RDRfoldable_foldr_RDR foldMap_RDRnull_RDRall_RDR traverse_RDR mempty_RDR mappend_RDR varQual_RDR tcQual_RDR clsQual_RDR dataQual_RDR wildCardName runMainIOName runRWNameorderingTyConNameordLTDataConNameordEQDataConNameordGTDataConName specTyConNameeitherTyConNameleftDataConNamerightDataConName voidTyConName v1TyConName u1TyConName par1TyConName rec1TyConName k1TyConName m1TyConName sumTyConName prodTyConName compTyConName rTyConName dTyConName cTyConName sTyConName rec0TyConName d1TyConName c1TyConName s1TyConName repTyConName rep1TyConName uRecTyConNameuAddrTyConNameuCharTyConNameuDoubleTyConNameuFloatTyConName uIntTyConNameuWordTyConNameprefixIDataConNameinfixIDataConNameleftAssociativeDataConNamerightAssociativeDataConNamenotAssociativeDataConNamesourceUnpackDataConNamesourceNoUnpackDataConNamenoSourceUnpackednessDataConNamesourceLazyDataConNamesourceStrictDataConNamenoSourceStrictnessDataConNamedecidedLazyDataConNamedecidedStrictDataConNamedecidedUnpackDataConNamemetaDataDataConNamemetaConsDataConNamemetaSelDataConName divIntName modIntNamecstringLengthName eqStringNameunpackCStringNameunpackCStringAppendNameunpackCStringFoldrNameunpackCStringUtf8NameunpackCStringAppendUtf8NameunpackCStringFoldrUtf8Name inlineIdName eqClassNameeqName ordClassNamegeNamefunctorClassNamefmapNamemonadClassName thenMName bindMName returnMNamemonadFailClassName failMNameapplicativeClassNameapAName pureAName thenANamefoldableClassNametraversableClassNamesemigroupClassName sappendNamemonoidClassName memptyName mappendName mconcatName joinMNamealternativeClassName joinMIdKey apAClassOpKeypureAClassOpKeythenAClassOpKeyalternativeClassKeyconsiderAccessibleName dollarNameotherwiseIdName foldrName buildName augmentNamemapName appendName assertNamefromStringName numClassNamefromIntegerName minusName negateName bnbVarQual bnnVarQual bniVarQualbignatFromWordListName bignatEqNamebignatCompareNamebignatCompareWordNamenaturalToWordNamenaturalPopCountNamenaturalShiftRNamenaturalShiftLNamenaturalAddNamenaturalSubNamenaturalSubThrowNamenaturalSubUnsafeNamenaturalMulNamenaturalQuotRemNamenaturalQuotNamenaturalRemNamenaturalAndNamenaturalAndNotName naturalOrNamenaturalXorNamenaturalTestBitNamenaturalBitNamenaturalGcdNamenaturalLcmNamenaturalLog2NamenaturalLogBaseWordNamenaturalLogBaseNamenaturalPowModNamenaturalSizeInBaseNameintegerFromNaturalNameintegerToNaturalClampNameintegerToNaturalThrowNameintegerToNaturalNameintegerToWordNameintegerToIntNameintegerToWord64NameintegerToInt64NameintegerFromWordNameintegerFromWord64NameintegerFromInt64NameintegerAddNameintegerMulNameintegerSubNameintegerNegateNameintegerAbsNameintegerPopCountNameintegerQuotNameintegerRemNameintegerDivNameintegerModNameintegerDivModNameintegerQuotRemNameintegerEncodeFloatNameintegerEncodeDoubleNameintegerGcdNameintegerLcmNameintegerAndName integerOrNameintegerXorNameintegerComplementNameintegerBitNameintegerTestBitNameintegerShiftLNameintegerShiftRNamerationalTyConNameratioTyConNameratioDataConName realClassNameintegralClassNamerealFracClassNamefractionalClassNamefromRationalName toIntegerNametoRationalNamefromIntegralNamerealToFracNamemkRationalBase2NamemkRationalBase10NamefloatingClassNamerealFloatClassNameintegerToFloatNameintegerToDoubleNamenaturalToFloatNamenaturalToDoubleNamerationalToFloatNamerationalToDoubleName ixClassNametrModuleTyConNametrModuleDataConNametrNameTyConNametrNameSDataConNametrNameDDataConNametrTyConTyConNametrTyConDataConNamekindRepTyConNamekindRepTyConAppDataConNamekindRepVarDataConNamekindRepAppDataConNamekindRepFunDataConNamekindRepTYPEDataConNamekindRepTypeLitSDataConNamekindRepTypeLitDDataConNametypeLitSortTyConNametypeLitSymbolDataConNametypeLitNatDataConNametypeLitCharDataConNametypeableClassNametypeRepTyConNamesomeTypeRepTyConNamesomeTypeRepDataConName typeRepIdName mkTrTypeName mkTrConName mkTrAppName mkTrFunNametypeNatTypeRepNametypeSymbolTypeRepNametypeCharTypeRepNametrGhcPrimModuleNamestarKindRepNamestarArrStarKindRepNamestarArrStarArrStarKindRepNameconstraintKindRepNamewithDictClassNamenonEmptyTyConNameerrorMessageTypeErrorFamNametypeErrorTextDataConNametypeErrorAppendDataConNametypeErrorVAppendDataConNametypeErrorShowTypeDataConNameunsafeEqualityProofNameunsafeEqualityTyConNameunsafeReflDataConNameunsafeCoercePrimName toDynName dataClassNameassertErrorName traceName enumClassName enumFromNameenumFromToNameenumFromThenNameenumFromThenToNameboundedClassName concatName filterNamezipNameisListClassName fromListName fromListNName toListName getFieldName setFieldName showClassName readClassName genClassName gen1ClassNamedatatypeClassNameconstructorClassNameselectorClassNamegenericClassNamesghciIoClassNameghciStepIoMName ioTyConName ioDataConName thenIOName bindIOName returnIOName failIOName printName int8TyConNameint16TyConNameint32TyConNameint64TyConNameword8TyConNameword16TyConNameword32TyConNameword64TyConName ptrTyConNamefunPtrTyConNamestablePtrTyConNamenewStablePtrNamemonadFixClassNamemfixNamearrAName composeAName firstANameappAName choiceAName loopAName guardMName liftMNamemzipNametoAnnotationWrapperNamemonadPlusClassNameisStringClassNameknownNatClassNameknownSymbolClassNameknownCharClassNamefromLabelClassOpName ipClassNamehasFieldClassNamecallStackTyConNameemptyCallStackNamepushCallStackNamesrcLocDataConNamepLUGINSpluginTyConNamefrontendPluginTyConNamemakeStaticNamestaticPtrInfoTyConNamestaticPtrInfoDataConNamestaticPtrTyConNamestaticPtrDataConNamefromStaticPtrNamefingerprintDataConNameconstPtrConNamevarQualtcQualclsQualdcQualmk_known_key_nameboundedClassKey enumClassKey eqClassKeyfloatingClassKeyfractionalClassKeyintegralClassKey monadClassKey dataClassKeyfunctorClassKey numClassKey ordClassKey readClassKey realClassKeyrealFloatClassKeyrealFracClassKey showClassKey ixClassKeytypeableClassKeywithDictClassKeymonadFixClassKeymonadFailClassKeymonadPlusClassKeyrandomClassKeyrandomGenClassKeyisStringClassKeyapplicativeClassKeyfoldableClassKeytraversableClassKey genClassKey gen1ClassKeydatatypeClassKeyconstructorClassKeyselectorClassKeyknownNatClassNameKeyknownSymbolClassNameKeyknownCharClassNameKeyghciIoClassKeysemigroupClassKeymonoidClassKey ipClassKeyhasFieldClassNameKeyaddrPrimTyConKeyarrayPrimTyConKey boolTyConKeybyteArrayPrimTyConKeystringTyConKeycharPrimTyConKey charTyConKeydoublePrimTyConKeydoubleTyConKeyfloatPrimTyConKey floatTyConKey fUNTyConKeyintPrimTyConKey intTyConKeyint8PrimTyConKey int8TyConKeyint16PrimTyConKey int16TyConKeyint32PrimTyConKey int32TyConKeyint64PrimTyConKey int64TyConKeyintegerTyConKeynaturalTyConKey listTyConKeyforeignObjPrimTyConKey maybeTyConKeyweakPrimTyConKeymutableArrayPrimTyConKeymutableByteArrayPrimTyConKeyorderingTyConKeymVarPrimTyConKeyioPortPrimTyConKey ratioTyConKeyrationalTyConKeyrealWorldTyConKeystablePtrPrimTyConKeystablePtrTyConKey eqTyConKey heqTyConKeyctArrowTyConKeyccArrowTyConKeytcArrowTyConKeystatePrimTyConKeystableNamePrimTyConKeystableNameTyConKeyeqPrimTyConKeyeqReprPrimTyConKeyeqPhantPrimTyConKeymutVarPrimTyConKey ioTyConKeywordPrimTyConKey wordTyConKeyword8PrimTyConKey word8TyConKeyword16PrimTyConKeyword16TyConKeyword32PrimTyConKeyword32TyConKeyword64PrimTyConKeyword64TyConKey kindConKey boxityConKey typeConKeythreadIdPrimTyConKeybcoPrimTyConKey ptrTyConKeyfunPtrTyConKeytVarPrimTyConKeycompactPrimTyConKeystackSnapshotPrimTyConKeypromptTagPrimTyConKeyeitherTyConKey voidTyConKeynonEmptyTyConKey dictTyConKeyliftedTypeKindTyConKeyunliftedTypeKindTyConKey tYPETyConKeycONSTRAINTTyConKeyconstraintKindTyConKeylevityTyConKeyruntimeRepTyConKeyvecCountTyConKeyvecElemTyConKeyliftedRepTyConKeyunliftedRepTyConKeyzeroBitRepTyConKeyzeroBitTypeTyConKeypluginTyConKeyfrontendPluginTyConKeytrTyConTyConKeytrModuleTyConKeytrNameTyConKeykindRepTyConKeytypeLitSortTyConKey v1TyConKey u1TyConKey par1TyConKey rec1TyConKey k1TyConKey m1TyConKey sumTyConKey prodTyConKey compTyConKey rTyConKey dTyConKey cTyConKey sTyConKey rec0TyConKey d1TyConKey c1TyConKey s1TyConKey repTyConKey rep1TyConKey uRecTyConKey uAddrTyConKey uCharTyConKeyuDoubleTyConKeyuFloatTyConKey uIntTyConKey uWordTyConKeyerrorMessageTypeErrorFamKeycoercibleTyConKeyproxyPrimTyConKey specTyConKey anyTyConKeysmallArrayPrimTyConKeysmallMutableArrayPrimTyConKeystaticPtrTyConKeystaticPtrInfoTyConKeycallStackTyConKeytypeRepTyConKeysomeTypeRepTyConKeysomeTypeRepDataConKeytypeSymbolAppendFamNameKeyunsafeEqualityTyConKeymultiplicityTyConKeyunrestrictedFunTyConKeymultMulTyConKeyint8X16PrimTyConKeyint16X8PrimTyConKeyint32X4PrimTyConKeyint64X2PrimTyConKeyint8X32PrimTyConKeyint16X16PrimTyConKeyint32X8PrimTyConKeyint64X4PrimTyConKeyint8X64PrimTyConKeyint16X32PrimTyConKeyint32X16PrimTyConKeyint64X8PrimTyConKeyword8X16PrimTyConKeyword16X8PrimTyConKeyword32X4PrimTyConKeyword64X2PrimTyConKeyword8X32PrimTyConKeyword16X16PrimTyConKeyword32X8PrimTyConKeyword64X4PrimTyConKeyword8X64PrimTyConKeyword16X32PrimTyConKeyword32X16PrimTyConKeyword64X8PrimTyConKeyfloatX4PrimTyConKeydoubleX2PrimTyConKeyfloatX8PrimTyConKeydoubleX4PrimTyConKeyfloatX16PrimTyConKeydoubleX8PrimTyConKeytypeSymbolKindConNameKeytypeCharKindConNameKeytypeNatAddTyFamNameKeytypeNatMulTyFamNameKeytypeNatExpTyFamNameKeytypeNatSubTyFamNameKeytypeSymbolCmpTyFamNameKeytypeNatCmpTyFamNameKeytypeCharCmpTyFamNameKeytypeLeqCharTyFamNameKeytypeNatDivTyFamNameKeytypeNatModTyFamNameKeytypeNatLogTyFamNameKeytypeConsSymbolTyFamNameKeytypeUnconsSymbolTyFamNameKeytypeCharToNatTyFamNameKeytypeNatToCharTyFamNameKeyconstPtrTyConKeycharDataConKeyconsDataConKeydoubleDataConKeyfalseDataConKeyfloatDataConKey intDataConKeynothingDataConKeyjustDataConKey eqDataConKey nilDataConKeyratioDataConKeyword8DataConKeystableNameDataConKeytrueDataConKeywordDataConKey ioDataConKey heqDataConKeycrossDataConKey inlDataConKey inrDataConKeygenUnitDataConKeyleftDataConKeyrightDataConKeyordLTDataConKeyordEQDataConKeyordGTDataConKeymkDictDataConKeycoercibleDataConKeystaticPtrDataConKeystaticPtrInfoDataConKeyfingerprintDataConKeysrcLocDataConKeytrTyConDataConKeytrModuleDataConKeytrNameSDataConKeytrNameDDataConKeytrGhcPrimModuleKeytypeErrorTextDataConKeytypeErrorAppendDataConKeytypeErrorVAppendDataConKeytypeErrorShowTypeDataConKeyprefixIDataConKeyinfixIDataConKeyleftAssociativeDataConKeyrightAssociativeDataConKeynotAssociativeDataConKeysourceUnpackDataConKeysourceNoUnpackDataConKeynoSourceUnpackednessDataConKeysourceLazyDataConKeysourceStrictDataConKeynoSourceStrictnessDataConKeydecidedLazyDataConKeydecidedStrictDataConKeydecidedUnpackDataConKeymetaDataDataConKeymetaConsDataConKeymetaSelDataConKeyvecRepDataConKeytupleRepDataConKeysumRepDataConKeyboxedRepDataConKeyboxedRepDataConTyConKeytupleRepDataConTyConKeyruntimeRepSimpleDataConKeysliftedDataConKeyunliftedDataConKeyvecCountDataConKeysvecElemDataConKeyskindRepTyConAppDataConKeykindRepVarDataConKeykindRepAppDataConKeykindRepFunDataConKeykindRepTYPEDataConKeykindRepTypeLitSDataConKeykindRepTypeLitDDataConKeytypeLitSymbolDataConKeytypeLitNatDataConKeytypeLitCharDataConKeyunsafeReflDataConKey oneDataConKeymanyDataConKeyintegerISDataConKeyintegerINDataConKeyintegerIPDataConKeynaturalNSDataConKeynaturalNBDataConKey wildCardKeyabsentErrorIdKeyabsentConstraintErrorIdKey augmentIdKey appendIdKey buildIdKey foldrIdKeyrecSelErrorIdKeyseqIdKeyabsentSumFieldErrorIdKey eqStringIdKeynoMethodBindingErrorIdKeynonExhaustiveGuardsErrorIdKeyimpossibleErrorIdKeyimpossibleConstraintErrorIdKey patErrorIdKeyrealWorldPrimIdKeyrecConErrorIdKeyunpackCStringUtf8IdKeyunpackCStringAppendUtf8IdKeyunpackCStringFoldrUtf8IdKeyunpackCStringIdKeyunpackCStringAppendIdKeyunpackCStringFoldrIdKey voidPrimIdKeytypeErrorIdKey divIntIdKey modIntIdKeycstringLengthIdKey concatIdKey filterIdKeyzipIdKey bindIOIdKey returnIOIdKeynewStablePtrIdKey printIdKey failIOIdKey nullAddrIdKey voidArgIdKeyotherwiseIdKey assertIdKeyleftSectionKeyrightSectionKey rootMainKey runMainKey thenIOIdKey lazyIdKeyassertErrorIdKey oneShotKeyrunRWKeytraceKey nospecIdKey inlineIdKeymapIdKey dollarIdKeycoercionTokenIdKeyconsiderAccessibleIdKey noinlineIdKeynoinlineConstraintIdKeyintegerToFloatIdKeyintegerToDoubleIdKeynaturalToFloatIdKeynaturalToDoubleIdKeyrationalToFloatIdKeyrationalToDoubleIdKey coerceKey unboundKeyfromIntegerClassOpKeyminusClassOpKeyfromRationalClassOpKeyenumFromClassOpKeyenumFromThenClassOpKeyenumFromToClassOpKeyenumFromThenToClassOpKey eqClassOpKey geClassOpKeynegateClassOpKeybindMClassOpKeythenMClassOpKeyfmapClassOpKeyreturnMClassOpKey mfixIdKeyfailMClassOpKeyfromLabelClassOpKey arrAIdKey composeAIdKey firstAIdKey appAIdKey choiceAIdKey loopAIdKeyfromStringClassOpKeytoAnnotationWrapperIdKeyfromIntegralIdKeyrealToFracIdKeytoIntegerClassOpKeytoRationalClassOpKey guardMIdKey liftMIdKey mzipIdKeyghciStepIoMClassOpKeyisListClassKeyfromListClassOpKeyfromListNClassOpKeytoListClassOpKey proxyHashKey mkTyConKey mkTrTypeKey mkTrConKey mkTrAppKeytypeNatTypeRepKeytypeSymbolTypeRepKeytypeCharTypeRepKey typeRepIdKey mkTrFunKey trTYPEKeytrTYPE'PtrRepLiftedKeytrRuntimeRepKeytr'PtrRepLiftedKeytrLiftedRepKeystarKindRepKeystarArrStarKindRepKeystarArrStarArrStarKindRepKeyconstraintKindRepKey toDynIdKeybitIntegerIdKey eqSCSelIdKey heqSCSelIdKeycoercibleSCSelIdKeysappendClassOpKeymemptyClassOpKeymappendClassOpKeymconcatClassOpKeyemptyCallStackKeypushCallStackKeyfromStaticPtrClassOpKey makeStaticKeyunsafeEqualityProofIdKeyunsafeCoercePrimIdKeygetFieldClassOpKeysetFieldClassOpKeyintegerFromNaturalIdKeyintegerToNaturalClampIdKeyintegerToNaturalThrowIdKeyintegerToNaturalIdKeyintegerToWordIdKeyintegerToIntIdKeyintegerToWord64IdKeyintegerToInt64IdKeyintegerAddIdKeyintegerMulIdKeyintegerSubIdKeyintegerNegateIdKeyintegerAbsIdKeyintegerPopCountIdKeyintegerQuotIdKeyintegerRemIdKeyintegerDivIdKeyintegerModIdKeyintegerDivModIdKeyintegerQuotRemIdKeyintegerEncodeFloatIdKeyintegerEncodeDoubleIdKeyintegerGcdIdKeyintegerLcmIdKeyintegerAndIdKeyintegerOrIdKeyintegerXorIdKeyintegerComplementIdKeyintegerBitIdKeyintegerTestBitIdKeyintegerShiftLIdKeyintegerShiftRIdKeyintegerFromWordIdKeyintegerFromWord64IdKeyintegerFromInt64IdKeynaturalToWordIdKeynaturalPopCountIdKeynaturalShiftRIdKeynaturalShiftLIdKeynaturalAddIdKeynaturalSubIdKeynaturalSubThrowIdKeynaturalSubUnsafeIdKeynaturalMulIdKeynaturalQuotRemIdKeynaturalQuotIdKeynaturalRemIdKeynaturalAndIdKeynaturalAndNotIdKeynaturalOrIdKeynaturalXorIdKeynaturalTestBitIdKeynaturalBitIdKeynaturalGcdIdKeynaturalLcmIdKeynaturalLog2IdKeynaturalLogBaseWordIdKeynaturalLogBaseIdKeynaturalPowModIdKeynaturalSizeInBaseIdKeybignatFromWordListIdKey bignatEqIdKeybignatCompareIdKeybignatCompareWordIdKeymkRationalBase2IdKeymkRationalBase10IdKeynumericClassKeysfractionalClassKeysstandardClassKeysderivableClassKeysinteractiveClassNamesinteractiveClassKeyspretendNameIsInScopeGHC.Builtin.Types BoxingInfoBI_NoBoxNeededBI_NoBoxAvailableBI_Box bi_data_con bi_inst_con bi_boxed_typesumTyCon sumDataConcTupleSelIdNamecTupleTyConNamecTupleDataConName cTupleDataCon tupleTyCon tupleDataConpromotedTupleDataCon integerTy naturalTytupleDataConNametupleTyConName multMulTyConunrestrictedFunTyConmanyDataConTyCon manyDataConTyoneDataConTyCon oneDataConTymultiplicityTymultiplicityTyConunboxedTupleKind anyTypeOfKindint8ElemRepDataConTyint16ElemRepDataConTyint32ElemRepDataConTyint64ElemRepDataConTyword8ElemRepDataConTyword16ElemRepDataConTyword32ElemRepDataConTyword64ElemRepDataConTyfloatElemRepDataConTydoubleElemRepDataConTy vec2DataConTy vec4DataConTy vec8DataConTyvec16DataConTyvec32DataConTyvec64DataConTyintRepDataConTyint8RepDataConTyint16RepDataConTyint32RepDataConTyint64RepDataConTywordRepDataConTyword8RepDataConTyword16RepDataConTyword32RepDataConTyword64RepDataConTyaddrRepDataConTyfloatRepDataConTydoubleRepDataConTyliftedDataConTyunliftedDataConTy liftedRepTy unliftedRepTy zeroBitRepTyvecRepDataConTyContupleRepDataConTyConboxedRepDataConTyConliftedDataConTyCon runtimeRepTylevityTyruntimeRepTyCon levityTyCon vecCountTyCon vecElemTyConconstraintKindliftedRepTyConunliftedRepTyConliftedTypeKindTyConunliftedTypeKindTyConliftedTypeKindunliftedTypeKindzeroBitTypeKindconstraintKindTyConNameliftedTypeKindTyConNameunitTycoercibleTyConheqTyConmkBoxedTupleTycharTytypeSymbolKind listTyConisLiftedTypeKindTyConName tYPETyCon tYPETyConNametYPEKindcONSTRAINTTyConcONSTRAINTTyConNamecONSTRAINTKind wiredInTyConsmkWiredInTyConNamemkWiredInIdName eqTyConName eqTyCon_RDR heqTyConNamecoercibleTyConName charTyConName intTyConName boolTyConName listTyConNamenilDataConNameconsDataConNamemaybeTyConNamenothingDataConNamejustDataConName wordTyConNamefloatTyConNamedoubleTyConNameanyTyConanyTymakeRecoveryTyCon boolTyCon_RDR false_RDRtrue_RDR intTyCon_RDR charTyCon_RDRstringTyCon_RDRintDataCon_RDR listTyCon_RDRconsDataCon_RDRtypeSymbolKindConisBuiltInOcc_maybeisPunOcc_maybe mkTupleStr cTupleTyConcTupleTyConNamesisCTupleTyConNamecTupleTyConNameArity_maybecTupleDataConNames cTupleSelIdmkPromotedPairTyisPromotedPairType unitTyCon unitTyConKey unitDataCon unitDataConId soloTyCon pairTyCon unboxedUnitTyunboxedUnitTyConunboxedUnitDataConunboxedSumKindeqTyConeqClass eqDataConheqClass heqDataConcoercibleClasscoercibleDataConmultiplicityTyConNameoneDataConNamemanyDataConName oneDataCon manyDataConunrestrictedFunTyConNameconstraintKindTyContypeToTypeKindunliftedTypeKindTyConNameunliftedDataConTyConsumRepDataConTyConliftedRepTyConNameunliftedRepTyConName charTyCon charDataConstringTyintTyintTyCon intDataConwordTy wordTyCon wordDataConword8Ty word8TyCon word8DataConfloatTy floatTyCon floatDataCondoubleTy doubleTyCon doubleDataCon boxingDataConboolTy boolTyCon falseDataCon trueDataConfalseDataConId trueDataConId orderingTyCon ordLTDataCon ordEQDataCon ordGTDataConordLTDataConIdordEQDataConIdordGTDataConIdmkListTy nilDataCon consDataCon maybeTyConnothingDataCon justDataConmkPromotedMaybeTy mkMaybeTyisPromotedMaybeTy mkTupleTy mkTupleTy1mkConstraintTupleTymkSumTypromotedTrueDataConpromotedFalseDataConpromotedNothingDataConpromotedJustDataConpromotedLTDataConpromotedEQDataConpromotedGTDataConpromotedConsDataConpromotedNilDataConmkPromotedListTyintegerTyConNameintegerISDataConNameintegerIPDataConNameintegerINDataConName integerTyConintegerISDataConintegerIPDataConintegerINDataConnaturalTyConNamenaturalNSDataConNamenaturalNBDataConName naturalTyConnaturalNSDataConnaturalNBDataCon filterCTuple primTyConsunexposedPrimTyConsexposedPrimTyConscharPrimTyConNameintPrimTyConNameint8PrimTyConNameint16PrimTyConNameint32PrimTyConNameint64PrimTyConNamewordPrimTyConNameword8PrimTyConNameword16PrimTyConNameword32PrimTyConNameword64PrimTyConNameaddrPrimTyConNamefloatPrimTyConNamedoublePrimTyConNamemkTemplateKindVarmkTemplateKindVarsmkTemplateTyVarsFrommkTemplateTyVarsmkTemplateTyConBindersmkTemplateKiTyVarsmkTemplateKiTyVarmkTemplateKindTyConBindersmkTemplateAnonTyConBinders alphaTyVar betaTyVar gammaTyVar deltaTyVaralphaTyVarSpec betaTyVarSpecgammaTyVarSpecdeltaTyVarSpecalphaConstraintTyVaralphaConstraintTyalphaTysalphaTybetaTygammaTydeltaTyalphaTyVarsUnliftedRepalphaTyVarUnliftedRepalphaTysUnliftedRepalphaTyUnliftedRepruntimeRep1TyVarruntimeRep2TyVarruntimeRep3TyVarruntimeRep1TyVarInfruntimeRep2TyVarInf runtimeRep1Ty runtimeRep2Ty runtimeRep3TyopenAlphaTyVar openBetaTyVaropenGammaTyVaropenAlphaTyVarSpecopenBetaTyVarSpecopenGammaTyVarSpec openAlphaTy openBetaTy openGammaTy levity2TyVar levity1TyVarlevity1TyVarInflevity2TyVarInf levity1Ty levity2TylevPolyAlphaTyVarlevPolyBetaTyVarlevPolyAlphaTyVarSpeclevPolyBetaTyVarSpeclevPolyAlphaTy levPolyBetaTymultiplicityTyVar1multiplicityTyVar2funTyFlagTyCon isArrowTyCon fUNTyConNamectArrowTyConNameccArrowTyConNametcArrowTyConNamefUNTyCon ctArrowTyCon ccArrowTyCon tcArrowTyCon charPrimTy charPrimTyCon intPrimTy intPrimTyCon int8PrimTy int8PrimTyCon int16PrimTyint16PrimTyCon int32PrimTyint32PrimTyCon int64PrimTyint64PrimTyCon wordPrimTy wordPrimTyCon word8PrimTyword8PrimTyCon word16PrimTyword16PrimTyCon word32PrimTyword32PrimTyCon word64PrimTyword64PrimTyCon addrPrimTy addrPrimTyCon floatPrimTyfloatPrimTyCon doublePrimTydoublePrimTyCon mkStatePrimTystatePrimTyConrealWorldTyCon realWorldTyrealWorldStatePrimTy mkProxyPrimTyproxyPrimTyCon eqPrimTyConeqReprPrimTyConeqPhantPrimTyCon equalityTyConarrayPrimTyConmutableArrayPrimTyConmutableByteArrayPrimTyConbyteArrayPrimTyConsmallArrayPrimTyConsmallMutableArrayPrimTyCon mkArrayPrimTybyteArrayPrimTymkSmallArrayPrimTymkMutableArrayPrimTymkMutableByteArrayPrimTymkSmallMutableArrayPrimTymutVarPrimTyConmkMutVarPrimTyioPortPrimTyConmkIOPortPrimTy mVarPrimTyCon mkMVarPrimTy tVarPrimTyCon mkTVarPrimTystablePtrPrimTyConmkStablePtrPrimTystableNamePrimTyConmkStableNamePrimTycompactPrimTyCon compactPrimTystackSnapshotPrimTyConstackSnapshotPrimTy bcoPrimTy bcoPrimTyCon weakPrimTyCon mkWeakPrimTythreadIdPrimTythreadIdPrimTyConpromptTagPrimTyConmkPromptTagPrimTy int8X16PrimTyint8X16PrimTyCon int16X8PrimTyint16X8PrimTyCon int32X4PrimTyint32X4PrimTyCon int64X2PrimTyint64X2PrimTyCon int8X32PrimTyint8X32PrimTyConint16X16PrimTyint16X16PrimTyCon int32X8PrimTyint32X8PrimTyCon int64X4PrimTyint64X4PrimTyCon int8X64PrimTyint8X64PrimTyConint16X32PrimTyint16X32PrimTyConint32X16PrimTyint32X16PrimTyCon int64X8PrimTyint64X8PrimTyConword8X16PrimTyword8X16PrimTyConword16X8PrimTyword16X8PrimTyConword32X4PrimTyword32X4PrimTyConword64X2PrimTyword64X2PrimTyConword8X32PrimTyword8X32PrimTyConword16X16PrimTyword16X16PrimTyConword32X8PrimTyword32X8PrimTyConword64X4PrimTyword64X4PrimTyConword8X64PrimTyword8X64PrimTyConword16X32PrimTyword16X32PrimTyConword32X16PrimTyword32X16PrimTyConword64X8PrimTyword64X8PrimTyCon floatX4PrimTyfloatX4PrimTyCondoubleX2PrimTydoubleX2PrimTyCon floatX8PrimTyfloatX8PrimTyCondoubleX4PrimTydoubleX4PrimTyConfloatX16PrimTyfloatX16PrimTyCondoubleX8PrimTydoubleX8PrimTyCon GHC.Core.Make FloatBindFloatLet FloatCase MkStringIdsunpackCStringIdunpackCStringUtf8Id mkCoreApps mkCoreConApps mkIntExpr mkWordExpr mkCharExpr mkStringExpr mkFloatExpr mkDoubleExpr mkCoreLams mkCoreLets mkCoreLetGHC.Core.UtilsmkSingleAltCase sortQuantVars mkCoreAppmkWildEvBindermkWildValBinder mkWildCase mkIfThenElsecastBottomExpr mkLitRubbishmkUncheckedIntExpr mkIntExprInt mkIntegerExpr mkNaturalExprmkStringExprFSgetMkStringIdsmkStringExprFSWithmkCoreUnboxedTuplemkCoreTupBoxitymkCoreVarTupTy mkCoreTupmkCoreUnboxedSummkBigCoreVarTupSolomkBigCoreVarTup mkBigCoreTupmkBigCoreVarTupTymkBigCoreTupTyunitExpr mkChunkifiedchunkifymkBigTupleSelectormkBigTupleSelectorSolomkBigTupleCase wrapFloat wrapFloats floatBindings mkNilExpr mkConsExpr mkListExpr mkFoldrExpr mkBuildExpr mkNothingExpr mkJustExprmkRuntimeErrorApperrorIdsrEC_SEL_ERROR_IDrEC_CON_ERROR_ID pAT_ERROR_IDnO_METHOD_BINDING_ERROR_IDnON_EXHAUSTIVE_GUARDS_ERROR_ID tYPE_ERROR_IDaBSENT_SUM_FIELD_ERROR_IDmkImpossibleExprmkAbsentErrorAppisCanonicalVarEq getModule pprString FieldNamefromFastString$fIsStringFieldNameGHC.ShowShow fieldNameHashfieldNameLabel ResolvedNames clsAllFieldsclsKnownFields clsKnownHashclsRowHasField clsSubRowdataConDictAnyidEvidenceAllFieldsidEvidenceKnownFieldsidEvidenceKnownHashidEvidenceRowHasFieldidEvidenceSubRow idMkDictAny tyConDictAny tyConMergetyConFieldTypes tyConPairtyConSimpleFieldTypesnameResolution KnownFieldtoExprtoTypeknownFieldNameknownFieldInfo Classified TyConSubstclassifiedProductiveclassifiedExtendEquivClassclassifiedReconsiderprocess tyConSubstMaptyConSubstCanontyConSubstEmptytyConSubstLookuptyConSubstExtendclassify mkTyConSubstsplitTyConApp_upTotryApplyParseOk ParseNoMatch ParseErrorparseAll parseAll'withOrigparseConstraintparseConstraint' parseConsparseNilparseInjTyConApp ParseResult CKnownHashknownHashLabel knownHashTypeparseKnownHashsolveKnownHash alterExisting GHC.MaybeNothing$fFunctorSmallHashMapGHC.BaseFunctorcontainers-0.6.7Data.Map.InternalMap SmallHashMapnulllookupmemberalter NotSubRowTargetContainsShadowedFieldsSourceMissesFields KnownRowFieldKnownRowknownRecordVectorknownRecordVisibleknownRecordAllVisibleghc-prim GHC.TypesFalsefromKnownRowFieldtoKnownRowField inRowOrder inFieldOrder isSubRowOffromListknownRowFieldNameknownRowFieldIndexknownRowFieldInfo FieldIndex visibleMaptraverseSource getSource getTargetallKnown parsePairFields FieldLabel FieldKnownFieldVar parseFieldsparseFieldLabel argsFunctorargsParsedFieldsargsParsedKnownrewriteCSubRowsubrowParsedLHSsubrowParsedRHS subrowTypeLHS subrowTypeRHSsubrowTypeKind parseSubRow solveSubRow CRowHasField hasFieldLabelhasFieldRecordhasFieldTypeKindhasFieldTypeLabelhasFieldTypeRowhasFieldTypeFieldevidenceHasFieldparseRowHasFieldsolveRowHasField CKnownFieldsknownFieldsParsedFieldsknownFieldsTypeRecordknownFieldsTypeKindevidenceKnownFieldsparseKnownFieldssolveKnownFields CAllFieldsallFieldsParsedFieldsallFieldsTypeFieldsallFieldsTypeConstraintallFieldsTypeKindevidenceAllFieldsparseAllFieldssolveAllFieldssolveplugin ReverseIndex arrayIndex StrictArray(primitive-0.9.0.0-2Ut0u6h4ou624O572IFc4SData.Primitive.SmallArray SmallArrayupdate backpermute ArrayIndexZeroBasedIndexgetZeroBasedIndexgetReverseIndex! fromListNfromLazytoLazy// CanonicaltoVector getAtIndex setAtIndexfromRowOrderListtoRowOrderListarrayIndicesInRowOrderfromRowOrderArraytoRowOrderArrayapplydiffUpddiffInsdiffNew allNewFieldsBoolTrueCharDoubleFloatIntWordOrderingLTEQGTMaybeJust~ ghc-bignumGHC.Num.IntegerIntegershow showsPrecshowListGHC.EnumBoundedminBoundmaxBoundEnum enumFromToenumFromThenTo enumFromThenenumFromfromEnumtoEnumsuccpredGHC.RealRealFracproperFractiontruncateroundceilingfloorIntegral toIntegerquotremdivmodquotRemdivModGHC.ReadReadreadList readsPrecIO GHC.ClassesOrd>=compare<<=>maxminStringRational Fractional fromRational/recipReal toRationalEq==/=Monoidmconcatmappendmempty Semigroup Applicative*><*>liftA2<*fmap<$Monadreturn>>>>= Data.EitherEitherLeftRightFoldablefoldrfoldllengthfoldl1sumproductfoldr1maximumminimumelemfoldMapControl.Monad.Fail MonadFailfailGHC.IO.ExceptionIOError GHC.FloatFloatingpiexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanhGHC.NumNum fromInteger-negate+*abssignum RealFloat floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2Data.Traversable TraversablesequenceShowSText.ParserCombinators.ReadPReadSGHC.IOFilePath realToFrac fromIntegral$ otherwise++GHC.Listfilterid Data.Functor<$>GHC.PrimseqGHC.Errerroreven Data.Tuplefstuncurryhead System.IO writeFilegetLineputStrLncycleconcatprint^&&||noterrorWithoutStackTrace undefined=<<const.flip$!untilasTypeOfsubtract Data.Maybemaybetaillastinitscanlscanl1scanrscanr1iteraterepeat replicate takeWhile dropWhiletakedropsplitAtspanbreakreverseandoranyallnotElem concatMap!!zip3zipWith3unzipunzip3showsshowChar showString showParenodd^^gcdlcmsndcurrylex readPareneither Text.ReadreadsreadmapM_ sequence_ Data.OldListlinesunlineswordsunwords userErrorioErrorputCharputStrgetChar getContentsinteractreadFile appendFilereadLnreadIO DictSubRow fieldDicts rowHasFieldDictRowHasFieldevidenceRowHasField fieldNamesDictKnownFields fieldMetadataDictAny mkDictAny DictAllFieldsevidenceKnownHashprojectIndicesevidenceSubRownoInlineUnsafeCoreflectRowHasFieldIsLabel toCanonicalunsafeFromCanonical mkFieldNameunsafeGetFieldunsafeSetField $fShowFieldRecordConstraints