h&]:      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh# Safe-Inferredfi large-anon Optionally  qualified import declarationj large-anonOptional package namek large-anonOptional package namelmnopqrstuvwxyz{|}~ ji Safe-Inferred large-anonFresh name generation Safe-Inferred 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%&'( 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!t 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! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*********************  Safe-Inferred4V* 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%&14* large-anon3Names we need to parse constraints or generate coreListed alphabetically.******************** Safe-Inferred%&'18:7H* 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%&(QN* 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  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  , 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 8s. 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  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 2 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-Inferred8U * 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%&1V* 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-InferredW* 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%&8:^* large-anon%Reason why we cannot failed to prove SubRow* large-anon/We do not support precords 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-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-anon'Check if one row is a subrow of anotherIf it is, returns the paired information from both records in the order of the target& record along with the index into the source record.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.************** Safe-Inferred%&b* large-anonFind field type by name-Since records are left-biased, we report the first match, independent of what is in the record tail. If however we encounter an unknown (variable) field, we stop the search: even if a later field matches the one we're looking for, the unknown field might too and, crucially, might not have the same type.Put another way: unlike in checkAllFieldsKnown, we do not insist that all fields are known here, but only the fields up to (including) the one we're looking for.6Returns the index and the type of the field, if found.* large-anon$Return map from field name to type, if all fields are statically known* large-anonParse (x := y)******** Safe-Inferred%&1d* 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%&'(e+ large-anonFunctor argument, if any+ large-anon Parsed fields+ large-anon%Known record, if all fields are known+ Safe-Inferred%&1f+ 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 $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%&1j+ 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%&1k+ Safe-Inferredlj+ 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-Inferred?o+ large-anon Strict vector"Implemented as a wrapper around a +. NOTE: None of the operations on Vector do any bounds checking.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#'. ++++++++++++ Safe-Inferred%&'05?x + large-anonCanonical record representation3Canonicity here refers to the fact that we have no Diff to apply (see #Data.Record.Anonymous.Internal.Diff). In this case, 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).Type 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: When 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-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-anonTo strict vector+ large-anonFrom strict vector+ large-anonAll fields in row order O(n)+ large-anon From list of fields in row orderO(n).+ 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 %&05$ + 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 fields%Indices refer to the original record.+ 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-Inferred0h+++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*,,,,,,,,*,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------- --------------------------------------------------------  # Safe-Inferred+$ Safe-Inferred)*/01 - 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 (.-- !"---#-$%-&--'-(-)-------' Safe-Inferred)*/* large-anonEvidence of some constraint c This is like (#, but without the functor argument.*+----) Safe-Inferred%&'()*/01, 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&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,,-./012-3--------------------.............--+ Safe-Inferred%&'1K4 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 / 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 continue2.4............... Safe-Inferred$  !"#$%&'()*+./2$)("#&'2 !%$./*+  Safe-Inferred /01w#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 9: all fields in the record must be known up to the requested field (in case of shadowing). So the record may be fully known::{example :: Record f (Merge '[ "a" := Bool ] '[ "b" := Char ]) -> f Charexample r = get #b r:}but it doesn't have to be::{8example :: Record I (Merge '[ "a" := Bool ] r) -> I Boolexample = get #a:}However, just like in the case of unknown fields (see example in 9), if earlier 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 01A large-anonConstrained form of ?B large-anonConstrained form of AC large-anon Analogue of 02D large-anonConstrained form of CE large-anon Analogue of ,F large-anon Analogue of 34G large-anonLike F, but also include field namesH large-anon Analogue of 05I large-anonSimplified form of HJ large-anon Analogue of 06K large-anon Analogue of 07L large-anon Analogue of 89M large-anonConstrained form of KN large-anonConstrained form of LO large-anonRecord of dictionariesThis reifies an # constraint as a record. Inverse to R.P large-anon Establish # from a record of dictionaries Inverse to Q.Q large-anonRecord of field namesThis reifies a & constraint as a record. Inverse to P.R large-anon Establish & from a record of field names Inverse to O.S large-anon Record over r'& with evidence that every field is in r.This reifies a  constraint. Inverse to T.T large-anon Establish  from a record of evidence. Inverse to S.U 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 U= 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 P), 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 T. 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.V large-anon!Introduce type variable for a row%This can be used in conjunction with W::{=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:}W large-anonInsert field into a record and introduce type variable for the resultW 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),-01356789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX)356789:;<=>?ACDEFG@BHIJKLMNOPQR01ST,-UVWX Safe-Inferred1Y large-anon Empty recordZ large-anonInsert new field:{-example :: Record [ "a" := Bool, "b" := Int ] example = insert #a True $ insert #b 1 $ empty:}Instead of using Z and Y, you can also write this as 1example = ANON { a = True , b = 1 }[ large-anonApplicative insert This is a simple wrapper around Z, 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 / 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}_ 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 b, _ can also flatten " d rows. See % for additional discussion.` large-anon(Inject smaller record into larger recordThis is just the a setter.a large-anonLens from one record to anotherSee _ for examples (_/ is just the lens getter, without the setter).b 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 _::{#example :: Record '[ "a" := Bool ]6example = project $ merge (insert #a True empty) empty:}See & for additional discussion.c large-anon.Move from the simple to the advanced interface This is an O(1) operation.d large-anon.Move from the advanced to the simple interface This is an O(1) operation.e large-anonSequence all actionsf large-anon!Introduce type variable for a row%This can be used in conjunction with g::{;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:}g large-anonInsert field into a record and introduce type variable for the resultg 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 continue4YZ[\]^_`abcdefgh4YZ[\]^_`abcdefgh.=>?=@A=@B=@C=@D=@E=FG=HI=JK=LM=LN=OP=OP=QRST(ST(SUVSUWSUXSUXSUYSUYSUZS[\S]^S]_S]`a-ba-.cd$e$f$g$h$i$j$k$l$m$n$o'p'p)q)q)r)r)s)s)t)u+u,"<v/ %wx&y1z{2|}~45679*,"<v/ %wx&5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ,                                                                                                                                       !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((((((( (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*))*))*))*))*))*))*))*))*)**)**)**)** * * * * *=** * * * * * * * * * * * * * * * * * * * * * * **G***************************************=***=*******,**"4**************4**************************++++++++++++++++++++++++++++++++++*++++++719+++++4*"x79+y1~5}!++++,/ "+!=*+*++=++=+6=++=++=++=*+=*y=*+=++=++=++=++=++=++=++=++=++=++=++=++=++=++*++*++*++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=++=*+=*+=*+=*+=*+=*+=++=++=++=++=++=++=++=++*++*++*+,*+,*+,*+,*+,*+,=,,=,,=,,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=*,=*,=*,=,,=,,=*,=*,=*2=*,=*,=3,=3,=3,=3,=3,=3,=3,=3,=3,=3,=3,=3,=3*=,,=,,=,5=,*=,1=*,=*=*,=*,=*,=*,**,**,=*,**,**,**,**,,,,=*,=*,**,**,**,**,=+,**,**,=,,=,,=,,=,,=*,=*,=*,=,,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=+,=,,=,,=,,=,,=3,=3,=3,=3,=3,=3,=3,=3,=3,=,,=,,=,,=,,=,,=,,=,,=,-=--=+-=+-=+-=+-=+-=+-=*-=*-=*-=*-=*-=+-=+7=+-=+-=+-=+-=+-=+-=+-=+-=+-=+-=+-=+-=+-=+-=+-=+*=+-=+-=+-=+-=+-=+-=+-=+-=+-=--=+-=+-=+-=*-=*-=*-=*-=*-=--=--=--*+-*+-*+-$-$-$M$-$-$-$-$-$-$-$-$-$+$+$-$-$-$-''''-=>-)-)-)-)-)-)%)x)w)))t)/) ),)")<)&)v)y)1)6)7)9)~)5))2)})))))))*)|)z){)4))+/+ +++-+++5+,+"+<+&+x+%+w+v-$large-anon-0.2-QIjRrnpijB38PEIKiOO5EData.Record.Anon.OverloadingData.Record.AnonData.Record.Anon.AdvancedData.Record.Anon.Simple/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.Constraints.RowHasField,Data.Record.Anon.Internal.Plugin.TC.Rewriter6Data.Record.Anon.Internal.Plugin.TC.Constraints.SubRow;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 KnownSymbolData.Functor.ProductPairProduct Data.ProxyProxyControl.Category>>>'sop-core-0.5.0.2-8cmRYB37llUAjnR98I5kI0 Data.SOP.DictData.SOP.BasicFunctors:.:CompIKunIData.SOP.ConstraintComposeData.SOP.Classes-.->FnapFn*record-hasfield-1.0-E2C6vFF7RAK4MRP4MokC8ChasField ifThenElsesetFieldSubRow KnownHashhashValMerge AllFieldsSimpleFieldTypes FieldTypes KnownFields RowHasFieldRow:= Reflected SomeRecordSomeInRowFieldRecord applyPendinginjectlensmapcmapcmapMcpureapcollapse sequenceA'czipWith czipWithMreifyAllFieldsreflectAllFieldsreifyKnownFieldsreflectKnownFields reifySubRow reflectSubRow letRecordT letInsertAs castEqual toAdvanced fromAdvanced importDecl lookupName lookupOccNameghcGHCTypecheckedSourceTypecheckedModuletm_typechecked_sourcetm_renamed_sourcetm_parsed_module tm_internals_tm_checked_module_infoTypecheckedModtypecheckedSource moduleInfo renamedSource RenamedSource ParsedSource ParsedModulepm_parsed_sourcepm_mod_summarypm_extra_src_files ParsedMod parsedSource ModuleInfo GhcApiErrorDesugaredModuledm_typechecked_moduledm_core_module CoreModulecm_typescm_safe cm_modulecm_bindsworkingDirectoryChangedwithCleanupSessiontypecheckModuleshowRichTokenStream setTargetssetSessionDynFlagssetProgramDynFlagssetInteractiveDynFlags setGHCiMonadrunGhcTrunGhc removeTargetpprParenSymNameparserparseTargetFiles parseModuleparseDynamicFlagsobtainTermFromValobtainTermFromIdmoduleTrustReqsmodInfoTyThingsmodInfoTopLevelScope modInfoSafe modInfoRdrEnvmodInfoModBreaksmodInfoLookupNamemodInfoIsExportedNamemodInfoInstances modInfoIfacemodInfoExportsWithSelectorsmodInfoExportsmkPrintUnqualifiedForModule lookupModulelookupGlobalName loadModuleisModuleTrustedisLoaded isDictonaryIdinterpretPackageEnv initGhcMonad guessTargetgetTokenStream getTargetsgetRichTokenStreamgetProgramDynFlagsgetPrintUnqualgetNameToInstancesIndex getModuleInfogetModuleGraph getModSummarygetInteractiveDynFlagsgetInstsgetHistorySpangetGRE getGHCiMonad getBindings findModulefindGlobalAnns desugarModuledefaultErrorHandlerdefaultCleanupHandler dataConTypecompileToCoreSimplifiedcompileToCoreModule addTargetaddSourceToTokensGHC.Driver.Make LoadHowMuchLoadUpToLoadAllTargetsLoadDependenciesOftopSortModuleGraphloaddepanalEdepanalcyclicModuleErrGHC.Runtime.EvalGetDocsFailure NoDocsInIfaceInteractiveNameNameHasNoModuletypeKind showModulesetupBreakpoint setContextrunParsedDeclsrunDeclsWithLocationrunDecls resumeExecreconstructType parseNameparseInstanceHeadparseImportDecl parseExprmoduleIsInterpretedmoduleIsBootOrNotObjectLinkablegetResumeContextgetRdrNamesInScopegetNamesInScopegetInstancesForTypegetInfogetHistoryModulegetDocs getContextforwardexprType execStmt'execStmt execOptionsdynCompileExprcompileParsedExprRemotecompileParsedExprcompileExprRemote compileExprback abandonAllabandonGHC.Driver.Main getHscEnv GHC.Tc.Module TcRnExprMode TM_DefaultTM_InstrunTcInteractiveGHC.Parser.UtilsisStmtisImportisDecl hasImportGHC.Types.TyThing.Ppr pprFamInstGHC.Driver.Monad WarnErrLoggerGhcTGhcMonad getSession setSessionGhcputMsgM putLogMsgM pushLogHookMprintException popLogHookM modifyLoggergetSessionDynFlagsdefaultWarnErrLoggerGHC.Driver.Env.TypesHscEnv hsc_unit_env hsc_unit_dbshsc_type_env_var hsc_tmpfs hsc_targetshsc_static_plugins hsc_plugins hsc_mod_graph hsc_logger hsc_interp hsc_hooks hsc_dflagshsc_NChsc_IChsc_HPThsc_FChsc_EPSHscGHC.Runtime.ContextInteractiveImportIIDeclIIModuleGHC.Unit.Module.ModIface ModIface_mi_warns mi_used_th mi_usages mi_trust_pkgmi_trust mi_sig_ofmi_rules mi_modulemi_insts mi_hsc_srcmi_hpc mi_globals mi_fixities mi_final_exts mi_fam_insts mi_ext_fields mi_exports mi_doc_hdrmi_depsmi_decls mi_decl_docsmi_complete_matches mi_arg_docsModIfacemi_annsGHC.Unit.Module.Graph ModuleGraphneedsTemplateHaskellOrQQ mkModuleGraphmgModSummariesmgLookupModulemapMGemptyMGGHC.Unit.Module.ModSummary ModSummaryms_textual_imps ms_srcimps ms_parsed_mod ms_obj_datems_mod ms_location ms_iface_date ms_hspp_opts ms_hspp_file ms_hspp_buf ms_hsc_src ms_hs_date ms_hie_date ms_mod_nameGHC.HsHsParsedModule hpm_src_files hpm_moduleHsModule hsmodName hsmodLayout hsmodImportshsmodHaddockModHeader hsmodExportshsmodDeprecMessage hsmodDeclshsmodAnn AnnsModuleam_mainam_decls GHC.Hs.Utils CollectPass collectXXPat CollectFlagCollNoDictBindersCollWithDictBinders unitRecStmtTc unguardedRHSunguardedGRHSsspanHsLocaLBindsnl_HsVar nlWildPatName nlWildPat nlWildConPatnlVarPat nlTuplePatnlParPatnlNullaryConPatnlLitPatnlList nlInfixConPat nlHsVarAppsnlHsVar nlHsTyVar nlHsTyConApp nlHsTyApps nlHsTyAppnlHsSyntaxApps nlHsParTynlHsPar nlHsOpAppnlHsLitnlHsLam nlHsIntLitnlHsIf nlHsFunTynlHsDo nlHsDataConnlHsCasenlHsApps nlHsAppTy nlHsAppKindTynlHsAppnlConVarPatName nlConVarPat nlConPatNamenlConPat mkVarBindmkUntypedSplice mkTypedSplicemkTransformStmtmkTransformByStmt mkTopFunBind mkTcBindStmt mkSimpleMatchmkSimpleGeneratedFunBind mkRnBindStmt mkRecStmt mkPsBindStmtmkPrefixFunRhs mkPatSynBindmkParPat mkNPlusKPatmkNPat mkMatchGroupmkMatch mkLocatedList mkLetStmt mkLastStmt mkLHsWrapCo mkLHsWrap mkLHsVarTuplemkLHsTupleExprmkLHsPar mkLHsCmdWrap mkHsWrapPatCo mkHsWrapPat mkHsWrapCoR mkHsWrapComkHsWrap mkHsVarBindmkHsStringPrimLit mkHsString mkHsSigEnvmkHsQuasiQuotemkHsPar mkHsOpAppmkHsLamsmkHsLam mkHsIsString mkHsIntegralmkHsIfmkHsFractional mkHsDoAnnsmkHsDo mkHsDictLet mkHsCompAnnsmkHsComp mkHsCmdWrap mkHsCmdIfmkHsCharPrimLit mkHsCaseAlt mkHsAppsWithmkHsApps mkHsAppWith mkHsAppTypes mkHsAppTypemkHsAppmkGroupUsingStmtmkGroupByUsingStmt mkFunBind mkClassOpSigs mkChunkified mkBodyStmtmkBigLHsVarTupmkBigLHsVarPatTup mkBigLHsTupmkBigLHsPatTup missingTupArglStmtsImplicits lPatImplicitsisUnliftedHsBindisInfixFunBindisBangedHsBindhsValBindsImplicitshsTypeToHsSigWcTypehsTypeToHsSigTypehsTyClForeignBindershsPatSynSelectorshsLTyClDeclBindershsGroupBindershsForeignDeclsBindershsDataFamInstBindersgetPatSynBindsemptyTransStmtemptyRecStmtNameemptyRecStmtId emptyRecStmtcollectStmtsBinderscollectStmtBinderscollectPatsBinderscollectPatBinderscollectMethodBinderscollectLocalBinderscollectLStmtsBinderscollectLStmtBinderscollectHsValBinderscollectHsIdBinderscollectHsBindsBinderscollectHsBindListBinderscollectHsBindBinderschunkifyGHC.Parser.LexerToken GHC.Hs.Expr XXExprGhcTc ExpansionExprWrapExpr XBindStmtTc xbstc_failOpxbstc_boundResultTypexbstc_boundResultMult xbstc_bindOp XBindStmtRn xbsrn_failOp xbsrn_bindOp SyntaxExprTc syn_res_wrapsyn_expr syn_arg_wrapsNoSyntaxExprTc SyntaxExprRnNoSyntaxExprRn SyntaxExprGhc RecordUpdTc rupd_wrap rupd_out_tys rupd_in_tys rupd_cons RecStmtTc recS_ret_ty recS_rec_retsrecS_later_rets recS_bind_ty PostTcTable PostTcExprPendingTcSplicePendingRnSpliceHsWrap HsSplicedT HsExpansion HsExpandedGrhsAnnga_vbarga_sepEpAnnUnboundVar hsUnboundHolehsUnboundBackquotes EpAnnHsCasehsCaseAnnsRest hsCaseAnnOf hsCaseAnnCase DelayedSpliceCmdTopTcAnnsLetalLetalInAnnsIf aiThenSemiaiThenaiIf aiElseSemiaiElse AnnProjectionapOpenapClose AnnFieldLabelafDotAnnExplicitSumaesOpenaesClose aesBarsBefore aesBarsAfter tupArgPresent thTyBrackets thBracketsstripParensLHsExprstripParensHsExprppr_splice_decl ppr_splice ppr_quasippr_module_name_prefix ppr_lexprppr_lcmdppr_infix_exprppr_expr ppr_do_stmtsppr_cmdppr_appspprTransformStmt pprTransStmt pprStmtInCtxtpprStmtpprQualspprPendingSplicepprParendLExpr pprParendExpr pprMatchespprMatchInCtxtpprMatchpprLCmd pprHsBracketpprGRHSspprGRHSpprDopprDebugParendExprpprComp pprCmdArgpprCmdpprBypprBinds pprBindStmtpprArgpp_rhs pp_dotdotparenthesizeHsExpr noSyntaxExprnoExpr mkSyntaxExprmkRnSyntaxExprmatchGroupAritymatchContextErrStringmatchArrowContextErrStringisSingletonMatchGroup isQuietHsExpr isQuietHsCmdisEmptyMatchGroupisAtomicHsExpr hsLMatchPatshsExprNeedsParens GHC.Hs.DeclsXViaStrategyPs HsRuleAnn ra_tyanns ra_tmannsra_resttyFamInstDeclNametyFamInstDeclLName tyClDeclLNametcdNamestandaloneKindSigNameroleAnnotDeclNameresultVariableNamepprTyFamInstDeclpprTyClDeclFlavourpprHsFamInstLHSpprDataFamInstFlavourpartitionBindsAndSigsmapDerivStrategyinstDeclDataFamInstshsGroupTopLevelFixitySigs hsDeclHasCuskhsConDeclThetagetRecConArgs_maybe getConNamesfoldDerivStrategyflattenRuleDeclsfamilyDeclNamefamilyDeclLNamefamResultKindSignature emptyRnGroup emptyRdrGroup appendGroups GHC.Hs.Pat ListPatTc EpAnnSumPatsumPatVbarsBeforesumPatVbarsAfter sumPatParensConPatTccpt_wrapcpt_tvs cpt_dicts cpt_binds cpt_arg_tysCoPat co_pat_ty co_pat_inner co_cpt_wrap pprParendLPat pprConArgspatNeedsParensparenthesizePatmkPrefixConPatmkNilPat mkCharLitPatlooksLazyPatBind isSimplePatisIrrefutableHsPat isBangedLPathsRecUpdFieldRdrhsRecUpdFieldOcchsRecUpdFieldId hsRecFieldIdcollectEvVarsPatscollectEvVarsPat GHC.Hs.Binds NHsValBindsLR NValBindsAnnSigasRestasDcolonpragSrcBrackets pragBracketsppr_sig ppr_monobind pprVarSigpprTickspprTcSpecPragspprSpec pprMinimalSigpprLHsBindsForUser pprLHsBinds pprDeclListplusHsValBindsisEmptyValBindsisEmptyLHsBindsisEmptyIPBindsTcisEmptyIPBindsPReqEmptyLocalBindsemptyValBindsOutemptyValBindsInemptyLocalBinds emptyLHsBinds GHC.Hs.TypeOutputableBndrFlag EpAnnForallTyunambiguousFieldOccsplitLHsSigmaTyInvissplitLHsQualTysplitLHsPatSynTysplitLHsInstDeclTysplitLHsGadtTysplitLHsForAllTyInvis_KPsplitLHsForAllTyInvissplitHsFunTypesetHsTyVarBndrFlagselectorAmbiguousFieldOccrdrNameAmbiguousFieldOcc pprLHsContext pprHsTypepprHsOuterSigTyVarBndrspprHsOuterFamEqnTyVarBndrs pprHsForAllpprConDeclFieldspprAnonWildCardparenthesizeHsTypeparenthesizeHsContextmkHsWildCardBndrsmkHsQTvsmkHsPatSigTypemkHsOuterImplicitmkHsOuterExplicitmkHsOpTymkHsImplicitSigTypemkHsForAllVisTelemkHsForAllInvisTelemkHsExplicitSigType mkHsAppTys mkHsAppTy mkHsAppKindTy mkFieldOccmkEmptyWildCardBndrsmkAnonWildCardTymkAmbiguousFieldOcclhsTypeArgSrcSpanisUnrestricted ignoreParens hsWcScopedTvshsTypeNeedsParens hsTyVarNamehsTyVarBndrFlag hsTyKindSighsTyGetAppHead_maybehsTvbAllKinded hsSigWcType hsScopedTvshsOuterTyVarNameshsOuterExplicitBndrs hsLTyVarNames hsLTyVarNamehsLTyVarLocNameshsLTyVarLocNamehsExplicitLTyVarNameshsAllLTyVarNamesgetLHsInstDeclHeadgetLHsInstDeclClass_maybe getBangTypegetBangStrictnessfromMaybeContext emptyLHsQTvs dropWildCards arrowToHsTypeambiguousFieldOcc GHC.Hs.Lit OverLitTcol_type ol_rebindable pp_st_suffix pmPprHsLit overLitType convertLit pprSpliceDecl pprSplice pprPatBindpprLExpr pprFunBindpprExprLanguage.Haskell.Syntax.ExprUntypedSpliceFlavourUntypedTypeSpliceUntypedPatSpliceUntypedDeclSpliceUntypedExpSplice TransForm GroupFormThenFormThModFinalizersStmtLR trS_using trS_stmtstrS_rettrS_formtrS_fmaptrS_exttrS_by trS_bndrstrS_bind recS_stmts recS_ret_fn recS_rec_ids recS_mfix_fnrecS_later_idsrecS_ext recS_bind_fnXStmtLR TransStmtRecStmtParStmtLetStmtLastStmtBodyStmtApplicativeStmtBindStmtStmtSplicePointNameSpliceDecoration BareSplice DollarSplice RecUpdProjRecProjPendingTcSplice'PendingRnSplice' ParStmtBlock XParStmtBlock MatchGroupTc mg_res_ty mg_arg_tysMatchm_patsm_grhssm_extm_ctxtXMatchLStmtLRLStmtLMatch LHsTupArg LHsRecUpdProj LHsRecProj LHsCmdTopLHsCmdLGRHSHsTupArgXTupArgMissingPresent HsStmtContext TransStmtCtxtPatGuard ParStmtCtxt MonadCompMDoExprListComp GhciStmtCtxt ArrowExprDoExprHsSplicedThing HsSplicedTy HsSplicedExpr HsSplicedPat HsRecordBindsHsPragE HsPragSCCXHsPragEHsMatchContext mc_strictnessmc_fun mc_fixity ThPatSplice ThPatQuoteStmtCtxtRecUpd PatBindRhs PatBindGuards LambdaExprIfAltFunRhsCaseAltPatSynArrowMatchCtxt HsFieldLabelhflLabelhflExt XHsFieldLabelHsDoRnHsCmdTopXCmdTopHsCmdXCmdHsCmdParHsCmdLet HsCmdLamCaseHsCmdLamHsCmdIfHsCmdDo HsCmdCase HsCmdArrFormHsCmdApp HsCmdArrApp HsBracketRn HsBracketVarBrTypBrTExpBrPatBrExpBrDecBrLXBracketDecBrGHsArrowMatchContextProcExpr ArrowCaseAlt KappaExpr HsArrAppTypeHsFirstOrderAppHsHigherOrderApp GuardStmt GuardLStmtGhciStmt GhciLStmtGRHSXGRHSFieldLabelStrings FailOperatorExprStmt ExprLStmtCmdSyntaxTableCmdStmtCmdLStmt ArithSeqInfoFromTo FromThenToFromFromThenApplicativeArgStmCtxPassApplicativeArgxarg_app_arg_onexarg_app_arg_many stmt_context is_body_stmt final_expr bv_patternarg_expr app_stmtsapp_arg_patternXApplicativeArgApplicativeArgManyApplicativeArgOnequalifiedDoModuleName_maybeprependQualifiedpprStmtContextpprMatchContextNounpprMatchContextpprFieldLabelStringspprExternalSrcLocpprArrowMatchContextNounpprAStmtContextmatchSeparator isTypedSpliceisTypedBracket isPatSynCtxtisMonadStmtContextisMonadCompContext isInfixMatchisComprehensionContextLanguage.Haskell.Syntax.Decls WarnDecls wd_warningswd_srcwd_extWarnings XWarnDeclsWarnDeclWarning XWarnDecl TyFamInstEqn TyFamInstDecltfid_xtntfid_eqnXTyFamInstDeclTyFamDefltDecl TyClGroup group_tyclds group_roles group_kisigs group_instds group_ext XTyClGroupTyClDecl tcdTyVarstcdSigstcdSExttcdRhstcdMethstcdLName tcdFixitytcdFamtcdFExttcdFDstcdDocs tcdDataDefntcdDExttcdCtxttcdCExttcdATs tcdATDefs XTyClDeclSynDeclFamDecl ClassDeclDataDeclStandaloneKindSigXStandaloneKindSig SpliceDecl XSpliceDecl RuleDeclsrds_src rds_rulesrds_extHsRules XRuleDeclsRuleDeclrd_tyvsrd_tmvsrd_rhsrd_namerd_lhsrd_extrd_actHsRule XRuleDeclRuleBndr XRuleBndr RuleBndrSig RoleAnnotDeclXRoleAnnotDecl NewOrDataDataTypeNewType LWarnDecls LWarnDecl LTyFamInstEqnLTyFamInstDeclLTyFamDefltDecl LTyClDeclLStandaloneKindSig LSpliceDecl LRuleDecls LRuleDecl LRuleBndrLRoleAnnotDecl LInstDeclLInjectivityAnn LHsFunDepLHsDerivingClauseLHsDecl LForeignDeclLFamilyResultSig LFamilyDeclLDocDeclLDerivStrategy LDerivDeclLDerivClauseTys LDefaultDeclLDataFamInstDeclLConDecl LClsInstDeclLAnnDeclInstDecl tfid_insttfid_ext dfid_instdfid_extcid_inst cid_d_ext XInstDecl TyFamInstDClsInstD DataFamInstDInjectivityAnnXInjectivityAnnHsTyPatsHsRuleRnHsGroup hs_warndshs_valds hs_tyclds hs_splcds hs_ruledshs_fordshs_fixdshs_exths_docs hs_derivdshs_defdshs_anndsXHsGroupHsDerivingClausederiv_clause_tysderiv_clause_strategyderiv_clause_extXHsDerivingClause HsDerivingHsDeclXHsDeclWarningDValDTyClDSpliceDSigDRuleD RoleAnnotDKindSigDInstDForDDocDDerivDAnnDDefD HsDataDefn dd_kindSigdd_ext dd_derivsdd_ctxtdd_consdd_cTypedd_ND XHsDataDefnHsConDeclH98DetailsHsConDeclGADTDetails PrefixConGADT RecConGADTFunDepXFunDep ForeignImportCImport ForeignExportCExport ForeignDecl fd_sig_tyfd_namefd_i_extfd_fifd_fefd_e_ext XForeignDeclFamilyResultSigXFamilyResultSigTyVarSigKindSigNoSig FamilyInfoOpenTypeFamilyClosedTypeFamily DataFamily FamilyDeclfdTyVars fdTopLevel fdResultSigfdLNamefdInjectivityAnnfdInfofdFixityfdExt XFamilyDeclFamEqn feqn_tyconfeqn_rhs feqn_pats feqn_fixityfeqn_ext feqn_bndrsXFamEqnDocDeclDocGroupDocCommentPrevDocCommentNamedDocCommentNext DerivStrategy ViaStrategy StockStrategyAnyclassStrategyNewtypeStrategy DerivDecl deriv_typederiv_strategyderiv_overlap_mode deriv_ext XDerivDeclDerivClauseTysXDerivClauseTysDctMulti DctSingle DefaultDecl XDefaultDeclDataFamInstDecldfid_eqn DataDeclRntcdFVs tcdDataCuskConDecl con_res_ty con_namescon_name con_mb_cxt con_g_ext con_g_args con_forallcon_ext con_ex_tvscon_doc con_bndrscon_argsXConDecl ConDeclGADT ConDeclH98 ClsInstDeclcid_tyfam_instscid_sigs cid_poly_tycid_overlap_modecid_extcid_datafam_insts cid_binds XClsInstDecl CImportSpecCWrapperCLabel CFunction AnnProvenanceValueAnnProvenanceModuleAnnProvenanceTypeAnnProvenanceAnnDecl HsAnnotationXAnnDecltyClGroupTyClDeclstyClGroupRoleDeclstyClGroupKindSigstyClGroupInstDeclstyClDeclTyVarspprFullRuleName pprFlavournewOrDataToFlavourisTypeFamilyDecl isSynDeclisOpenTypeFamilyInfo isFamilyDeclisDataFamilyDecl isDataDeclisClosedTypeFamilyInfo isClassDeclhsGroupInstDecls docDeclDocderivStrategyNamecountTyClDeclscollectRuleBndrSigTysannProvenanceName_maybeLanguage.Haskell.Syntax.Binds TcSpecPragsIsDefaultMethod SpecPrags TcSpecPragSpecPragSigXSigTypeSigSpecSig SpecInstSig SCCFunSig PatSynSig MinimalSig InlineSigIdSigFixSig ClassOpSigCompleteMatchSigRecordPatSynFieldrecordPatSynPatVarrecordPatSynField PatSynBindpsb_idpsb_extpsb_dirpsb_defpsb_args XPatSynBindPSB LTcSpecPragLSigLIPBindLHsLocalBindsLR LHsLocalBinds LHsBindsLRLHsBinds LHsBindLRLHsBind LFixitySigIPBindXIPBind HsValBindsLRValBinds XValBindsLR HsValBinds HsPatSynDirUnidirectionalExplicitBidirectionalImplicitBidirectionalHsPatSynDetailsHsLocalBindsLRXHsLocalBindsLR HsIPBindsEmptyLocalBinds HsLocalBinds XHsIPBindsIPBindsHsBindLRvar_rhsvar_idvar_ext pat_tickspat_rhspat_lhspat_extfun_tick fun_matchesfun_idfun_extabs_tvsabs_sigabs_ext abs_exports abs_ev_vars abs_ev_binds abs_binds XHsBindsLRVarBindPatBindAbsBindsFunBindHsBind FixitySig XFixitySigABExportabe_wrap abe_pragsabe_polyabe_monoabe_extABE XABExport noSpecPrags isTypeLSig isSpecLSigisSpecInstLSig isSCCFunSig isPragLSig isMinimalLSig isInlineLSig isFixityLSigisDefaultMethodisCompleteMatchSighsSigDoc hasSpecPragspprLPatLanguage.Haskell.Syntax.PatLHsRecUpdField LHsRecField' LHsRecField HsRecUpdField HsRecFieldsrec_flds rec_dotdot HsRecField'hsRecPun hsRecFieldLbl hsRecFieldArg HsRecField hsRecFieldAnnHsConPatDetailsConLikePhsRecFieldsArgs hsRecFields hsRecFieldSel hsConPatArgsLanguage.Haskell.Syntax.Type LHsWcType LHsTypeArgLHsType LHsTyVarBndr LHsSigWcType LHsSigType LHsQTyVarshsq_ext hsq_explicitHsQTvs XLHsQTyVarsLHsKind LHsContext LFieldOcc LConDeclField LBangTypeHsWildCardBndrshswc_ext hswc_bodyHsWCXHsWildCardBndrsHsType hst_xqual hst_xforallhst_telehst_ctxthst_bodyXHsType HsWildCardTyHsTyVar HsTupleTyHsSumTyHsStarTy HsSpliceTyHsRecTyHsQualTyHsParTyHsOpTyHsListTy HsKindSig HsIParamTyHsFunTy HsForAllTyHsExplicitTupleTyHsExplicitListTyHsDocTyHsBangTyHsAppTyHsTyLit HsAppKindTy HsTyVarBndr XTyVarBndr KindedTyVar UserTyVarHsStrTyHsCharTyHsNumTy HsTupleSortHsBoxedOrConstraintTupleHsUnboxedTuple HsSigTypesig_extsig_body sig_bndrsHsSig XHsSigTypeHsScaled HsPatSigTypehsps_ext hsps_bodyHsPS XHsPatSigTypeHsPSRn hsps_nwcs hsps_imp_tvsHsOuterTyVarBndrs hso_ximplicit hso_xexplicit hso_bndrsXHsOuterTyVarBndrsHsOuterExplicitHsOuterImplicitHsOuterSigTyVarBndrsHsOuterFamEqnTyVarBndrsHsKindHsIPNameHsForAllTelescopehsf_xvis hsf_xinvis hsf_vis_bndrshsf_invis_bndrsXHsForAllTelescope HsForAllInvis HsForAllVisHsCoreTy HsContext HsConDetailsRecConInfixCon PrefixConHsArrowHsUnrestrictedArrowHsExplicitMult HsLinearArrowHsArgHsValArgHsArgPar HsTypeArgFieldOccrdrNameFieldOcc extFieldOcc XFieldOcc ConDeclField cd_fld_type cd_fld_names cd_fld_ext cd_fld_doc XConDeclFieldBangTypeAmbiguousFieldOccXAmbiguousFieldOcc Ambiguous UnambiguousnumVisibleArgs noTypeArgsmapHsOuterImplicitisHsKindedTyVarhsUnrestricted hsScaledThing hsQTvExplicit hsPatSigTypehsMulthsLinear hsIPNameFSPat pat_con_extpat_conpat_argsXPatWildPatViewPatVarPatTuplePatSumPat SplicePatSigPatParPat NPlusKPatNPatLitPatListPatLazyPatConPatAsPatBangPatLPatLanguage.Haskell.Syntax.Lit OverLitVal HsIsString HsFractional HsIntegral HsOverLit ol_witnessol_valol_extXOverLitOverLitHsLitXLit HsWordPrim HsWord64Prim HsStringPrimHsStringHsRat HsInteger HsIntPrim HsInt64PrimHsInt HsFloatPrim HsDoublePrimHsChar HsCharPrimnegateOverLitValhsOverLitNeedsParenshsLitNeedsParens GHC.Hs.ImpExp LImportDeclLIEWrappedNameLIEImportDeclQualifiedStyle QualifiedPre NotQualified QualifiedPost ImportDeclideclSourceSrc ideclSource ideclSafeideclQualified ideclPkgQual ideclName ideclImplicit ideclHidingideclExtideclAs XImportDecl IEWrappedNameIETypeIEName IEPattern IEWildcard NoIEWildcardIEXIEIEVar IEThingWith IEThingAll IEThingAbsIEModuleContentsIEGroupIEDoc IEDocNamedEpAnnImportDeclimportDeclAnnSafeimportDeclAnnQualifiedimportDeclAnnPragmaimportDeclAnnPackageimportDeclAnnImportimportDeclAnnAssimpleImportDeclreplaceWrappedNamereplaceLWrappedName pprImpExplieWrappedNameisImportDeclQualifiedimportDeclQualifiedStyle ieWrappedNameieWrappedLNameieNamesieNameieLWrappedNameGHC.Hs.ExtensionPass TypecheckedParsedRenamedOutputableBndrId NoGhcTcPass IsSrcSpanAnnIsPassghcPassIdGhcPGhcTcGhcRnGhcPsGhcPasspprIfTcpprIfRnpprIfPsGHC.Core.InstEnvClsInstpprInstanceHdr pprInstanceinstanceDFunIdGHC.ByteCode.Types ModBreaksmodBreaks_varsmodBreaks_locsmodBreaks_flagsmodBreaks_decls modBreaks_ccsmodBreaks_breakInfo BreakIndexGHC.Runtime.Eval.Types SingleStepRunToCompletionRunAndLogStepsResume resumeStmt resumeSpanresumeHistoryIx resumeHistoryresumeFinalIds resumeDecl resumeContext resumeCCSresumeBreakInforesumeBindings resumeApStackHistoryhistoryBreakInfohistoryEnclosingDecls ExecResult execResultexecAllocation breakNames breakInfo ExecBreak ExecComplete ExecOptionsexecWrapexecSourceFileexecSingleStepexecLineNumber BreakInfobreakInfo_numberbreakInfo_module GHC.Types.IdrecordSelectorTyConisRecordSelector isPrimOpId isImplicitId isFCallId isDeadEndId isDeadBinderisDataConWorkIdisClassOpId_maybeidType idDataCon SyntaxExpr MatchGroup mg_originmg_extmg_altsMG XMatchGroupLHsExprHsSpliceXSpliceHsUntypedSplice HsTypedSplice HsQuasiQuote HsSplicedHsExpr rupd_fldsrupd_ext rupd_expr rcon_fldsrcon_extrcon_con proj_fldsproj_extgf_fieldgf_extgf_exprXExprSectionRSectionL RecordUpd RecordConOpAppNegAppHsVar HsUnboundVarHsTickHsTcBracketOutHsStatic HsSpliceEHsRnBracketOutHsRecFld HsProjectionHsProcHsPar HsOverLabel HsMultiIfHsLet HsLamCaseHsLamHsIfHsIPVar HsGetFieldHsDo HsConLikeOutHsCase HsBinTick HsAppTypeHsApp ExprWithTySig ExplicitTuple ExplicitSum ExplicitListArithSeqGRHSsgrhssLocalBinds grhssGRHSsgrhssExtXGRHSs!Language.Haskell.Syntax.Extension XXWarnDecls XXWarnDecl XXValBindsLRXXType XXTyVarBndrXXTyFamInstDecl XXTyClGroup XXTyClDeclXXTupArgXXStmtLRXXStandaloneKindSig XXSpliceDeclXXSpliceXXSig XXRuleDecls XXRuleDecl XXRuleBndrXXRoleAnnotDeclXXPragE XXPatSynBindXXPatXXParStmtBlock XXOverLit XXMatchGroupXXMatchXXLit XXLHsQTyVars XXInstDeclXXInjectivityAnn XXImportDeclXXIPBindXXIEXXHsWildCardBndrs XXHsSigTypeXXHsPatSigTypeXXHsOuterTyVarBndrsXXHsLocalBindsLR XXHsIPBinds XXHsGroupXXHsForAllTelescopeXXHsFieldLabelXXHsDerivingClauseXXHsDecl XXHsDataDefn XXHsBindsLRXXGRHSsXXGRHSXXFunDep XXForeignDecl XXFixitySig XXFieldOccXXFamilyResultSig XXFamilyDeclXXFamEqnXXExpr XXDerivDeclXXDerivClauseTys XXDefaultDeclXXConDeclField XXConDeclXXCmdTopXXCmd XXClsInstDecl XXBracketXXApplicativeArg XXAnnDeclXXAmbiguousFieldOcc XXABExportXWildPat XWildCardTy XWarnings XWarningDXWarningXViewPat XViaStrategyXVarPatXVarBrXVarBindXVarXValD XValBinds XUserTyVarXUntypedSplice XUnboundVar XUnambiguous XTypedSpliceXTypeSigXTypBr XTyVarSigXTyVarXTyLit XTyFamInstDXTyClDXTupleTy XTuplePat XTransStmtXTick XTcBracketOutXTExpBrXSynDeclXSumTyXSumPatXStockStrategyXStaticXStarTyXSpliced XSpliceTy XSplicePatXSpliceEXSpliceDXSpecSig XSpecInstSigXSigPatXSigD XSectionR XSectionL XSCCFunSigXSCCXRuleD XRuleBndrSig XRoleAnnotD XRnBracketOut XRecordUpd XRecordConXRecTyXRecStmtXRecFldXRec XQuasiQuoteXQualTy XProjectionXProcXPresentXPragE XPatSynSigXPatBrXPatBindXParTyXParStmtXParPatXParXPSB XOverLitE XOverLabelXOpTyXOpAppXNoSigXNewtypeStrategyXNegApp XNPlusKPatXNPatXMultiIfXMissing XMinimalSigXMGXLitPatXLitEXListTyXListPatXLetStmtXLetXLazyPat XLastStmtXLamCaseXLam XKindedTyVar XKindSigDXKindSigXInstD XInlineSigXIfXIdSig XIParamTyXIPVarXIPBindsXIEVar XIEThingWith XIEThingAll XIEThingAbsXIEModuleContentsXIEGroup XIEDocNamedXIEDoc XHsWordPrim XHsWord64PrimXHsWC XHsValBinds XHsStringPrim XHsStringXHsSigXHsRule XHsRecFieldXHsRatXHsQTvsXHsPSXHsOuterImplicitXHsOuterExplicit XHsInteger XHsIntPrim XHsInt64PrimXHsInt XHsForAllVisXHsForAllInvis XHsFloatPrim XHsDoublePrim XHsCharPrimXHsChar XHsAnnotation XGetFieldXFunTyXFunBindXForeignImportXForeignExportXForD XForAllTyXFixSigXFamDeclXExprWithTySigXExplicitTupleTyXExplicitTuple XExplicitSumXExplicitListTy XExplicitListXExpBrXEmptyLocalBindsXDocTyXDocDXDoXDerivDXDefDXDecBrLXDecBrG XDctSingle XDctMulti XDataFamInstD XDataDeclXConPat XConLikeOut XConDeclH98 XConDeclGADTXCompleteMatchSigXCoPatXCmdWrapXCmdParXCmdLet XCmdLamCaseXCmdLamXCmdIfXCmdDoXCmdCase XCmdArrForm XCmdArrAppXCmdApp XClsInstD XClassOpSig XClassDeclXCaseXCTyFamInstDecl XCTyClGroup XCRuleDecls XCRuleBndrXCRoleAnnotDeclXCMatch XCKindSigXCInjectivityAnn XCImportDeclXCIPBind XCHsGroupXCHsFieldLabelXCHsDerivingClause XCHsDataDefnXCGRHSsXCGRHSXCFunDep XCFieldOcc XCFamilyDeclXCFamEqn XCDerivDecl XCDefaultDecl XCClsInstDecl XBodyStmt XBindStmtXBinTickXBangTyXBangPatXAsPat XArithSeqXApplicativeStmtXApplicativeArgOneXApplicativeArgMany XAppTypeEXAppTy XAppKindTyXAppXAnyClassStrategyXAnnD XAmbiguous XAbsBindsXABEWrapXRecwrapXRecUnXRecunXRecNoGhcTc NoExtFieldNoExtConMapXRecmapXRecLIdPIdPAnno noExtFieldnoExtConGHC.Driver.ErrorswarningsToMessagesprintOrThrowWarningsprintBagOfErrorsisWarnMsgFatalhandleFlagWarningsGHC.Utils.ErrorprettyPrintGhcErrorsGHC.Utils.LoggerLogger getLogger pushLogHook popLogHookGHC.Driver.SessionGhcModeMkDependOneShot CompManagerGhcLinkNoLink LinkStaticLib LinkInMemory LinkBinary LinkDynLibgoptGHC.Types.SourceErrorhandleSourceErrorGHC.Types.ErrorSeverity SevWarning SevOutputSevInteractiveSevInfoSevFatalSevDumpSevErrorGHC.Core.DataConStrictnessMark MarkedStrictNotMarkedStrictSrcUnpackedness SrcUnpack NoSrcUnpack SrcNoUnpack SrcStrictness SrcStrict NoSrcStrictSrcLazy HsSrcBang HsImplBangHsUnpackHsLazyHsStrictisVanillaDataConisMarkedStrictdataConWrapperTypedataConSrcBangsdataConIsInfixGHC.Core.FamInstEnvFamInstGHC.Core.TyCo.Ppr pprTypeApppprThetaArrowTy pprParendType pprForAll GHC.Core.TypesplitForAllTyCoVars funResultTyGHC.Builtin.Types.Prim alphaTyVarsGHC.Core.TyCon tyConDataConstyConClass_maybesynTyConRhs_maybesynTyConDefn_maybeisTypeSynonymTyConisTypeFamilyTyCon isPrimTyConisOpenTypeFamilyTyConisOpenFamilyTyCon isNewTyCon isFamilyTyCon isClassTyConGHC.Core.ClassClass pprFundeps classTvsFds classSCTheta classMethodsclassATs GHC.Hs.Doc LHsDocString HsDocStringExtractedTHDocsethd_mod_headerethd_inst_docsethd_decl_docs ethd_arg_docs DeclDocMap ArgDocMap unpackHDS ppr_mbDocmkHsDocStringUtf8ByteString mkHsDocStringisEmptyDocStringhsDocStringToByteStringemptyDeclDocMapemptyArgDocMap concatDocs appendDocsGHC.Parser.Annotation TrailingAnn AddVbarAnn AddSemiAnn AddRarrowAnnU AddRarrowAnn AddCommaAnn AddLollyAnnU SrcSpanAnnP SrcSpanAnnN SrcSpanAnnL SrcSpanAnnC SrcSpanAnnA SrcSpanAnn'locA SrcSpanAnnannSrcAnn ParenTypeAnnParensSquare AnnParens AnnParensHashNoEpAnnsNameAnn nann_trailing nann_quoted nann_quote nann_open nann_name nann_commas nann_closenann_adornmentNameAnnTrailing NameAnnRArrow NameAnnQuote NameAnnOnly NameAnnCommas NameAdornment NameSquareNameParensHashNameBackquotes NameParensLocatedPLocatedNLocatedLLocatedC LocatedAnLocatedA LEpaCommentIsUnicodeSyntax NormalSyntax UnicodeSyntaxHasENoE EpaLocationEpaDeltaEpaSpan EpaCommentTokEpaLineComment EpaEofComment EpaDocSection EpaDocOptionsEpaDocCommentPrevEpaDocCommentNextEpaBlockCommentEpaDocCommentNamed EpaCommentac_tok ac_prior_tok EpAnnComments priorCommentsfollowingComments EpaCommentsEpaCommentsBalancedEpAnnCOEpAnnentrycommentsanns EpAnnNotUsedDeltaPos deltaLine deltaColumn DifferentLineSameLine AnnSortKey NoAnnSortKey AnnPragmaapr_restapr_open apr_closeAnnParenap_openap_close ap_adornment AnnListItem lann_trailingAnnList al_trailingal_restal_openal_close al_anchor AnnKeywordIdAnnrarrowtailUAnnlarrowtailUAnnVia AnnValStrAnnUnit AnnThTyQuoteAnnSimpleQuote AnnSignatureAnnSafeAnnRarrowtailU AnnRarrowU AnnQualified AnnPercentOne AnnPercentAnnPackageNameAnnOpenS AnnOpenPH AnnOpenEQUAnnOpenC AnnOpenBUAnnNameAnnMdo AnnLollyUAnnLarrowtailU AnnLarrowU AnnHiding AnnForallUAnnDollarDollar AnnDollar AnnDcolonU AnnDarrowU AnnCommaTuple AnnCloseS AnnCloseQU AnnClosePH AnnCloseC AnnCloseBUAnnClassAnnAs AnnAnyclassAnnInfix AnnLarrow AnnPatternAnnFunIdAnnRole AnnExport AnnImport AnnForeign AnnFamily AnnNewtypeAnnStock AnnDeriving AnnDefault AnnInstanceAnnData AnnForall AnnDarrow AnnModuleAnnBangAnnRecAnnUsingAnnGroupAnnByAnnColonAnnMinus AnnStatic AnnClosePAnnOpenPAnnProcAnnDot AnnCloseQ AnnOpenEQAnnOpenEAnnAt AnnDcolon AnnDotdotAnnInAnnLetAnnLamAnnElseAnnThenAnnIfAnnDoAnnOfAnnCase AnnCloseBAnnOpenB AnnRarrowtail AnnLarrowtail Annrarrowtail AnnlarrowtailAnnSemi AnnRarrowAnnWhereAnnEqualAnnVbarAnnTilde AnnBackquoteAnnTypeAnnCommaAnnCloseAnnValAnnOpen AnnHeader AnnContextac_open ac_darrowac_closeAnchorOperation MovedAnchorUnchangedAnchorAnchor anchor_opanchorAddEpAnn widenSpanwidenLocatedAn widenAnchorR widenAnchor unicodeAnn transferAnnsA spanAsAnchor sortLocatedAsetPriorCommentssetFollowingCommentssetCommentsSrcAnnsetCommentsEpAnnremoveCommentsA realSrcSpanrealSpanAsAnchorreLocNreLocLreLocCreLocAreLocreAnnLreAnnCreAnnplaceholderRealSpan parenTypeKws noSrcSpanAnoLocA noComments noAnnSrcSpannoAnnna2lan2lmapLocAla2rla2nala2lal2nl2l getLocAnngetLocAgetFollowingComments getDeltaLineextraToAnnListepaLocationRealSrcSpanepaLocationFromSrcAnn epAnnComments epAnnAnnsL epAnnAnns emptyCommentsdeltaPos commentsOnlyAcommentcombineSrcSpansA combineLocsAannParen2AddEpAnnaddTrailingCommaToNaddTrailingAnnToLaddTrailingAnnToAaddCommentsToSrcAnnaddCommentsToEpAnn addCLocAAaddCLocAaddAnnsAaddAnnsGHC.Types.Name.ReaderRdrNameExactQualUnqual rdrNameOcc mkRdrUnqual mkRdrQualGHC.Types.Name nameSrcSpan nameModulemkInternalNameisExternalNameGHC.Types.Name.Occurrence TidyOccEnvOccSetOccEnv NameSpacevarName unitOccSet unitOccEnv unionOccSetsunionManyOccSetstvName tidyOccNametcName tcClsNamestartsWithUnderscore srcDataNamesetOccNameSpacepromoteOccName pprOccName pprOccEnvpprNonVarNameSpacepprNameSpaceBrief pprNameSpace plusOccEnv_C plusOccEnv parenSymOcc occEnvEltsnameSpacesRelated mkWorkerOccmkVarOcc mkTyVarOccFS mkTyVarOcc mkTyConRepOcc mkTcOccFSmkTcOcc mkTag2ConOccmkSuperDictSelOccmkSuperDictAuxOcc mkSpecOcc mkRepEqOccmkOccSet mkOccNameFS mkOccName mkOccEnv_CmkOccEnv mkNewTyCoOcc mkMethodOcc mkMaxTagOcc mkMatcherOcc mkLocalOcc mkInstTyTcOcc mkInstTyCoOccmkIPOccmkGenRmkGen1RmkForeignExportOcc mkEqPredCoOcc mkDictOccmkDefaultMethodOcc mkDataTOcc mkDataOccFS mkDataOccmkDataConWrapperOccmkDataConWorkerOcc mkDataCOcc mkDFunOcc mkCon2TagOcc mkClsOccFSmkClsOccmkClassOpAuxOccmkClassDataConOcc mkBuilderOcc minusOccSet mapOccEnv lookupOccEnvisVarOccisVarNameSpaceisValOccisValNameSpaceisTypeableBindOccisTvOcc isTvNameSpaceisTcOccisTcClsNameSpaceisSymOcc isEmptyOccSetisDerivedOccNameisDefaultMethodOcc isDataSymOcc isDataOccisDataConNameSpaceintersectOccSetinitTidyOccEnv foldOccEnv filterOccSet filterOccEnvextendOccSetList extendOccSetextendOccEnv_CextendOccEnv_AccextendOccEnvList extendOccEnvemptyTidyOccEnv emptyOccSet emptyOccEnv elemOccSet elemOccEnv demoteOccNamedelTidyOccEnvListdelListFromOccEnv delFromOccEnvdataNameclsNameavoidClashesOccEnv alterOccEnv GHC.Types.Var isLocalId isGlobalId isExportedIdDataCon dataConTyCondataConFieldLabelsGHC.Core.TyCo.RepType ThetaTypePredTypeMultKindGHC.Types.TyThingTyThingAnIdATyConACoAxiomAConLikeTyCon tyConTyVars tyConArity tyConKind isFunTyConGHC.Types.TargetTargetId TargetFile TargetModuleTargettargetIdtargetContentstargetAllowObjCodeGHC.Driver.Flags GeneralFlagOpt_WriteInterface Opt_WriteHieOpt_WorkerWrapperOpt_WholeArchiveHsLibsOpt_WeightlessBlocklayoutOpt_WarnIsErrorOpt_VersionMacrosOpt_ValidateHieOpt_UnclutterValidHoleFitsOpt_UnboxStrictFieldsOpt_UnboxSmallStrictFields Opt_Ticky_LNEOpt_Ticky_Dyn_ThunkOpt_Ticky_Allocd Opt_TickyOpt_SuppressVarKindsOpt_SuppressUniquesOpt_SuppressUnfoldingsOpt_SuppressTypeSignaturesOpt_SuppressTypeApplicationsOpt_SuppressTimestampsOpt_SuppressTicksOpt_SuppressStgExtsOpt_SuppressModulePrefixesOpt_SuppressIdInfoOpt_SuppressCoercionsOpt_Strictness Opt_StgStatsOpt_StgLiftLams Opt_StgCSE Opt_StaticArgumentTransformationOpt_SplitSectionsOpt_SpecialiseAggressivelyOpt_SpecialiseOpt_SpecConstrKeenOpt_SpecConstrOpt_SortValidHoleFitsOpt_SortBySubsumHoleFitsOpt_SortBySizeHoleFitsOpt_SolveConstantDictsOpt_SingleLibFolderOpt_SimplPreInliningOpt_ShowWarnGroupsOpt_ShowValidHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowMatchesOfHoleFitsOpt_ShowLoadedModulesOpt_ShowHoleConstraintsOpt_ShowDocsOfHoleFitsOpt_SharedImplibOpt_RelativeDynlibPathsOpt_RegsIterative Opt_RegsGraph Opt_RPathOpt_ProfCountEntriesOpt_PrintUnicodeSyntaxOpt_PrintTypecheckerElaborationOpt_PrintPotentialInstancesOpt_PrintExplicitRuntimeRepsOpt_PrintExplicitKindsOpt_PrintExplicitForallsOpt_PrintExplicitCoercionsOpt_PrintExpandedSynonymsOpt_PrintEvldWithShowOpt_PrintEqualityRelationsOpt_PrintBindResultOpt_PrintBindContentsOpt_PrintAxiomIncompsOpt_PprShowTicksOpt_PprCaseAsLetOpt_PpOpt_PluginTrustworthyOpt_PedanticBottomsOpt_PackageTrustOpt_PIEOpt_PICExecutableOpt_PICOpt_OptimalApplicativeDoOpt_OmitYieldsOpt_OmitInterfacePragmasOpt_NumConstantFoldingOpt_NoTypeableBindsOpt_NoLlvmManglerOpt_NoIt Opt_NoHsMainOpt_LoopificationOpt_LocalGhciHistory Opt_LlvmTBAAOpt_LlvmFillUndefWithGarbage Opt_LinkRtsOpt_LiberateCaseOpt_LateSpecialiseOpt_LateDmdAnalOpt_KillOneShotOpt_KillAbsenceOpt_KeepTmpFilesOpt_KeepSFilesOpt_KeepRawTokenStreamOpt_KeepOFilesOpt_KeepLlvmFilesOpt_KeepHscppFilesOpt_KeepHiFilesOpt_KeepHiDiffsOpt_KeepHcFiles Opt_KeepGoing Opt_KeepCAFsOpt_IrrefutableTuplesOpt_InlineGenericsAggressivelyOpt_InlineGenericsOpt_InfoTableMapOpt_ImplicitImportQualifiedOpt_IgnoreOptimChangesOpt_IgnoreInterfacePragmasOpt_IgnoreHpcChangesOpt_IgnoreDotGhciOpt_IgnoreAssertsOpt_HpcOpt_HideSourcePathsOpt_HideAllPluginPackagesOpt_HideAllPackagesOpt_HexWordLiteralsOpt_HelpfulErrorsOpt_HaddockOptions Opt_HaddockOpt_GhciSandboxOpt_GhciLeakCheckOpt_GhciHistoryOpt_GenManifestOpt_G_NoStateHackOpt_G_NoOptCoercionOpt_FunToThunkOpt_FullLazinessOpt_ForceRecomp Opt_FloatIn Opt_FastLlvmOpt_FamAppCacheOpt_ExternalInterpreterOpt_ExternalDynamicRefsOpt_ExposeInternalSymbolsOpt_ExposeAllUnfoldingsOpt_ExitificationOpt_ExcessPrecisionOpt_ErrorSpansOpt_EnableThSpliceWarningsOpt_EnableRewriteRulesOpt_EmbedManifestOpt_EagerBlackHolingOpt_DumpToFileOpt_DoStgLintingOpt_DoLinearCoreLintingOpt_DoLambdaEtaExpansionOpt_DoEtaReductionOpt_DoCoreLintingOpt_DoCmmLintingOpt_DoBoundsCheckingOpt_DoAsmLintingOpt_DoAnnotationLintingOpt_DmdTxDictSelOpt_DistrustAllPackagesOpt_DistinctConstructorTablesOpt_DictsStrictOpt_DictsCheapOpt_DiagnosticsShowCaretOpt_DeferTypedHolesOpt_DeferTypeErrorsOpt_DeferOutOfScopeVariablesOpt_DeferDiagnosticsOpt_D_faststring_statsOpt_D_dump_minimal_importsOpt_CrossModuleSpecialise Opt_CprAnalOpt_CompactUnwindOpt_CmmStaticPred Opt_CmmSinkOpt_CmmElimCommonBlocksOpt_CfgBlocklayoutOpt_CatchBottoms Opt_CaseMergeOpt_CaseFolding Opt_CallArityOpt_CSE Opt_ByteCodeOpt_BuildingCabalPackageOpt_BuildDynamicTooOpt_BreakOnExceptionOpt_BreakOnErrorOpt_AutoSccsOnIndividualCafsOpt_AutoLinkPackagesOpt_AsmShortcuttingOpt_AbstractRefHoleFitsOpt_AlignmentSanitisationGHC.Driver.PhasesPhaseGHC.Types.Basic SuccessFlagFailed SucceededSpliceExplicitFlagExplicitSpliceImplicitSplice succeededfailedGHC.Types.Fixity LexicalFixityInfixPrefixFixityDirectionInfixRInfixLInfixNFixity negateFixity maxPrecedence defaultFixity compareFixityTyVarIdGHC.Types.SafeHaskellSafeHaskellMode Sf_UnsafeSf_TrustworthySf_SafeInferredSf_Safe Sf_IgnoreSf_NoneGHC.Types.SourceText SourceText NoSourceTextGHC.Unit.Module.Location ModLocation ml_obj_file ml_hs_file ml_hie_file ml_hi_fileGHC.Unit.TypesmkModuleGHC.Unit.Module.NamemoduleNameString mkModuleName NamedThinggetName getOccNameNameGHC.Types.SrcLocSrcSpan RealSrcSpan UnhelpfulSpanSrcLoc RealSrcLoc UnhelpfulLoc srcSpanFile RealLocatedLocated GenLocatedL unRealSrcSpanunLocsrcSpanStartLinesrcSpanStartCol srcSpanStartsrcSpanEndLine srcSpanEndCol srcSpanEnd srcLocSpan srcLocLine srcLocFile srcLocColspansrightmost_smallest noSrcSpannoSrcLocnoLoc mkSrcSpanmkSrcLocmkGeneralLocatedleftmost_smallestleftmost_largest isSubspanOf isGoodSrcSpangetRealSrcSpangetLoc eqLocated combineLocs cmpLocatedaddCLocGHC.Data.FastString.Env FastStringEnvmkFsEnv lookupFsEnv extendFsEnv emptyFsEnvGHC.Types.Unique.SupplytakeUniqFromSupplyGHC.Utils.Panic GhcException UsageErrorSorry ProgramErrorPprSorryPprProgramErrorPprPanicPanicInstallationErrorSignal CmdLineErrorwithSignalHandlersshowGhcExceptionGHC.Utils.OutputableQueryQualifyPackageQueryQualifyNameQueryQualifyModule QualifyName NameUnqualNameQualNameNotInScope1NameNotInScope2PrintUnqualifiedqueryQualifyPackagequeryQualifyName QueryQualifyqueryQualifyModulePDoc OutputablePpdocOutputableBndr pprPrefixOcc pprInfixOccbndrIsJoin_maybepprBndr Outputableppr LabelStyleAsmStyleCStyleDepthPartWay AllTheWay DefaultDepth BindingSiteLetBind LambdaBindCaseBind CasePatBindztextword withUserStyle withPprStyle withErrStyle whenPprDebugvcatvbar userStyleupdSDocContext unicodeSyntax underscorespeakNthspeakNOfspeakNspaceshowSDocUnsafeshowSDocOneLine showPprUnsafesetStyleColouredsepsemisdocWithContext sdocOptionrunSDocrparenrenderWithContextreallyAlwaysQualifyNamesreallyAlwaysQualifyrbrackrbracerationalquotesquotedListWithOrquotedListWithNorquote queryQual qualPackagequalName qualModule punctuateptext printSDocLn printSDocprimWordSuffixprimWord8SuffixprimWord64SuffixprimWord32SuffixprimWord16Suffix primIntSuffixprimInt8SuffixprimInt64SuffixprimInt32SuffixprimInt16SuffixprimFloatSuffixprimDoubleSuffixprimCharSuffix pprWithCommas pprWithBars pprSetDepth pprQuotedList pprPrimWord8 pprPrimWord64 pprPrimWord32 pprPrimWord16 pprPrimWord pprPrimInt8 pprPrimInt64 pprPrimInt32 pprPrimInt16 pprPrimInt pprPrimChar pprPrefixVar pprInfixVar pprHsString pprHsChar pprHsBytespprFilePathStringpprFastFilePath pprDeeperList pprDeeperpprCode ppWhenOptionppWhenppUnlessOptionppUnlesspluralparensneverQualifyPackagesneverQualifyNamesneverQualifyModules neverQualifynestmulArrow mkUserStyle mkErrStyle mkDumpStylelparenlollipoplbracklbracelarrowttlarrowtlarrowlambdakeyword itsOrTheirisOrAreisEmpty interppSP interpp'SP' interpp'SPinteger intWithCommasint ifPprDebughsephcat hangNotEmptyhang getPprStyle getPprDebugftextfsep forAllLitfloatfcatequals dumpStyle doubleQuotes doublePrecdoubledot docToSDocdoOrDoesdefaultUserStyledefaultSDocContextdefaultErrStyledefaultDumpStyledcolondarrowcparencommacolouredcolon codeStylecmdlineParserStylecharcatbulletbufLeftRenderSDocbracketsbraces blankLineasmStylearrowttarrowtarrow angleBracketsalwaysQualifyPackagesalwaysQualifyNamesalwaysQualifyModules alwaysQualify<><+>$+$$$OccName occNameFS occNameSpace HasOccNameoccName occNameString mkVarOccFSmkRecFldSelOccGHC.Data.FastString FastStringGHC.Driver.BackendBackendViaC NoBackendNCG InterpreterLLVMDynFlags warningFlagswarnUnsafeOnLoc warnSafeOnLoc verbosity useUnicodeuseColoruniqueIncrement unfoldingOptstrustworthyOnLoc trustFlags toolSettingsthOnLoc targetWays_stubDirstrictnessBefore sseVersion splitInfospecConstrThresholdspecConstrRecursivespecConstrCountsolverIterationssimplTickFactor simplPhases safeInferred safeInfer safeHaskell ruleCheckrtsOptsSuggestionsrtsOptsEnabledrtsOptsrtldInfortccInfo reverseErrorsrefLevelHoleFitsreductionDepth rawSettingsprofAuto pprUserLengthpprColspluginPackageFlagspluginModNamespluginModNameOpts platformMisc pkgTrustOnLoc parMakeCount packageFlags packageEnvpackageDBFlagsoverlapInstLocoutputHi outputFile_optLevel objectSuf_ objectDirnextWrapperNum newDerivOnLoc maxWorkerArgsmaxValidHoleFitsmaxUncoveredPatternsmaxSimplIterationsmaxRelevantBindsmaxRefHoleFitsmaxPmCheckModelsmaxInlineMemsetInsnsmaxInlineMemcpyInsnsmaxInlineAllocSize maxErrorsmainModuleNameIs mainFunIs llvmConfigliftLamsRecArgsliftLamsNonRecArgs liftLamsKnown libraryPathsliberateCaseThresholdldInputslanguageinteractivePrint inlineCheck initialUniqueincoherentOnLoc includePaths importPathsignorePackageFlagshpcDirhomeUnitInstantiations_homeUnitInstanceOf_ homeUnitId_ historySizehieSufhieDirhiSuf_hiDirhcSufhaddockOptions ghciScripts ghciHistSizeghcVersionFileghcNameVersionghcModeghcLink ghcHeapSize generalFlagsfrontendPluginOptsframeworkPathsflushOutflushErr floatLamArgs fileSettingsfatalWarningFlags extensionsextensionFlagsenableTimeStatsdynamicTooFailed dynamicNow dynOutputHidynOutputFile_ dynObjectSuf_ dynLibLoader dynHiSuf_dylibInstallNamedumpPrefixForce dumpPrefix dumpFlagsdumpDirderiveViaOnLoc depSuffixes depMakefiledepIncludePkgDepsdepIncludeCppDepsdepExcludeMods debugLevel colSchemecmmProcAlignmentcmdlineFrameworks cfgWeights canUseColorcallerCcFilters bmiVersionbinBlobThresholdavx512pfavx512favx512eravx512cdavx2avxtargetPlatformbackendUnitModule moduleName moduleUnit pprModule SDocContextsdocUnitIdForUsersdocSuppressVarKindssdocSuppressUniquessdocSuppressUnfoldingssdocSuppressTypeSignaturessdocSuppressTypeApplicationssdocSuppressTickssdocSuppressStgExtssdocSuppressModulePrefixessdocSuppressIdInfosdocSuppressCoercions sdocStylesdocStarIsTypesdocShouldUseColorsdocPrintUnicodeSyntaxsdocPrintTypecheckerElaborationsdocPrintTypeAbbreviationssdocPrintPotentialInstancessdocPrintExplicitRuntimeRepssdocPrintExplicitKindssdocPrintExplicitForallssdocPrintExplicitCoercionssdocPrintEqualityRelationssdocPrintCaseAsLetsdocPrintAxiomIncomps sdocPprDebugsdocLinearTypessdocLineLengthsdocLastColoursdocImpredicativeTypessdocHexWordLiteralssdocErrorSpanssdocDefaultDepth sdocColSchemeSDCsdocCanUseUnicodeSDocPprStylePprUserPprCodePprDumptext ModuleName ghci-9.2.4GHCi.RemoteTypes ForeignHValueHValue coreModule HasDefaultExtdefExt NameCacheIOtakeUniqFromNameCacheIOhscNameCacheIO issueWarningmkLabelFreshT runFreshT runFreshHscfreshfreshVardebugtypeletnoapplyModeAdvancedSimpleOptions parseOpts parseModeLargeAnonNameslargeAnon_emptylargeAnon_insertlargeAnon_applyPendinglargeAnon_letRecordTlargeAnon_letInsertAstypelet_castEqualgetLargeAnonNamesrecordWithTypelet simpleLam sourcePluginconstructEquivClasses canonicalizeGHC.Tc.Utils.TcMTypewriteMetaTyVarisFilledMetaTyVar_maybeGHC.Tc.Utils.MonadnewName GHC.Tc.Types TcTyThingTcGblEnvGHC.Tc.Types.ConstraintTcEvDest EvVarDestHoleDestQCInstCtLoc CtFlavour CtEvidence ctev_predctev_loc ctev_dest ctev_evarCtmkNonCanonicalctPredctOriginctLoc ctFlavour ctEvidencectEvExprctEqRelbumpCtLocDepthGHC.Tc.Types.OriginCtOrigin GHC.Core.Make FloatBind FloatCaseFloatLet wrapFloats wrapFloatunitExpr tYPE_ERROR_ID sortQuantVarsrUNTIME_ERROR_IDrEC_SEL_ERROR_IDrEC_CON_ERROR_ID pAT_ERROR_IDnO_METHOD_BINDING_ERROR_IDnON_EXHAUSTIVE_GUARDS_ERROR_ID mkWordExprmkWildValBindermkWildEvBinder mkWildCasemkUncheckedIntExprmkTupleSelector1mkTupleSelector mkTupleCasemkStringExprFSWithmkStringExprFS mkStringExprmkSmallTupleSelectormkSmallTupleCasemkRuntimeErrorApp mkNothingExprmkNonEmptyListExpr mkNilExpr mkNaturalExpr mkListExpr mkJustExpr mkIntegerExpr mkIntExprInt mkIntExprmkImpossibleExpr mkIfThenElse mkFoldrExpr mkFloatExpr mkDoubleExprmkCoreVarTupTy mkCoreUbxTup mkCoreUbxSummkCoreTupBoxity mkCoreTup mkCoreLets mkCoreLet mkCoreLams mkCoreConApps mkCoreApps mkCoreApp mkConsExpr mkCharExpr mkBuildExprmkBigCoreVarTupTymkBigCoreVarTup1mkBigCoreVarTupmkBigCoreTupTy mkBigCoreTupmkAbsentErrorApp floatBindingserrorIdscastBottomExpraBSENT_SUM_FIELD_ERROR_IDaBSENT_ERROR_IDGHC.Core.UtilsmkSingleAltCaseGHC.Tc.Types.EvidenceEvTermEvExpr EvBindsVarEvBindeb_lhseb_rhs lookupEvBind evDataConApp evCoercionevCastInstEnvsTcLclEnvGHC.Tc.Utils.TcTypeTcTypeTcLevelMetaInfo isSkolemTyVarGHC.Builtin.Types wordTyConName wordTyConwordTy wordDataCon word8TyConword8Ty word8DataCon wiredInTyConsunrestrictedFunTyConNameunliftedTypeKindTyConNameunliftedRepTyConNameunliftedDataConTyCon unitTyConKey unitTyCon unitDataConId unitDataConunboxedUnitTyCon unboxedUnitTyunboxedUnitDataConunboxedSumKindtypeToTypeKindtypeSymbolKindContupleDataConNametrue_RDR trueDataConId trueDataConsumRepDataConTyConstringTyCon_RDRstringTy soloTyConpromotedTrueDataConpromotedNothingDataConpromotedNilDataConpromotedLTDataConpromotedJustDataConpromotedGTDataConpromotedFalseDataConpromotedEQDataConpromotedConsDataCon pairTyCon orderingTyConordLTDataConId ordLTDataConordGTDataConId ordGTDataConordEQDataConId ordEQDataCononeDataConName oneDataConnothingDataConNamenothingDataConnonEmptyTyConName nonEmptyTyConnonEmptyDataConNamenonEmptyDataConnilDataConName nilDataConnaturalTyConName naturalTyConnaturalNSDataConNamenaturalNSDataConnaturalNBDataConNamenaturalNBDataConmultiplicityTyConNamemkWiredInTyConNamemkWiredInIdName mkTupleTy1 mkTupleTy mkTupleStrmkSumTymkPromotedPairTymkPromotedMaybeTy mkMaybeTymkListTymaybeTyConName maybeTyConmanyDataConName manyDataConmakeRecoveryTyCon listTyCon_RDR listTyConNameliftedTypeKindTyConNameliftedRepTyConNamejustDataConName justDataConisPromotedPairTypeisPromotedMaybeTyisCTupleTyConNameisBuiltInOcc_maybeintegerTyConName integerTyConintegerISDataConNameintegerISDataConintegerIPDataConNameintegerIPDataConintegerINDataConNameintegerINDataCon intTyCon_RDR intTyConNameintTyConintTyintDataCon_RDR intDataCon heqTyConName heqDataConheqClassfloatTyConName floatTyConfloatTy floatDataCon filterCTuple false_RDRfalseDataConId falseDataCon eqTyCon_RDR eqTyConNameeqTyCon eqDataConeqClassdoubleTyConName doubleTyCondoubleTy doubleDataConconstraintKindTyConNameconstraintKindTyConconsDataCon_RDRconsDataConName consDataConcoercibleTyConNamecoercibleDataConcoercibleClass charTyCon_RDR charTyConName charTyCon charDataConcTupleTyConNamescTupleTyConNameArity_maybe cTupleTyCon cTupleSelIdcTupleDataConNamesboxingDataCon_maybe boolTyCon_RDR boolTyConName boolTyConboolTyanyTyConanyTy MonadThings lookupTyCon lookupThing lookupDataConlookupId mkLocalIdGHC.CoreExprVarCoercionCoreExprCoreBndrGHC.Unit.Finder.Types FindResult fr_unusablesfr_suggestionsfr_pkgs_hiddenfr_pkgfr_pathsfr_mods_hiddenNotFound NoPackageFound FoundMultiple classDataCon FamInstEnvGHC.Core.PredicatePred IrredPred ForAllPred ClassPredEqPredEqRelNomEqReprEq mkClassPredclassifyPredTypeGHC.Core.CoercionmkPrimEqPredRoletyConAppTyConPicky_maybe splitAppTyssplitAppTy_maybe mkStrLitTy mkNumLitTy mkCoercionTymkAppTys isTyVarTy isStrLitTy isNumLitTyisCoercionTy_maybegetTyVar_maybeeqTypewordPrimTyConName wordPrimTyCon wordPrimTyword8X64PrimTyConword8X64PrimTyword8X32PrimTyConword8X32PrimTyword8X16PrimTyConword8X16PrimTyword8PrimTyConNameword8PrimTyCon word8PrimTyword64X8PrimTyConword64X8PrimTyword64X4PrimTyConword64X4PrimTyword64X2PrimTyConword64X2PrimTyword64PrimTyConNameword64PrimTyCon word64PrimTyword32X8PrimTyConword32X8PrimTyword32X4PrimTyConword32X4PrimTyword32X16PrimTyConword32X16PrimTyword32PrimTyConNameword32PrimTyCon word32PrimTyword16X8PrimTyConword16X8PrimTyword16X32PrimTyConword16X32PrimTyword16X16PrimTyConword16X16PrimTyword16PrimTyConNameword16PrimTyCon word16PrimTy weakPrimTyConunexposedPrimTyConsthreadIdPrimTyConthreadIdPrimTy tYPETyConName tYPETyCon tVarPrimTyConstatePrimTyConstablePtrPrimTyConstableNamePrimTyConsmallMutableArrayPrimTyConsmallArrayPrimTyConruntimeRep3TyVar runtimeRep3TyruntimeRep2TyVar runtimeRep2TyruntimeRep1TyVar runtimeRep1TyrealWorldTyCon realWorldTyrealWorldStatePrimTyproxyPrimTyCon primTyConsprimRepToRuntimeRepopenGammaTyVar openGammaTy openBetaTyVar openBetaTyopenAlphaTyVar openAlphaTymutableByteArrayPrimTyConmutableArrayPrimTyConmutableArrayArrayPrimTyConmutVarPrimTyConmultiplicityTyVar2multiplicityTyVar1 mkWeakPrimTymkTemplateTyVarsFrommkTemplateTyVarsmkTemplateTyConBindersmkTemplateKindVarsmkTemplateKindTyConBindersmkTemplateKiTyVarsmkTemplateKiTyVarmkTemplateAnonTyConBinders mkTVarPrimTy mkStatePrimTymkStablePtrPrimTymkStableNamePrimTymkSmallMutableArrayPrimTymkSmallArrayPrimTy mkProxyPrimTymkPrimTyConNamemkMutableByteArrayPrimTymkMutableArrayPrimTymkMutableArrayArrayPrimTymkMutVarPrimTy mkMVarPrimTymkIOPortPrimTy mkArrayPrimTymkArrayArrayPrimTy mVarPrimTyConioPortPrimTyConintPrimTyConName intPrimTyCon intPrimTyint8X64PrimTyCon int8X64PrimTyint8X32PrimTyCon int8X32PrimTyint8X16PrimTyCon int8X16PrimTyint8PrimTyConName int8PrimTyCon int8PrimTyint64X8PrimTyCon int64X8PrimTyint64X4PrimTyCon int64X4PrimTyint64X2PrimTyCon int64X2PrimTyint64PrimTyConNameint64PrimTyCon int64PrimTyint32X8PrimTyCon int32X8PrimTyint32X4PrimTyCon int32X4PrimTyint32X16PrimTyConint32X16PrimTyint32PrimTyConNameint32PrimTyCon int32PrimTyint16X8PrimTyCon int16X8PrimTyint16X32PrimTyConint16X32PrimTyint16X16PrimTyConint16X16PrimTyint16PrimTyConNameint16PrimTyCon int16PrimTy gammaTyVargammaTyfunctionWithMultiplicity funTyConNamefunTyConfloatX8PrimTyCon floatX8PrimTyfloatX4PrimTyCon floatX4PrimTyfloatX16PrimTyConfloatX16PrimTyfloatPrimTyConNamefloatPrimTyCon floatPrimTyexposedPrimTyCons equalityTyConeqReprPrimTyCon eqPrimTyConeqPhantPrimTyCondoubleX8PrimTyCondoubleX8PrimTydoubleX4PrimTyCondoubleX4PrimTydoubleX2PrimTyCondoubleX2PrimTydoublePrimTyConNamedoublePrimTyCon doublePrimTy deltaTyVardeltaTycompactPrimTyCon compactPrimTycharPrimTyConName charPrimTyCon charPrimTybyteArrayPrimTyConbyteArrayPrimTy betaTyVarbetaTy bcoPrimTyCon bcoPrimTyarrayPrimTyConarrayArrayPrimTyConalphaTysUnliftedRepalphaTysalphaTyVarsUnliftedRepalphaTyVarUnliftedRep alphaTyVaralphaTyUnliftedRepalphaTyaddrPrimTyConName addrPrimTyCon addrPrimTy CoercionHolech_ref ch_co_varmkVisFunTysManymkVisFunTyMany mkTyVarTys mkTyVarTymkPiTysmkPiTy mkForAllTysisLiftedTypeKindTyConNameGHC.Builtin.NameszipNamezipIdKey wordTyConKeywordPrimTyConKeywordDataConKeyword8X64PrimTyConKeyword8X32PrimTyConKeyword8X16PrimTyConKeyword8TyConName word8TyConKeyword8PrimTyConKeyword8DataConKeyword64X8PrimTyConKeyword64X4PrimTyConKeyword64X2PrimTyConKeyword64TyConNameword64TyConKeyword64PrimTyConKeyword32X8PrimTyConKeyword32X4PrimTyConKeyword32X16PrimTyConKeyword32TyConNameword32TyConKeyword32PrimTyConKeyword16X8PrimTyConKeyword16X32PrimTyConKeyword16X16PrimTyConKeyword16TyConNameword16TyConKeyword16PrimTyConKey wildCardName wildCardKeyweakPrimTyConKey voidPrimIdKey voidArgIdKeyvecRepDataConKeyvecElemTyConKeyvecElemDataConKeysvecCountTyConKeyvecCountDataConKeys varQual_RDRvarQual v1TyConName v1TyConKeyunsafeReflDataConNameunsafeReflDataConKeyunsafeRangeSize_RDRunsafeIndex_RDRunsafeEqualityTyConNameunsafeEqualityTyConKeyunsafeEqualityProofNameunsafeEqualityProofIdKeyunsafeCoercePrimNameunsafeCoercePrimIdKeyunrestrictedFunTyConKeyunpackCString_RDRunpackCStringUtf8_RDRunpackCStringUtf8NameunpackCStringUtf8IdKeyunpackCStringNameunpackCStringIdKeyunpackCStringFoldr_RDRunpackCStringFoldrUtf8_RDRunpackCStringFoldrUtf8NameunpackCStringFoldrUtf8IdKeyunpackCStringFoldrNameunpackCStringFoldrIdKeyunpackCStringAppendIdKeyunliftedTypeKindTyConKeyunliftedRepTyConKeyunliftedDataConKeyunknownTyConKeyunknown3TyConKeyunknown2TyConKeyunknown1TyConKey unboundKey unRec1_RDR unPar1_RDRunK1_RDR unComp1_RDRuWordTyConName uWordTyConKey uWordHash_RDRuWordDataCon_RDR uRecTyConName uRecTyConKey uNSAFE_COERCE uIntTyConName uIntTyConKey uIntHash_RDRuIntDataCon_RDRuFloatTyConNameuFloatTyConKeyuFloatHash_RDRuFloatDataCon_RDRuDoubleTyConNameuDoubleTyConKeyuDoubleHash_RDRuDoubleDataCon_RDRuCharTyConName uCharTyConKey uCharHash_RDRuCharDataCon_RDRuAddrTyConName uAddrTyConKey uAddrHash_RDRuAddrDataCon_RDR u1TyConName u1TyConKey u1DataCon_RDRtypeableClassNametypeableClassKeytypeUnconsSymbolTyFamNameKeytypeSymbolTypeRepNametypeSymbolTypeRepKeytypeSymbolKindConNameKeytypeSymbolCmpTyFamNameKeytypeSymbolAppendFamNameKeytypeRepTyConNametypeRepTyConKey typeRepIdName typeRepIdKeytypeNatTypeRepNametypeNatTypeRepKeytypeNatToCharTyFamNameKeytypeNatSubTyFamNameKeytypeNatMulTyFamNameKeytypeNatModTyFamNameKeytypeNatLogTyFamNameKeytypeNatExpTyFamNameKeytypeNatDivTyFamNameKeytypeNatCmpTyFamNameKeytypeNatAddTyFamNameKeytypeLitSymbolDataConNametypeLitSymbolDataConKeytypeLitSortTyConNametypeLitSortTyConKeytypeLitNatDataConNametypeLitNatDataConKeytypeLitCharDataConNametypeLitCharDataConKeytypeLeqCharTyFamNameKeytypeErrorVAppendDataConNametypeErrorVAppendDataConKeytypeErrorTextDataConNametypeErrorTextDataConKeytypeErrorShowTypeDataConNametypeErrorShowTypeDataConKeytypeErrorIdKeytypeErrorAppendDataConNametypeErrorAppendDataConKeytypeConsSymbolTyFamNameKey typeConKeytypeCharTypeRepNametypeCharTypeRepKeytypeCharToNatTyFamNameKeytypeCharKindConNameKeytypeCharCmpTyFamNameKeytupleRepDataConKeytrueDataConKey traverse_RDRtraversableClassNametraversableClassKey traceNametraceKeytrTyConTyConNametrTyConTyConKeytrTyConDataConNametrTyConDataConKey trTYPEKeytrTYPE'PtrRepLiftedKeytrRuntimeRepKeytrNameTyConNametrNameTyConKeytrNameSDataConNametrNameSDataConKeytrNameDDataConNametrNameDDataConKeytrModuleTyConNametrModuleTyConKeytrModuleDataConNametrModuleDataConKeytrLiftedRepKeytrGhcPrimModuleNametrGhcPrimModuleKeytr'PtrRepLiftedKeyto_RDRtoRational_RDRtoRationalNametoRationalClassOpKey toList_RDR toListNametoListClassOpKey toInteger_RDR toIntegerNametoIntegerClassOpKey toEnum_RDR toDynName toDynIdKeytoAnnotationWrapperNametoAnnotationWrapperIdKeyto1_RDR times_RDRthreadIdPrimTyConKey thenMNamethenMClassOpKey thenIOName thenIOIdKey thenANamethenAClassOpKey tcQual_RDRtcQual tYPETyConKeytYPEABLE_INTERNALtYPEABLEtVarPrimTyConKey symbol_RDR sumTyConName sumTyConKeysumRepDataConKeysucc_RDRstringTyConKeystep_RDRstaticPtrTyConNamestaticPtrTyConKeystaticPtrInfoTyConNamestaticPtrInfoTyConKeystaticPtrInfoDataConNamestaticPtrInfoDataConKeystaticPtrDataConNamestaticPtrDataConKeystatePrimTyConKeystarKindRepNamestarKindRepKeystarArrStarKindRepNamestarArrStarKindRepKeystarArrStarArrStarKindRepNamestarArrStarArrStarKindRepKeystandardClassKeysstablePtrTyConNamestablePtrTyConKeystablePtrPrimTyConKeystableNameTyConKeystableNamePrimTyConKeystableNameDataConKeysrcLocDataConNamesrcLocDataConKey specTyConName specTyConKeysourceUnpackDataConNamesourceUnpackDataConKeysourceStrictDataConNamesourceStrictDataConKeysourceNoUnpackDataConNamesourceNoUnpackDataConKeysourceLazyDataConNamesourceLazyDataConKeysomeTypeRepTyConNamesomeTypeRepTyConKeysomeTypeRepDataConNamesomeTypeRepDataConKeysndNamesndIdKeysmallMutableArrayPrimTyConKeysmallArrayPrimTyConKey shows_RDR showsPrec_RDRshowString_RDR showSpace_RDR showParen_RDRshowCommaSpace_RDR showClassName showClassKey setFieldNamesetFieldClassOpKeyseqIdKeysemigroupClassNamesemigroupClassKeyselectorClassNameselectorClassKey selName_RDR sappendNamesappendClassOpKey sYSTEM_IO sTyConName sTyConKey s1TyConName s1TyConKeyruntimeRepTyConKeyruntimeRepSimpleDataConKeysruntimeErrorIdKey runRWNamerunRWKey runMainKey runMainIOName rootMainKey right_RDRrightSectionKeyrightDataConNamerightDataConKeyrightAssociativeDataConNamerightAssociativeDataConKeyrightAssocDataCon_RDR returnM_RDR returnMNamereturnMClassOpKey returnIO_RDR returnIOName returnIOIdKey reset_RDR replace_RDR repTyConName repTyConKey rep1TyConName rep1TyConKeyrecSelErrorIdKeyrecConErrorIdKey rec1TyConName rec1TyConKeyrec1DataCon_RDR rec0TyConName rec0TyConKeyrealWorldTyConKeyrealWorldPrimIdKeyrealToFracNamerealToFracIdKeyrealFracClassNamerealFracClassKeyrealFloatClassNamerealFloatClassKey realClassName realClassKeyreadSymField_RDR readPrec_RDR readList_RDRreadListPrec_RDRreadListPrecDefault_RDRreadListDefault_RDR readField_RDRreadFieldHash_RDR readClassName readClassKeyrationalTyConNamerationalTyConKeyrationalToFloatNamerationalToFloatIdKeyrationalToDoubleNamerationalToDoubleIdKeyratioTyConName ratioTyConKeyratioDataCon_RDRratioDataConNameratioDataConKey range_RDRrandomGenClassNamerandomGenClassKeyrandomClassNamerandomClassKeyraiseUnderflowIdKeyraiseOverflowIdKeyraiseDivZeroIdKey rTyConName rTyConKey rOOT_MAIN rEAD_PRECrANDOM r1DataCon_RDRpushCallStackNamepushCallStackKeypure_RDR pureANamepureAClassOpKeypunc_RDR ptrTyConName ptrTyConKeyproxyPrimTyConKey proxyHashKey prodTyConName prodTyConKeyprodDataCon_RDR printName printIdKeypretendNameIsInScopeprefixIDataConNameprefixIDataConKeyprefixDataCon_RDRpred_RDRprec_RDRplus_RDRpluginTyConNamepluginTyConKey pfail_RDR patErrorIdKey parens_RDR par1TyConName par1TyConKeypar1DataCon_RDRpackageName_RDR pRELUDE_NAMEpRELUDEpLUGINSotherwiseIdNameotherwiseIdKeyorderingTyConNameorderingTyConKeyordLTDataConNameordLTDataConKeyordGTDataConNameordGTDataConKeyordEQDataConNameordEQDataConKey ordClass_RDR ordClassName ordClassKeyopaqueTyConNameopaqueTyConKey oneShotKey oneDataConKeynumericClassKeys numClass_RDR numClassName numClassKeynull_RDR nullAddrIdKeynothingDataConKeynot_RDRnotAssociativeDataConNamenotAssociativeDataConKeynotAssocDataCon_RDRnonExhaustiveGuardsErrorIdKeynonEmptyTyConKeynonEmptyDataConKey noinlineIdKeynoSourceUnpackednessDataConNamenoSourceUnpackednessDataConKeynoSourceStrictnessDataConNamenoSourceStrictnessDataConKeynoSelTyConName noSelTyConKeynoMethodBindingErrorIdKey nilDataConKeynewStablePtr_RDRnewStablePtrNamenewStablePtrIdKey negateNamenegateClassOpKeynaturalXorNamenaturalXorIdKeynaturalTyConKeynaturalToWordNamenaturalToWordIdKeynaturalToWordClampNamenaturalToWordClampIdKeynaturalToFloatNamenaturalToFloatIdKeynaturalToDoubleNamenaturalToDoubleIdKeynaturalTestBitNamenaturalTestBitIdKeynaturalSubUnsafeNamenaturalSubUnsafeIdKeynaturalSubThrowNamenaturalSubThrowIdKeynaturalSubNamenaturalSubIdKeynaturalSizeInBaseNamenaturalSizeInBaseIdKeynaturalSignumNamenaturalSignumIdKeynaturalShiftRNamenaturalShiftRIdKeynaturalShiftLNamenaturalShiftLIdKeynaturalRemNamenaturalRemIdKeynaturalQuotRemNamenaturalQuotRemIdKeynaturalQuotNamenaturalQuotIdKeynaturalPowModNamenaturalPowModIdKeynaturalPopCountNamenaturalPopCountIdKey naturalOrNamenaturalOrIdKeynaturalNegateNamenaturalNegateIdKey naturalNeNamenaturalNeIdKeynaturalNSDataConKeynaturalNBDataConKeynaturalMulNamenaturalMulIdKey naturalLtNamenaturalLtIdKeynaturalLogBaseWordNamenaturalLogBaseWordIdKeynaturalLogBaseNamenaturalLogBaseIdKeynaturalLog2NamenaturalLog2IdKey naturalLeNamenaturalLeIdKeynaturalLcmNamenaturalLcmIdKey naturalGtNamenaturalGtIdKey naturalGeNamenaturalGeIdKeynaturalGcdNamenaturalGcdIdKey naturalEqNamenaturalEqIdKeynaturalCompareNamenaturalCompareIdKeynaturalBitNamenaturalBitIdKeynaturalAndNotNamenaturalAndNotIdKeynaturalAndNamenaturalAndIdKeynaturalAddNamenaturalAddIdKeymzipName mzipIdKeymutableByteArrayPrimTyConKeymutableArrayPrimTyConKeymutableArrayArrayPrimTyConKeymutVarPrimTyConKeymultiplicityTyConKeymultMulTyConKeymonoidClassNamemonoidClassKeymonadPlusClassNamemonadPlusClassKeymonadFixClassNamemonadFixClassKeymonadFailClassNamemonadFailClassKeymonadClass_RDRmonadClassName monadClassKeymoduleName_RDR modIntName modIntIdKeymk_known_key_name mkUnboundName mkTyConKey mkTrTypeName mkTrTypeKey mkTrFunName mkTrFunKey mkTrConName mkTrConKey mkTrAppName mkTrAppKeymkThisGhcModule_mkThisGhcModulemkRationalBase2NamemkRationalBase2IdKeymkRationalBase10NamemkRationalBase10IdKey mkPrimModule mkMainModule_ mkMainModulemkInteractiveModulemkBignumModule mkBaseModule_ mkBaseModule minus_RDR minusNameminusClassOpKey minBound_RDRmfixName mfixIdKeymetaSelDataConNamemetaSelDataConKeymetaDataDataConNamemetaDataDataConKeymetaConsDataConNamemetaConsDataConKey mempty_RDR memptyNamememptyClassOpKey mconcatNamemconcatClassOpKey maybeTyConKey maxBound_RDR mappend_RDR mappendNamemappendClassOpKeymap_RDRmapNamemapIdKeymanyDataConKeymakeStaticName makeStaticKeymain_RDR_Unqual magicDictKeymVarPrimTyConKey mONAD_ZIP mONAD_FIX mONAD_FAILmONAD mAIN_NAME m1TyConName m1TyConKey m1DataCon_RDRlt_RDR ltTag_RDR loopAName loopAIdKey listTyConKeyliftedTypeKindTyConKeyliftedRepTyConKeyliftedDataConKey liftMName liftMIdKey liftA2_RDRlexP_RDRlevityTyConKeyleft_RDRleftSectionKeyleftDataConNameleftDataConKeyleftAssociativeDataConNameleftAssociativeDataConKeyleftAssocDataCon_RDRle_RDR lazyIdKeylEX l1DataCon_RDRknownSymbolClassNameKeyknownSymbolClassNameknownNatClassNameKeyknownNatClassNameknownCharClassNameKeyknownCharClassNamekindRepVarDataConNamekindRepVarDataConKeykindRepTypeLitSDataConNamekindRepTypeLitSDataConKeykindRepTypeLitDDataConNamekindRepTypeLitDDataConKeykindRepTyConNamekindRepTyConKeykindRepTyConAppDataConNamekindRepTyConAppDataConKeykindRepTYPEDataConNamekindRepTYPEDataConKeykindRepFunDataConNamekindRepFunDataConKeykindRepAppDataConNamekindRepAppDataConKey kindConKey k1TyConName k1TyConKey k1DataCon_RDRjustDataConKey joinMName joinMIdKey ixClassName ixClassKeyitName isUnboundNameisStringClassNameisStringClassKeyisNewtypeName_RDRisListClassNameisListClassKey ipClassName ipClassKey ioTyConName ioTyConKeyioPortPrimTyConKey ioDataCon_RDR ioDataConName ioDataConKeyinteractiveClassNamesinteractiveClassKeysintegralClassNameintegralClassKeyintegerXorNameintegerXorIdKeyintegerTyConKeyintegerToWordNameintegerToWordIdKeyintegerToWord64NameintegerToWord64IdKeyintegerToNaturalThrowNameintegerToNaturalThrowIdKeyintegerToNaturalNameintegerToNaturalIdKeyintegerToNaturalClampNameintegerToNaturalClampIdKeyintegerToIntNameintegerToIntIdKeyintegerToInt64NameintegerToInt64IdKeyintegerToFloatNameintegerToFloatIdKeyintegerToDoubleNameintegerToDoubleIdKeyintegerTestBitNameintegerTestBitIdKeyintegerSubNameintegerSubIdKeyintegerSignumNameintegerSignumIdKeyintegerShiftRNameintegerShiftRIdKeyintegerShiftLNameintegerShiftLIdKeyintegerRemNameintegerRemIdKeyintegerQuotRemNameintegerQuotRemIdKeyintegerQuotNameintegerQuotIdKeyintegerPopCountNameintegerPopCountIdKey integerOrNameintegerOrIdKeyintegerNegateNameintegerNegateIdKey integerNeNameintegerNeIdKeyintegerMul_RDRintegerMulNameintegerMulIdKeyintegerModNameintegerModIdKey integerLtNameintegerLtIdKey integerLeNameintegerLeIdKeyintegerLcmNameintegerLcmIdKeyintegerISDataConKeyintegerIPDataConKeyintegerINDataConKey integerGtNameintegerGtIdKey integerGeNameintegerGeIdKeyintegerGcdNameintegerGcdIdKeyintegerFromWordNameintegerFromWordIdKeyintegerFromWord64NameintegerFromWord64IdKeyintegerFromNaturalNameintegerFromNaturalIdKeyintegerFromInt64NameintegerFromInt64IdKey integerEqNameintegerEqIdKeyintegerEncodeFloatNameintegerEncodeFloatIdKeyintegerEncodeDoubleNameintegerEncodeDoubleIdKeyintegerDivNameintegerDivModNameintegerDivModIdKeyintegerDivIdKeyintegerComplementNameintegerComplementIdKeyintegerCompareNameintegerCompareIdKeyintegerBitNameintegerBitIdKeyintegerAndNameintegerAndIdKeyintegerAdd_RDRintegerAddNameintegerAddIdKeyintegerAbsNameintegerAbsIdKey intTyConKeyintPrimTyConKey intDataConKeyint8X64PrimTyConKeyint8X32PrimTyConKeyint8X16PrimTyConKey int8TyConName int8TyConKeyint8PrimTyConKeyint64X8PrimTyConKeyint64X4PrimTyConKeyint64X2PrimTyConKeyint64TyConName int64TyConKeyint64PrimTyConKeyint32X8PrimTyConKeyint32X4PrimTyConKeyint32X16PrimTyConKeyint32TyConName int32TyConKeyint32PrimTyConKeyint16X8PrimTyConKeyint16X32PrimTyConKeyint16X16PrimTyConKeyint16TyConName int16TyConKeyint16PrimTyConKey inrDataConKey inlineIdName inlineIdKey inlDataConKeyinfixIDataConNameinfixIDataConKeyinfixDataCon_RDR index_RDR inRange_RDR ident_RDR heqTyConKey heqSCSelIdKey heqDataConKeyhasFieldClassNameKeyhasFieldClassName guardMName guardMIdKeygt_RDR gtTag_RDR groupWithNamegroupWithIdKeyghciStepIoMNameghciStepIoMClassOpKeyghciIoClassNameghciIoClassKey getTag_RDR getFieldNamegetFieldClassOpKeygenericTyConNamesgenericClassNamesgenUnitDataConKey genClassName genClassKey gen1ClassName gen1ClassKeyge_RDRgeName geClassOpKeygHC_WORD gHC_TYPESgHC_TYPENATS_INTERNAL gHC_TYPENATSgHC_TYPELITS_INTERNAL gHC_TYPELITS gHC_TUPLEgHC_TOP_HANDLERgHC_STATICPTR_INTERNAL gHC_STATICPTRgHC_STACK_TYPES gHC_STACK gHC_STABLEgHC_ST gHC_SRCLOCgHC_SHOW gHC_RECORDSgHC_REALgHC_READgHC_PTRgHC_PRIM_PANICgHC_PRIM_EXCEPTIONgHC_PRIMOPWRAPPERSgHC_PRIMgHC_OVER_LABELSgHC_NUM_NATURALgHC_NUM_INTEGERgHC_NUM_BIGNATgHC_NUM gHC_MAYBE gHC_MAGICgHC_LISTgHC_IXgHC_IO_ExceptiongHC_IOgHC_INTgHC_GHCI_HELPERSgHC_GHCI gHC_GENERICS gHC_FLOATgHC_FINGERPRINT_TYPEgHC_EXTSgHC_ERRgHC_ENUM gHC_DESUGAR gHC_CSTRINGgHC_CONC gHC_CLASSESgHC_BASEgENERICSfunctorClassNamefunctorClassKey funTyConKeyfunPtrTyConNamefunPtrTyConKeyfstNamefstIdKeyfrontendPluginTyConNamefrontendPluginTyConKeyfrom_RDRfromString_RDRfromStringNamefromStringClassOpKeyfromStaticPtrNamefromStaticPtrClassOpKeyfromRational_RDRfromRationalNamefromRationalClassOpKey fromList_RDR fromListName fromListN_RDR fromListNNamefromListNClassOpKeyfromListClassOpKeyfromLabelClassOpNamefromLabelClassOpKeyfromIntegral_RDRfromIntegralNamefromIntegralIdKeyfromInteger_RDRfromIntegerNamefromIntegerClassOpKey fromEnum_RDR from1_RDRfractionalClassNamefractionalClassKeysfractionalClassKeyforeignObjPrimTyConKey foldr_RDR foldrName foldrIdKeyfoldable_foldr_RDRfoldableClassNamefoldableClassKey foldMap_RDRfmap_RDRfmapNamefmapClassOpKeyfloatingClassNamefloatingClassKeyfloatX8PrimTyConKeyfloatX4PrimTyConKeyfloatX16PrimTyConKey floatTyConKeyfloatPrimTyConKeyfloatDataConKey firstAName firstAIdKeyfingerprintDataConNamefingerprintDataConKey filterName filterIdKeyfalseDataConKey failM_RDR failMNamefailMClassOpKey failIOName failIOIdKey expectP_RDR error_RDRerrorMessageTypeErrorFamNameerrorMessageTypeErrorFamKey errorIdKeyeq_RDR eqTyConKey eqTag_RDR eqString_RDR eqStringName eqStringIdKey eqSCSelIdKeyeqReprPrimTyConKeyeqPrimTyConKeyeqPhantPrimTyConKeyeqName eqDataConKey eqClass_RDR eqClassOpKey eqClassName eqClassKey enumFrom_RDRenumFromTo_RDRenumFromToNameenumFromToClassOpKeyenumFromThen_RDRenumFromThenTo_RDRenumFromThenToNameenumFromThenToClassOpKeyenumFromThenNameenumFromThenClassOpKey enumFromNameenumFromClassOpKey enumClass_RDR enumClassName enumClassKeyemptyCallStackNameemptyCallStackKeyeitherTyConNameeitherTyConKeydoubleX8PrimTyConKeydoubleX4PrimTyConKeydoubleX2PrimTyConKeydoubleTyConKeydoublePrimTyConKeydoubleDataConKey dollarName dollarIdKey divIntName divIntIdKeyderivableClassKeysdecidedUnpackDataConNamedecidedUnpackDataConKeydecidedStrictDataConNamedecidedStrictDataConKeydecidedLazyDataConNamedecidedLazyDataConKeydcQualdatatypeName_RDRdatatypeClassNamedatatypeClassKey dataToTag_RDR dataQual_RDR dataClassName dataClassKeydYNAMIC dTyConName dTyConKey dEBUG_TRACEdATA_TYPE_EQUALITY dATA_TUPLEdATA_TRAVERSABLE dATA_STRING dATA_LIST dATA_FOLDABLE dATA_EITHER dATA_COERCEdATA_ARRAY_PARALLEL_PRIM_NAMEdATA_ARRAY_PARALLEL_NAME d1TyConName d1TyConKeycstringLengthNamecstringLengthIdKeycrossDataConKeyconstructorClassNameconstructorClassKeyconstraintKindTyConKeyconsiderAccessibleNameconsiderAccessibleIdKeyconsDataConKey concatName concatIdKey conName_RDRconIsRecord_RDR conFixity_RDR compose_RDR composeAName composeAIdKey compare_RDRcompactPrimTyConKey compTyConName compTyConKeycomp1DataCon_RDRcoercionTokenIdKeycoercibleTyConKeycoercibleSCSelIdKeycoercibleDataConKey coerceKey clsQual_RDRclsQual choose_RDR choiceAName choiceAIdKey charTyConKeycharPrimTyConKeycharDataConKeycallStackTyConNamecallStackTyConKey cTyConName cTyConKeycONTROL_EXCEPTION_BASEcONTROL_APPLICATIVE c1TyConName c1TyConKeybyteArrayPrimTyConKey build_RDR buildName buildIdKeybreakpointNamebreakpointIdKeybreakpointCondNamebreakpointCondIdKey boxityConKeyboxedRepDataConKeyboundedClassNameboundedClassKey boolTyConKey bnnVarQual bniVarQual bnbVarQualbitIntegerIdKey bindM_RDR bindMNamebindMClassOpKey bindIO_RDR bindIOName bindIOIdKeybignatFromWordListNamebignatFromWordListIdKeybcoPrimTyConKeybasicKnownKeyNames augmentName augmentIdKey assertName assertIdKeyassertErrorNameassertErrorIdKeyarrayPrimTyConKeyarrayArrayPrimTyConKeyarrAName arrAIdKeyapplicativeClassNameapplicativeClassKey append_RDR appendName appendIdKeyappAName appAIdKeyap_RDRapAName apAClassOpKey anyTyConKey anyBoxConKeyand_RDRalternativeClassNamealternativeClassKeyalt_RDRall_RDRallNameStringsaddrPrimTyConKeyabsentSumFieldErrorIdKeyabsentErrorIdKeyaRROW classTyConmkUnivCo mkTransComkSymComkReflCoGHC.Core.Coercion.AxiomRoleRepresentationalNominalPhantomEvVarCoVarmkTyVarwordRepDataConTyword8RepDataConTyword8ElemRepDataConTyword64RepDataConTyword64ElemRepDataConTyword32RepDataConTyword32ElemRepDataConTyword16RepDataConTyword16ElemRepDataConTyvecRepDataConTyCon vecElemTyCon vecCountTyCon vec8DataConTyvec64DataConTy vec4DataConTyvec32DataConTy vec2DataConTyvec16DataConTyunrestrictedFunTyConunliftedTypeKindTyConunliftedTypeKindunliftedRepTyCon unliftedRepTyunliftedDataConTyunitTyunboxedTupleKindtypeSymbolKindtupleTyConName tupleTyContupleRepDataConTyCon tupleDataConsumTyCon sumDataConruntimeRepTyCon runtimeRepTypromotedTupleDataCononeDataConTyCon oneDataConTy naturalTymultiplicityTyConmultiplicityTy multMulTyConmkPromotedListTymkBoxedTupleTymanyDataConTyCon manyDataConTy listTyConliftedTypeKindTyConliftedTypeKindliftedRepTyCon liftedRepTyliftedDataConTyConliftedDataConTy levityTyCon integerTyintRepDataConTyint8RepDataConTyint8ElemRepDataConTyint64RepDataConTyint64ElemRepDataConTyint32RepDataConTyint32ElemRepDataConTyint16RepDataConTyint16ElemRepDataConTyheqTyConfloatRepDataConTyfloatElemRepDataConTydoubleRepDataConTydoubleElemRepDataConTyconstraintKindcoercibleTyConcharTycTupleTyConNamecTupleSelIdNamecTupleDataConName cTupleDataConboxedRepDataConTyCon anyTypeOfKindaddrRepDataConTypromoteDataContyConAppTyCon_maybetYPEsplitTyConApp_maybe mkTyConTy mkTyConAppmkAppTy isCoercionTyUnivCoProvenance mkForAllTy MetaDetails isMetaTyVar TupleSort UnboxedTuple BoxedTupleConstraintTuple PromotionFlag IsPromoted NotPromotedBoxityBoxedUnboxedArity isPromotedTcTyVarstringToUnitIdGHC.Types.Unique.DFMUniqDFMlookupUDFM_Directly lookupUDFMelemUDFMGHC.Types.Unique.FMUniqFM listToUFMemptyUFMGHC.Types.UniqueUnique Uniquable getUniquehasKeypprPanicunpackFSfsLitGHC.Utils.Panic.PlainpanicUnitIdunitIdFS0ghc-tcplugin-api-0.10.0.0-Iq8gG2Whuq3FGBMqE1YHKVGHC.TcPlugin.APImkTyFamAppReductionmkPluginUnivEvTermmkPluginUnivCo setEvBindnewCoercionHolenewEvVarsetCtLocRewriteM setCtLocMrewriteEnvCtLocnewGiven newWantedzonkCt zonkTcTypeisTouchableTcPluginM newFlexiTyVar newUniquematchFamgetFamInstEnvs getInstEnvsgetEnvs tcLookupIdtcLookuptcLookupGlobal tcLookupClasstcLookupDataCon tcLookupTyCon lookupOrigfindImportedModule resolveImportpkgQualToPkgName mkInvisFunTys mkInvisFunTy tcPluginTrace tcPluginIOOneTyManyTyPkgQualGHC.TcPlugin.API.InternalmkTcPluginErrorTy mkTcPlugin askRewriteEnv askDeriveds askEvBinds TcPluginStageRewriteSolveStopInitTcPluginSolverTcPluginRewriterTcPlugintcPluginRewrite tcPluginStop tcPluginSolve tcPluginInit TcPluginM MonadTcPluginMonadTcPluginWorkTcPluginErrorMessage:-::|:Txt PrintTypeGHC.TcPlugin.API.Internal.Shim RewriteEnvTcPluginSolveResultTcPluginContradiction TcPluginOkTcPluginRewriteResulttcRewriterNewWantedstcPluginReductionTcPluginNoRewriteTcPluginRewriteTo(GHC.TcPlugin.API.Internal.Shim.Reduction ReductionreductionReducedTypereductionCoercionisCanonicalVarEq getModule FieldNamefromFastString$fIsStringFieldNameGHC.ShowShow fieldNameHashfieldNameLabel ResolvedNames clsAllFieldsclsKnownFields clsKnownHashclsRowHasField clsSubRowdataConDictAnyidEvidenceAllFieldsidEvidenceKnownFieldsidEvidenceKnownHashidEvidenceRowHasFieldidEvidenceSubRowidUnsafeCoerce tyConDictAny tyConMergetyConFieldTypes tyConPairtyConSimpleFieldTypesnameResolution KnownFieldtoExprtoTypeknownFieldNameknownFieldInfo Classified TyConSubstclassifiedProductiveclassifiedExtendEquivClassclassifiedReconsiderprocess tyConSubstMaptyConSubstCanontyConSubstEmptytyConSubstLookuptyConSubstExtendclassify mkTyConSubstsplitTyConApp_upTotryApplyParseOk ParseNoMatch ParseErrorparseAll parseAll'withOrigparseConstraintparseConstraint' parseConsparseNilparseInjTyConApp ParseResult CKnownHashknownHashLabel knownHashTypeparseKnownHashsolveKnownHash alterExisting GHC.MaybeNothing$fFunctorSmallHashMapGHC.BaseFunctorcontainers-0.6.5.1Data.Map.InternalMap SmallHashMapnulllookupmemberalter NotSubRowTargetContainsShadowedFieldsSourceMissesFieldsKnownRowknownRecordVectorknownRecordVisibleknownRecordAllVisibleghc-prim GHC.TypesFalseisSubRowfromList visibleMaptraverseindexedallKnown parsePair FieldLabel FieldKnownFieldVarFields parseFieldsparseFieldLabel CRowHasField hasFieldLabelhasFieldRecordhasFieldTypeKindhasFieldTypeLabelhasFieldTypeRowhasFieldTypeFieldevidenceHasFieldparseRowHasFieldsolveRowHasField argsFunctorargsParsedFieldsargsParsedKnownrewriteCSubRowsubrowParsedLHSsubrowParsedRHS subrowTypeLHS subrowTypeRHSsubrowTypeKind parseSubRow solveSubRow CKnownFieldsknownFieldsParsedFieldsknownFieldsTypeRecordknownFieldsTypeKindevidenceKnownFieldsparseKnownFieldssolveKnownFields CAllFieldsallFieldsParsedFieldsallFieldsTypeFieldsallFieldsTypeConstraintallFieldsTypeKindevidenceAllFieldsparseAllFieldssolveAllFieldssolveplugin StrictArray'primitive-0.7.4.0-5Mou7sRsTgfjuEOfjOZOzData.Primitive.SmallArray SmallArray! fromListNfromLazytoLazy//update backpermute Canonical getAtIndex setAtIndextoVector fromVectorapplydiffUpddiffInsdiffNew allNewFields++GHC.PrimseqGHC.Listfilter System.IOprint Data.Tuplefstsnd otherwise$GHC.Real fromIntegral realToFracGHC.EnumBoundedminBoundmaxBoundEnumsuccpredtoEnumfromEnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.ClassesEq==/= GHC.FloatFloatingtanhtansqrtsinhsinpilogBaselogexpcoshcosatanhatanasinhasinacosh**acos Fractionalrecip fromRational/IntegralremquotRemquotmoddivMod toIntegerdivMonad>>=return>>fmap<$GHC.NumNumsignumabs*+negate fromInteger-Ord<<=>maxmin>=compareGHC.ReadReadreadList readsPrecReal toRational RealFloat significand scaleFloatisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloatatan2 decodeFloatRealFractruncateroundproperFractionceilingfloorshowListshow showsPrecControl.Monad.Fail MonadFailfail Applicative<**><*>FoldablefoldMapsumproductminimummaximumfoldr1foldl1elemlengthfoldlfoldrData.Traversable Traversablesequence SemigroupMonoidmemptymconcatmappendBoolTrueStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerIntegerMaybeJustOrderingGTLTEQRationalIOWord Data.EitherEitherLeftRight Data.Functor<$>const.id Text.Readread writeFilereadLnreadIOreadFileputStrLnputStrputCharinteractgetLine getContentsgetChar appendFileGHC.IO.ExceptionioErrorGHC.IOFilePathIOError userError sequence_ornotElemmapM_ concatMapconcatanyandall Data.OldListwordsunwordsunlineslinesreadseither readParenlexText.ParserCombinators.ReadPReadSoddlcmgcdeven^^^ShowSshows showString showParenshowCharzipWith3zip3unzip3unzip takeWhiletaketailsplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatlastiterateinithead dropWhiledropcyclebreak!! Data.MaybemaybeuncurrycurrysubtractuntilflipasTypeOf=<<$!GHC.Err undefinederrorWithoutStackTraceerror&&not|| DictSubRow fieldDictsprojectIndicesDictAny DictAllFieldsDictKnownFields fieldNamesDictRowHasField rowHasFieldevidenceRowHasField fieldMetadataevidenceKnownHashevidenceSubRownoInlineUnsafeCoreflectRowHasFieldIsLabel toCanonicalunsafeFromCanonical mkFieldNameunsafeGetFieldunsafeSetFieldRecordConstraints