h*,|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop qrstuvwxyz{|}~                                                    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""#################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % % % % % % % % % % % % % % % & & & & & & ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *****************************************+++++++++++++++++++++++++++++++++,,,,,,-.........//00000011111111111111111111111111122222222333333333344444445556777777788899::::::9;999:;;:<====== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????@@@@@AAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFGGGGGGGGHIIIIIIIJJJJJJJJJKKKKKKKKKKKKKLLLLLLLLLMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQRRRRRRRRRRRRSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVWWWWWWWWWWXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_________________`````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhiiiiiiiiijjjjjjjjjkkkkkkkkllllllllllllllllllllllllllllllllllllllllllll))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))mmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrs s s s s s s s s s s s s t t t t t t t t t t t t u u u u v v v v v v v v v v v v w w x x x x x x                                                                                !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#z#z#z#z#z#z#z#z#z#z#z#z#z#z#z#z#z#z#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#{#:#:#{#{#{#{#{#{#{#{${${$y$y$y$y$($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($($(%(%(%(%(%(%(%(%(%(%(%|%|%|%|%|%|%|%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%}%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%~%~%2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&2&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3&3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3'3':':':':':':':':':':':':':':':':':':':':'''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------................................................................................................................................////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> > > > > > > > > > > > > > > > > > > > > > > > > > > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@9@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7@7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7A7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7B7BBBBBBBB=;D9IL=;D9IL n)ghc '(lengthAtLeast xs n) = (length xs >= n)ghc "(lengthIs xs n) = (length xs == n)ghc %(lengthIsNot xs n) = (length xs /= n)ghc &(lengthAtMost xs n) = (length xs <= n)ghc ((lengthLessThan xs n) == (length xs < n)ghcTrue if length xs == length ysghcTrue if length xs <= length ysghcTrue if length xs < length ysghc=Utility function to go from a singleton list to it's element.Wether or not the argument is a singleton list is only checked in debug builds.ghcExtract the single element of a list and panic with the given message if there are more elements or the list was empty. Like  expectJust, but for lists.ghcSplit a list into chunks of n elementsghc>Compute all the ways of removing a single element from a list. 4holes [1,2,3] = [(1, [2,3]), (2, [1,3]), (3, [1,2])]ghc8Replace the last element of a list with another element.ghc5Apply an effectful function to the last list element.ghc4Merge an unsorted list of sorted lists, for example: mergeListsBy compare [ [2,5,15], [1,10,100] ] = [1,2,5,10,15,100] O(n \log{} k) ghc=Remove duplicates but keep elements in order. O(n * log n)ghc=Remove duplicates but keep elements in order. O(n * log n)ghc;Given two lists xs and ys, return `splitAt (length xs) ys`.ghcdrop from the end of a listghc+spanEnd p l == reverse (span p (reverse l)). The first list returns actually comes after the second list (when you look at the input list).ghc$Get the last two elements in a list.ghc onJust x m f? applies f to the value inside the Just or returns the default.ghcSplit a list into its last element and the initial part of the list. %snocView xs = Just (init xs, last xs) for non-empty lists. snocView xs = Nothing otherwise. Unless both parts of the result are guaranteed to be used prefer separate calls to last + init. If you are guaranteed to use both, this will be more efficient.ghc=Convert a word to title case by capitalising the first letterghcFind the "restricted" Damerau-Levenshtein edit distance between two strings. See:  9http://en.wikipedia.org/wiki/Damerau-Levenshtein_distance. Based on the algorithm presented in "A Bit-Vector Algorithm for Computing Levenshtein and Damerau Edit Distances" in PSC'02 (Heikki Hyyro). See  *http://www.cs.uta.fi/~helmu/pubs/psc02.pdf and  ,http://www.cs.uta.fi/~helmu/pubs/PSCerr.html for an explanationghcSearch for possible matches to the users input in the given list, returning a small number of ranked resultsghc*Determine the $log_2$ of exact powers of 2ghcParse a string into a significand and exponent. A trivial example might be: ghci> readSignificandExponentPair "1E2" (1,2) In a more complex case we might return a exponent different than that which the user wrote. This is needed in order to use a Integer significand. ghci> readSignificandExponentPair "-1.11E5" (-111,3)ghcParse a string into a significand and exponent according to the "Hexadecimal Floats in Haskell" proposal. A trivial example might be: ghci> readHexSignificandExponentPair "0x1p+1" (1,1) Behaves similar to readSignificandExponentPair but the base is 16 and numbers are given in hexadecimal: ghci> readHexSignificandExponentPair "0xAp-4" (10,-4) ghci> readHexSignificandExponentPair "0x1.2p3" (18,-1)ghcA sample hash function for Strings. We keep multiplying by the golden ratio and adding. The implementation is: hashString = foldl' f golden where f m c = fromIntegral (ord c) * magic + hashInt32 m magic = 0xdeadbeef2Where hashInt32 works just as hashInt shown above.Knuth argues that repeated multiplication by the golden ratio will minimize gaps in the hash space, and thus it's a good choice for combining together multiple keys to form one.Here we know that individual characters c are often small, and this produces frequent collisions if we use ord c alone. A particular problem are the shorter low ASCII and ISO-8859-1 character strings. We pre-multiply by a magic twiddle factor to obtain a good distribution. In fact, given the following test: testp :: Int32 -> Int testp k = (n - ) . length . group . sort . map hs . take n $ ls where ls = [] : [c : l | l <- ls, c <- ['\0'..'\xff']] hs = foldl' f golden f m c = fromIntegral (ord c) * k + hashInt32 m n = 100000!We discover that testp magic = 0.ghcA sample (and useful) hash function for Int32, implemented by extracting the uppermost 32 bits of the 64-bit result of multiplying by a 33-bit constant. The constant is from Knuth, derived from the golden ratio: $golden = round ((sqrt 5 - 1) * 2^32)We get good key uniqueness on small inputs (a problem with previous versions): (length $ group $ sort $ map hashInt32 [-32767..65536]) == 65536 + 32768{]{]32 Safe-Inferred 7ghcA 5 is a pointer to some array of Latin-1 encoded chars.ghcLexical FastStringThis is a simple FastString wrapper with an Ord instance using  (i.e. which compares FastStrings on their String representation). Hence it is deterministic from one run to the other.ghcNon-deterministic FastStringThis is a simple FastString wrapper with an Ord instance using  (i.e. which compares FastStrings on their Uniques). Hence it is not deterministic from one run to the other.ghcA : is a UTF-8 encoded string together with a unique ID. All s are stored in a global hashtable to support fast O(1) comparison.It is also associated with a lazy reference to the Z-encoding of this string which is used by the compiler internally.ghcLazily computed Z-encoding of this string. See Note [Z-Encoding] in GHC.Utils.Encoding.Since s are globally memoized this is computed at most once for any given string.ghc:Gives the Modified UTF-8 encoded bytes corresponding to a ghc:Gives the Modified UTF-8 encoded bytes corresponding to a ghczStringTakeN n =  n .  but is performed in  O(\min(n,l)) rather than O(l) , where l is the length of the .ghcCompare FastString lexically2If you don't care about the lexical ordering, use  instead.ghc3Compare FastString by their Unique (not lexically).Much cheaper than  but non-deterministic!ghc Create a  by copying an existing ghc Create a  from an existing  without copying.ghcCreates a UTF-8 encoded  from a :ghc Creates a  from a UTF-8 encoded [Word8]ghcCreates a (lazy) Z-encoded  from a = and account the number of forced z-strings into the passed .ghcReturns the length of the  in charactersghcReturns True if the  is emptyghc)Lazily unpacks and decodes the FastStringghc!Returns a Z-encoded version of a . This might be the original, if it was already Z-encoded. The first time this function is applied to a particular , the results are memoized.ghc Outputs a  with no decoding at all,, that is, you get the actual bytes in the  written to the .ghcWrap an unboxed address into a .ghc Decode a  back into a : using Latin-1 encoding. This does not free the memory associated with .ghcunpackPtrStringTakeN n =  n .  but is performed in  O(\min(n,l)) rather than O(l) , where l is the length of the .ghcReturn the length of a 00  Safe-InferredghcReplicate an 8-bit character  !"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)!David Terei stableportable Safe-Inferred -ghcRendering mode.ghcNormalghcWith zig-zag cutsghc%No indentation, infinitely long linesghcAll on one lineghcA rendering style.ghcThe rendering modeghcLength of line, in charsghc%Ratio of line length to ribbon lengthghcThe TextDetails data typeA TextDetails represents a fragment of text that will be output at some point.ghcA single Char fragmentghcA whole String fragmentghcRDoc is a "reduced GDoc", guaranteed not to have a top-level Above or Beside.ghcThe abstract type of documents. A Doc represents a *set* of layouts. A Doc with no occurrences of Union or NoDoc represents just one layout.ghcA document of height and width 1, containing a literal character.ghc5A document of height 1 containing a literal string.  satisfies the following laws:  s   t =  (st) ""  x = x, if x non-empty8The side condition on the last law is necessary because  "" has height 1, while  has no height.ghcSome text with any width. (text s = sizedText (length s) s)ghcSome text, but without any width. Use for non-printing text such as a HTML or Latex tagsghc*Empty text (one line high but no width). (emptyText = text "")ghc2The empty document, with no height and no width.  is the identity for , ,  and ), and anywhere in the argument list for , , , ,  etc.ghcReturns L if the document is emptyghcGet the first character of a document. We also return a new document, equivalent to the original one but faster to render. Use it to avoid work duplication.ghcApply  to  if boolean is true.ghc*Perform some simplification of a built up GDoc.ghcList version of .ghcList version of .ghcList version of .ghcNest (or indent) a document by a given number of positions (which may also be negative).  satisfies the laws:  0 x = x  k ( k' x) =  (k+k') x  k (x  y) =  k z   k y  k (x  y) =  k x   k y  k  = x   k y = x  y, if x non-empty6The side condition on the last law is needed because  is a left identity for .ghc "hang d1 n d2 = sep [d1, nest n d2]ghcApply  to the arguments if the first  is not empty.ghc punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn]ghcAbove, except that if the last line of the first argument stops at least one position before the first line of the second begins, these two lines are overlapped. For example: % text "hi" $$ nest 5 (text "there") lays out as  hi there rather than  hi there is associative, with identity , and also satisfies(x  y)  z = x  (y  z), if y non-empty.ghcAbove, with no overlapping.  is associative, with identity .ghc Beside.  is associative, with identity .ghc;Beside, separated by space, unless one of the arguments is .  is associative, with identity .ghcEither  or .ghcEither  or .ghc"Paragraph fill" version of .ghc"Paragraph fill" version of .ghcfirst returns its first argument if it is non-empty, otherwise its second.ghcThe default style (7mode=PageMode False, lineLength=100, ribbonsPerLine=1.5).ghcCan we output an ascii space character for spaces? Mostly true, but not for e.g. UTF16 See Note [putSpaces optimizations] for why we bother to track this.ghc Render the Doc to a String using the given Style.ghcDefault TextDetails printerghc The general rendering interface.ghcA ';' characterghcA ',' characterghcA : characterghcA space characterghcA '=' characterghcA '(' characterghcA ')' characterghcA '[' characterghcA ']' characterghcA '{' characterghcA '}' characterghc int n = text (show n)ghc integer n = text (show n)ghc float n = text (show n)ghc double n = text (show n)ghc rational n = text (show n)ghc%See Note [Print Hexadecimal Literals]ghcWrap document in `...'ghcWrap document in '...'ghcWrap document in "..."ghcWrap document in (...)ghcWrap document in [...]ghcWrap document in {...}ghcRendering modeghc Line lengthghcRibbons per lineghcWhat to do with textghcWhat to do at the endghc The documentghcResult5566" Safe-Inferred3ghcA colour/style for use with coloured.ghc;Parse the colour scheme from a string (presumably from the  GHC_COLORS environment variable).ghcAllow colours to be combined (e.g. bold + red); In case of conflict, right side takes precedence.# Safe-Inferred7 ghcSource Unpackedness$What unpackedness the user requestedghc{-# UNPACK #-} specifiedghc{-# NOUNPACK #-} specifiedghcno unpack pragmaghcSource Strictness)What strictness annotation the user wroteghc Lazy, ie ~ghc Strict, ie !ghcno strictness annotationghc%See Note [Roles] in GHC.Core.CoercionOrder of constructors matters: the Ord instance coincides with the *super*typing relation on roles.ghcField labels are just represented as strings; they are not necessarily unique (even within a module)ghcA *one-index* constructor tagType of the tags associated with each constructor possibility or superclass selectorghcThe width of an unboxed sum$ Safe-Inferred )*/17O ghcSee Note [NoGhcTc] in GHC.Hs.Extension. It has to be in this module because it is used like an extension point (in the data definitions of types that should be parameter-agnostic. ghc*Maps the "normal" id type for a given pass ghcThe trivial wrapper that carries no additional information See Note [XRec and SrcSpans in the AST] ghc4We can map over the underlying type contained in an XRec( while preserving the annotation as is. ghcWe can strip off the XRec to access the underlying data. See Note [XRec and SrcSpans in the AST] ghcGHC's L prefixed variants wrap their vanilla variant in this type family, to add SrcLoc info via Located. Other passes than GhcPass= not interested in location information can define this as "type instance XRec NoLocated a = a*. See Note [XRec and SrcSpans in the AST] ghcA placeholder type for TTG extension points that are not currently unused to represent any particular value.!This should not be confused with  ', which are found in unused extension  constructors8 and therefore should never be inhabited. In contrast,   is used in extension points (e.g., as the field of some constructor), so it must have an inhabitant to construct AST passes that manipulate fields with that extension point as their type. ghc=Used when constructing a term with an unused extension point. ghc Eliminate a  &. See Note [Constructor cannot occur].  % Safe-Inferred ghc2A ModuleName is essentially a simple string, e.g.  Data.List. ghc6Compares module names lexically, rather than by their Uniques ghcReturns the string version of the module name, with dots replaced by slashes. ghcReturns the string version of the module name, with dots replaced by colons. * Safe-Inferred 6D ghcA class of types that represent a multiline document, with support for vertical composition.See Note [HLine versus HDoc] and Note [The outputable class hierarchy] for more details. ghc Join two docs together vertically. If there is no vertical overlap it "dovetails" the two onto one line. ghc Concatenate docs vertically with dovetailing. ghcPrints as either the given   or the given  , depending on which type the result is instantiated to. This should generally be avoided; see Note [dualLine and dualDoc] for details. ghcA class of types that represent a single logical line of text, with support for horizontal composition.See Note [HLine versus HDoc] and Note [The outputable class hierarchy] for more details. ghc Join two doc&s together horizontally without a gap. ghc Join two doc0s together horizontally with a gap between them. ghcSeparate: is either like   or like  , depending on what fits. ghc,A paragraph-fill combinator. It's much like  , only it keeps fitting things on one line until it can't fit any more. ghc Concatenate docs horizontally without gaps. ghc Concatenate doc-s horizontally with a space between each one. ghcPrints as either the given   or the given  , depending on which type the result is instantiated to. This should generally be avoided; see Note [dualLine and dualDoc] for details. ghcA superclass for   and   that provides an identity,  #, as well as access to the shared  .;See Note [The outputable class hierarchy] for more details. ghcRepresents a (possibly empty) sequence of lines that can be efficiently printed directly to a  (actually a ). See Note [SDoc versus HDoc] and Note [HLine versus HDoc] for more details. ghcRepresents a single line of output that can be efficiently printed directly to a  (actually a ). See Note [SDoc versus HDoc] and Note [HLine versus HDoc] for more details. ghcWhen we print a binder, we often want to print its type too. The OutputableBndr class encapsulates this idea. ghc  is used to tell the thing that prints binder what language construct is binding the identifier. This can be used to decide how much info to print. Also see Note [Binding-site specific printing] in  GHC.Core.Ppr ghcThe x in (x. e) ghc+The x in case scrut of x { (y,z) -> ... } ghc+The y,z in case scrut of x { (y,z) -> ... } ghcThe x in (let x = rhs in e) ghcWrapper for types having a Outputable instance when an OutputableP instance is required. ghc5Outputable class with an additional environment value See Note [The OutputableP class] ghc(Class designating that some type has an   representation ghc stop ghcUse   field as depth ghc!Print code; either C or assembler ghc$NB: This won't ever show package IDs ghcDefault style for error messages, when we don't know NamePprCtx It's a bit of a hack because it doesn't take into account what's in scope Only used for desugarer warnings, and typechecker errors in interface sigs ghc!Style for printing error messages ghcDefault pretty-printing options ghc6Truncate a list that is longer than the current depth. ghc'Indicate if -dppr-debug mode is enabled ghc,Says what to do with and without -dppr-debug ghc7Says what to do with -dppr-debug; without, return empty ghcThe analog of  for  , which tries to make sure the terminal doesn't get screwed up by the ANSI color codes if an exception is thrown during pretty-printing. ghcLike   but appends an extra newline. ghcAn efficient variant of   specialized for  that outputs to a . ghcdoublePrec p n shows a floating point number n with p. digits of precision after the decimal point. ghcIndent   some specified amount ghc Join two   together vertically ghcA paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more. ghcThis behaves like  , but it uses  ( for horizontal composition rather than  ghcThis behaves like  , but does not indent the second document when the header is empty. ghc.Apply the given colour/style for the argument.)Only takes effect if colours are enabled. ghc2Special combinator for showing character literals. ghc/Special combinator for showing string literals. ghc3Special combinator for showing bytestring literals. ghc0Special combinator for showing unboxed literals. ghc9Normalise, escape and render a string representing a pathe.g. "c:\whatever" ghcReturns the separated concatenation of the pretty printed things. ghcReturns the comma-separated concatenation of the pretty printed things. ghcReturns the comma-separated concatenation of the quoted pretty printed things. ,y,z] ==> `x', `y', `z' ghc&Converts an integer to a verbal index: speakNth 1 = text "first" speakNth 5 = text "fifth" speakNth 21 = text "21st" ghc-Converts an integer to a verbal multiplicity: speakN 0 = text "none" speakN 5 = text "five" speakN 10 = text "10" ghcConverts an integer and object description to a statement about the multiplicity of those objects: speakNOf 0 (text "melon") = text "no melons" speakNOf 1 (text "melon") = text "one melon" speakNOf 3 (text "melon") = text "three melons" ghcDetermines the pluralisation suffix appropriate for the length of a list: plural [] = char 's' plural ["Hello"] = empty plural ["Hello", "World"] = char 's' ghcDetermines the singular verb suffix appropriate for the length of a list: singular [] = empty singular["Hello"] = char 's' singular ["Hello", "World"] = empty ghcDetermines the form of to be appropriate for the length of a list: isOrAre [] = text "are" isOrAre ["Hello"] = text "is" isOrAre ["Hello", "World"] = text "are" ghcDetermines the form of to do appropriate for the length of a list: doOrDoes [] = text "do" doOrDoes ["Hello"] = text "does" doOrDoes ["Hello", "World"] = text "do" ghcDetermines the form of possessive appropriate for the length of a list: itsOrTheir [x] = text "its" itsOrTheir [x,y] = text "their" itsOrTheir [] = text "their" -- probably avoid this ghcDetermines the form of subject appropriate for the length of a list: thisOrThese [x] = text "This" thisOrThese [x,y] = text "These" thisOrThese [] = text "These" -- probably avoid this ghc"has" or "have"# depending on the length of a list. ghc The headerghcAmount to indent the hung bodyghc3The hung body, indented and placed below the header ghcThe punctuationghcThe list that will have punctuation added between every adjacent pair of elementsghcPunctuated list ghc#The pretty printing function to useghcThe things to be pretty printedghc  where the things have been pretty printed, comma-separated and finally packed into a paragraph. ghc#The pretty printing function to useghcThe things to be pretty printedghc  where the things have been pretty printed, bar-separated and finally packed into a paragraph.  + Safe-InferredPghc=GHC's own exception type error messages all take the form:  : If the location is on the command line, or in GHC itself, then ="ghc". All of the error types below correspond to a of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).ghc(Some other fatal signal (SIGHUP,SIGTERM)ghc*Prints the short usage msg after the errorghcA problem with the command line arguments, but don't print usage.ghcThe  impossible happened.ghcThe user tickled something that's known not to work yet, but we're not counting it as a bug.ghcAn installation problem.ghc&An error in the user's code, probably.ghcShow an exception as a string.ghcShow an exception which can possibly throw other exceptions. Used when displaying exception thrown within TH code.ghc;Append a description of the given exception to this string.Note that this uses  >, which doesn't use the options set by the user via DynFlags.ghc;Append a description of the given exception to this string.ghc7Throw an exception saying "bug in GHC" with a callstackghc&Throw an exception saying "bug in GHC"ghc3Throw an exception saying "this isn't finished yet"ghcThrow an exception saying "bug in pgm being compiled" (used for unusual program errors)ghcLike try, but pass through UserInterrupt and Panic exceptions. Used when we want soft failures when reading interface files, for example. TODO: I'm not entirely sure if this is catching what we really want to catchghc-We use reference counting for signal handlersghcTemporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.ghcPanic with an assertion failure, recording the given file and line number. Should typically be accessed with the ASSERT family of macros++ Safe-InferredTghc!If debug output is on, show some   on the screenghcpprTraceWith desc f x is equivalent to pprTrace desc (f x) x. This allows you to print details from the returned value as well as from ambient variables.ghcpprTraceIt desc x is equivalent to pprTrace desc (ppr x) xghcpprTraceException desc x action< runs action, printing a message if it throws an exception.ghc!If debug output is on, show some  7 on the screen along with a call stack when available.ghcJust warn about an assertion failure, recording the given file and line number.ghcFor when we want to show the user a non-fatal WARNING so that they can report a GHC bug, but don't want to panic.   Safe-InferredU>=;D9IL or C. This choice must be recorded in order to exactprint such tokens, so instead of  HsToken "->" we introduce HsUniToken "->" "C". See also IsUnicodeSyntax in GHC.Parser.Annotation,; we do not use here to avoid a dependency.ghcA token stored in the syntax tree. For example, when parsing a let-expression, we store  HsToken "let" and  HsToken "in". The locations of those tokens can be used to faithfully reproduce (exactprint) the original program text.ghc.Layout column (indentation level, begins at 1)  K Safe-Inferred ]*ghc+A state monad which is strict in the state s, but lazy in the value a.See Note [Strict State monad] for the particular notion of strictness and implementation details.ghcForces the state component of the unboxed representation pair of . See Note [Strict State monad]. This is The Place doing the forcing!   Safe-Inferred`ghcmapAndUnzipM for triplesghcMonadic version of mapAccumLghcMonadic version of mapSndghcMonadic version of concatMapghcApplicative version of mapMaybeghcMonadic version of &, aborts the computation at the first True valueghcMonad version of &, aborts the computation at the first False valueghcMonadic version of orghcMonadic version of andghc1Monadic version of foldl that discards its resultghcMonadic version of when#, taking the condition in the monadghcMonadic version of unless#, taking the condition in the monadghcLike ), only it reverses the sense of the test.ghcMonadic version of  partitionghccombining functionghc initial stateghcinputsghcfinal state, outputs!4 !"ef2!4 !"ef2A Safe-Inferrede ghc$Is this an acceptable variable name?ghc'Is this an acceptable constructor name?ghc Is this an acceptable type name?ghcIs this an acceptable alphanumeric variable name, assuming it starts with an acceptable letter?ghcIs this an acceptable symbolic variable name, assuming it starts with an acceptable character?ghcIs this an acceptable alphanumeric constructor name, assuming it starts with an acceptable letter?ghcIs this an acceptable symbolic constructor name, assuming it starts with an acceptable character?ghcIs this string an acceptable id, possibly with a suffix of hashes, but not worrying about case or clashing with reserved words?ghcIs this character acceptable in an identifier (after the first letter)? See alexGetByte in GHC.Parser.LexerghcAll reserved identifiers. Taken from section 2.4 of the 2010 Report.ghcAll reserved operators. Taken from section 2.4 of the 2010 Report.ghcDoes this string contain only dashes and has at least 2 of them?F Safe-InferredgghcWhen invoking external tools as part of the compilation pipeline, we pass these a sequence of options on the command-line. Rather than just using a list of Strings, we use a type that allows us to distinguish between filepaths and 'other stuff'. The reason for this is that this type gives us a handle on transforming filenames, and filenames only, to whatever format they're expected to be on a particular platform.G Safe-Inferredi0ghc-What kind of {-# SCC #-} to add automaticallyghcno SCC annotations addedghc,top-level and nested functions are annotatedghc"top-level functions annotated onlyghc!exported functions annotated onlyghcannotate call-sitesL Safe-InferredjghcThis is used to signal if one of my imports used HPC instrumentation even if there is no module-local HPC usageghc;Information about a modules use of Haskell Program Coverageghc*Is hpc used anywhere on the module *tree*?ghcFind out if HPC is used by this module or any of the modules it depends upon  H Safe-InferredkghcDoes the controlling terminal support ANSI color sequences? This memoized to avoid thread-safety issues in ncurses (see #17922).ghcCheck if ANSI escape sequences can be used to control color in stderr. Safe-Inferred "o ghc File name.ghcFile modification time.ghc File owner.ghc File group.ghc File mode.ghc File size.ghc File bytes.ghcghc Stream m a b is a computation in some Monad m/ that delivers a sequence of elements of type a followed by a result of type b.!More concretely, a value of type  Stream m a b can be run using runStreamInternal in the Monad m, and it delivers eitherthe final result: Done b, or Yield a str where a( is the next element in the stream, and str is the rest of the stream Effect mstr where mstr is some action running in m* which generates the rest of the stream.4Stream is itself a Monad, and provides an operation  that produces a new element of the stream. This makes it convenient to turn existing monadic computations into streams.The idea is that Stream is useful for making a monadic computation that produces values from time to time. This can be used for knitting together two complex monadic operations, so that the producer does not have to produce all its values before the consumer starts consuming them. We make the producer into a Stream, and the consumer pulls on the stream each time it wants a new value. is implemented in the "yoneda" style for efficiency. By representing a stream in this manner  and  operations are accumulated in the function parameters before being applied once when the stream is destroyed. In the old implementation each usage of  and  would traverse the entire stream in order to apply the substitution at the leaves.The >>= operation for . was a hot-spot in the ticky profile for the ManyConstructors test which called the cg function many times in  StgToCmm.hsghcTurn a Stream into an ordinary list, by demanding all the elements.ghcTurn a list into a #, by yielding each element in turn.ghc&Apply a function to each element of a , lazilyghc/Apply a monadic operation to each element of a , lazilyghcNote this is not very efficient because it traverses the whole stream before rebuilding it, avoid using it if you can. mapAccumL used to implemented but it wasn't used anywhere in the compiler and has similar efficiency problems.M Safe-Inferred -%ghc+Copy and freeze a slice of a mutable array.ghc!Freeze a mutable array (no copy!)ghc)Index a small-array (no bounds checking!)ghcConvert a list into an array.ghcsizeghcinitial contentsghcarrayghcindexghc new elementghcsourceghcoffsetghclengthghcarrayghcindex   Safe-Inferred /9=ghcTakes a list of Maybes and returns the first Just if there is one, or Nothing otherwise.ghcTakes computations returnings Maybes6; tries each one in order. The first one to return a Just wins. Returns Nothing if all computations return Nothing.ghcFlipped version of  fromMaybe, useful for chaining.ghcTry performing an D action, failing on error.@JKv4@ Safe-Inferred Safe-InferredAʟghcmaybeFlipCond c returns Just c'= if it is possible to flip the arguments to the conditional c", and the new condition should be c'.˟ghc If we apply maybeInvertCond to the condition of a jump we turn jumps taken into jumps not taken and vice versa.Careful! If the used comparison and the conditional jump don't match the above behaviour will NOT hold. When used for FP comparisons this does not consider unordered numbers. Also inverting twice might return a synonym for the original condition.ŸßğşƟǟȟɟʟ˟ŸßğşƟǟȟɟʟ˟(c) Matt Morrow 2009BSD3stableportable Safe-Inferred 9 ҟghc Dominators. Complexity as for idomӟghcPost-dominators. Complexity as for idom.ԟghcDominator tree. Complexity as for idom.՟ghcPost-dominator tree. Complexity as for idom.֟ghcImmediate dominators. O(|E|*alpha(|E|,|V|)), where  alpha(m,n)4 is "a functional inverse of Ackermann's function".This Complexity bound assumes O(1) indexing. Since we're using IntMap, it has an additional lg |V|0 factor somewhere in there. I'm not sure where.ןghcImmediate post-dominators. Complexity as for idom.؟ghc!Post-dominated depth-first search.ٟghc)Reverse post-dominated depth-first search.ghc arr .= x idx => write x to indexghcrenum n g: Rename all nodesGives nodes sequential names starting at n. Returns the new graph and a mapping. (renamed, old -> new)џПϟΟ֟͟ןԟ՟ҟӟ؟ٟڟ۟ܟݟޟߟџПϟΟ֟͟ןԟ՟ҟӟ؟ٟڟ۟ܟݟޟߟ29  Safe-InferredE Safe-Inferred 9:;h::P Safe-Inferred)*0169 ghc2A sequence of nodes. May be any of four shapes (OO, OC, CO, CC). Open at the entry means single entry, mutatis mutandis for exit. A closedclosed block is a basic/ block and can't be extended further. Clients should avoid manipulating blocks and should stick to either nodes or graphs.ghc!Maybe type indexed by open/closedghc6Either type indexed by closed/open using type familiesghcUsed at the type level to indicate "open" vs "closed" structure.ghcAn "open" structure with a unique, unnamed control-flow edge flowing in or out. "Fallthrough" and concatenation are permitted at an open point.ghcA "closed" structure which supports control transfer only through the use of named labels---no "fallthrough" is permitted. The number of control-flow edges is unconstrained.ghcSplit a closed block into its entry node, open middle block, and exit node.ghc#map a function over the nodes of a ghc A strict ghcmap over a block, with different functions to apply to first nodes, middle nodes and last nodes respectively. The map is strict.ghcFold a function over every node in a block, forward or backward. The fold function must be polymorphic in the shape of the nodes.** Safe-Inferred-ghcExpand occurrences of the $tooldir interpolation in a string on Windows, leave the string untouched otherwise.ghc.Returns a Unix-format path pointing to TopDir.ghc*whether we use the ambient mingw toolchainghctooldirghc,Maybe TopDir path (without the '-B' prefix).ghcTopDir (in Unix format  separated)ghc*whether we use the ambient mingw toolchainghctopdir Safe-InferredghcThe predicates below look costly, but aren't, GHC+GCC do a great job at the big case below. Safe-InferredKghcOrdGr comes equipped with an Ord instance, so that graphs can be used as e.g. Map keys.ghc Merge the  into the .Context adjacencies should only refer to either a Node already in a graph or the node in the Context itself (for loops).(Behaviour is undefined if the specified  already exists in the graph.ghcMinimum implementation: , , , , ghc An empty .ghcTrue if the given  is empty.ghc Decompose a  into the - found for the given node and the remaining .ghc Create a  from the list of s and s.&For graphs that are also instances of , mkGraph ns es should be equivalent to ( es .  ns) .ghcA list of all  s in the .ghcDecompose a graph into the  for an arbitrarily-chosen  and the remaining .ghcThe number of s in a .ghcThe minimum and maximum  in a .ghcA list of all  s in the .ghcUnlabeled decomposition.ghcUnlabeled context.ghc The same as , only more sure of itself.ghc, decomposition - the context removed from a , and the rest of the .ghc Links to the , the ! itself, a label, links from the .In other words, this captures all information regarding the specified  within a graph.ghcLabeled links to or from a .ghcQuasi-unlabeled pathghc Labeled pathghcUnlabeled pathghcQuasi-unlabeled edgeghc Labeled edgeghcUnlabeled edgeghcQuasi-unlabeled nodeghc Labeled nodeghcUnlabeled nodeghc0The number of nodes in the graph. An alias for .ghc!The number of edges in the graph.Note that this counts every edge found, so if you are representing an unordered graph by having each edge mirrored this will be incorrect.If you created an unordered graph by either mirroring every edge (including loops!) or using the undir function in Data.Graph.Inductive.Basic9 then you can safely halve the value returned by this.ghc6Fold a function over the graph by recursively calling .ghc5Map a function over the graph by recursively calling .ghcMap a function over the  labels in a graph.ghcMap a function over the  labels in a graph.ghcMap functions over both the  and  labels in a graph.ghc List all  s in the .ghc List all  s in the .ghc$Drop the label component of an edge.ghcAdd a label to an edge.ghcThe label in an edge.ghcList N available s, i.e. s that are not used in the .ghcL if the  is present in the .ghc Insert a  into the .ghc Insert a  into the .ghc Remove a  from the .ghc Remove an  from the .6NOTE: in the case of multiple edges, this will delete all such edges from the graph as there is no way to distinguish between them. If you need to delete only a single such edge, please use .ghc Remove an  from the .NOTE: in the case of multiple edges with the same label, this will only delete the first5 such edge. To delete all such edges, please use  delAllLedge.ghc,Remove all edges equal to the one specified.ghcInsert multiple  s into the .ghcInsert multiple  s into the . ghcRemove multiple  s from the .àghcRemove multiple  s from the .ĠghcBuild a  from a list of s.2The list should be in the order such that earlier 1s depend upon later ones (i.e. as produced by  (:) []).ŠghcBuild a quasi-unlabeled .ƠghcBuild a graph out of the contexts for which the predicate is satisfied by recursively calling .ǠghcReturns the subgraph only containing the labelled nodes which satisfy the given predicate.ȠghcReturns the subgraph only containing the nodes which satisfy the given predicate.ɠghcReturns the subgraph only containing the nodes whose labels satisfy the given predicate.ʠghc3Returns the subgraph induced by the supplied nodes.ˠghcFind the context for the given . Causes an error if the  is not present in the .̠ghcFind the label for a .͠ghcFind the neighbors for a .Πghc4Find the labelled links coming into or going from a .Ϡghc Find all "s that have a link from the given .Рghc Find all s that link to to the given .Ѡghc Find all !s that are linked from the given  and the label of each link.Ҡghc Find all s that link to the given  and the label of each link.ӠghcFind all outward-bound s for the given .ԠghcFind all inward-bound s for the given .ՠghc The outward-bound degree of the .֠ghcThe inward-bound degree of the .נghcThe degree of the .ؠghcThe  in a .٠ghcThe label in a .ڠghcThe  from a .۠ghcAll s linked to or from in a .ܠghc/All labelled links coming into or going from a .ݠghcAll s linked to in a .ޠghcAll s linked from in a .ߠghcAll s linked from in a , and the label of the links.ghcAll s linked from in a , and the label of the links.ghcAll outward-directed s in a .ghcAll inward-directed s in a .ghcThe outward degree of a .ghcThe inward degree of a .ghcThe degree of a .ghc5Checks if there is a directed edge between two nodes.ghc8Checks if there is an undirected edge between two nodes.ghc5Checks if there is a labelled edge between two nodes.ghcChecks if there is an undirected labelled edge between two nodes.ghcPretty-print the graph. Note that this loses a lot of information, such as edge inverses, etc.ghc!Pretty-print the graph to stdout. àĠŠƠȠǠɠʠˠ̠͠ΠϠРѠҠӠԠՠ֠נؠ٠ڠ۠ܠݠޠߠ àĠŠƠȠǠɠʠˠ̠͠ΠϠРѠҠӠԠՠ֠נؠ٠ڠ۠ܠݠޠߠ Safe-Inferred< Safe-InferredR Safe-Inferredghc2Edge weights to use when generating a CFG from CMMghcDefault edge weights  S Safe-Inferred )*ȧghc-Simple data type to represent JSON documents.ghcThe : is unescaped  h Safe-Inferredghc9Subset of UnitInfo: just enough to pretty-print a unit-idInstead of printing the unit-id which may contain a hash, we print: package-version:componentnameghc IdentifierghcSource package nameghcSource package versionghcComponent nameT Safe-Inferred%&79:;:0ghcA location as produced by the parser. Consists of two components:The location in the file, adjusted for #line and {-# LINE ... #-} pragmas (RealSrcLoc)The location in the string buffer (BufPos) with monotonicity guarantees (see #17632)ghcWe attach SrcSpans to lots of things, so let's have a datatype for it.ghc Source SpanA  identifies either a specific portion of a text file or a human-readable description of a location.ghcStringBuffer Source SpanghcA  delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.-The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.Real Source SpanghcSource Locationghc30-based offset identifying the raw location in the  StringBuffer.The lexer increments the  every time a character (UTF-8 code point) is read from the input buffer. As UTF-8 is a variable-length encoding and  StringBuffer% needs a byte offset for indexing, a  cannot be used for indexing.The parser guarantees that  are monotonic. See #17632. This means that syntactic constructs that appear later in the  StringBuffer" are guaranteed to have a higher . Contrast that with , which does *not* make the analogous guarantee about higher line/column numbers.This is due to #line and {-# LINE ... #-} pragmas that can arbitrarily modify  . Notice how  setSrcLoc and resetAlrLastLoc in GHC.Parser.Lexer update  , modifying  but preserving .Monotonicity makes  useful to determine the order in which syntactic elements appear in the source. Consider this example (haddockA041 in the test suite):haddockA041.hs {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where #include "IncludeMe.hs"IncludeMe.hs: -- | Comment on T data T = MkT -- ^ Comment on MkT#After the C preprocessor runs, the  StringBuffer will contain a program that looks like this (unimportant lines at the beginning removed):# 1 "haddockA041.hs" {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where # 1 "IncludeMe.hs" 1 -- | Comment on T data T = MkT -- ^ Comment on MkT # 7 "haddockA041.hs" 2The line pragmas inserted by CPP make the error messages more informative. The downside is that we can't use RealSrcLoc to determine the ordering of syntactic elements.With RealSrcLoc, we have the following location information recorded in the AST: * The module name is located at haddockA041.hs:3:8-31 * The Haddock comment "Comment on T" is located at IncludeMe:1:1-17 * The data declaration is located at IncludeMe.hs:2:1-32Is the Haddock comment located between the module name and the data declaration? This is impossible to tell because the locations are not comparable; they even refer to different files.On the other hand, with , we have the following location information: * The module name is located at 846-870 * The Haddock comment "Comment on T" is located at 898-915 * The data declaration is located at 916-928Aside: if you're wondering why the numbers are so high, try running ghc -E haddockA041.hs and see the extra fluff that CPP inserts at the start of the file.For error messages,  is not useful at all. On the other hand, this is exactly what we need to determine the order of syntactic elements: 870 < 898, therefore the Haddock comment appears *after* the module name. 915 < 916, therefore the Haddock comment appears *before* the data declaration.We use  in in GHC.Parser.PostProcess.Haddock to associate Haddock comments with parts of the AST using location information (#17544).ghcReal Source Location'Represents a single point within a fileghc Safe-Inferred7 ghcA wrapper around  with the sole purpose of informing call sites that the provided 5 and 6 instances are nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.ghcA finite map from uniques* of one type to elements in another type.The key is just here to keep us honest. It's always safe to use a single type as key. If two types don't overlap in their uniques it's also safe to index the same map at multiple key types. But this is very much discouraged.ghcAdd an element, returns previous lookup result and new map. If old element doesn't exist, add the passed element directly, otherwise compute the element to add using the passed function.ghcAdd elements to the map, combining existing values with inserted ones using the given function.ghc1`plusUFM_CD f m1 d1 m2 d2` merges the maps using f! as the combinding function and d1 resp. d2/ as the default value if there is no entry in m1 reps. m2-. The domain is the union of the domains of m1 and m2.IMPORTANT NOTE: This function strictly applies the modification function and forces the result unlike most the other functions in this module.Representative example: plusUFM_CD f {A: 1, B: 2} 23 {B: 3, C: 4} 42 == {A: f 1 42, B: f 2 3, C: f 23 4 } ghc,`plusUFM_CD2 f m1 m2` merges the maps using f$ as the combining function. Unlike =, a missing value is not defaulted: it is instead passed as J to f. f' can never have both its arguments be J.IMPORTANT NOTE: This function strictly applies the modification function and forces the result.`plusUFM_CD2 f m1 m2` is the same as `plusUFM_CD f (mapUFM Just m1) Nothing (mapUFM Just m2) Nothing`.ghcminusUFC_C f map1 map2 returns map1, except that every mapping key |-> value1 in map1" that shares a key with a mapping key |-> value2 in map2 is altered by f: value1 is replaced by f value1 value2 , where K& means that the new value is used and J$ means that the mapping is deleted.ghcIn essence foldM See Note [Deterministic UniqFM] to learn about nondeterminism. If you use this please provide a justification why it doesn't introduce nondeterminism.ghc Cast the key domain of a UniqFM.As long as the domains don't overlap in their uniques this is safe.ghcPretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetEltsUFM.ghcPretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetUFMToList.ghcDetermines the pluralisation suffix appropriate for the length of a set in the same way that plural from Outputable does for lists.ghcInherently nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.ghcInherently nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.ghcThe things to be pretty printedghc3The pretty printing function to use on the elementsghc + where the things have been pretty printedghcThe things to be pretty printedghc3The pretty printing function to use on the elementsghc + where the things have been pretty printed Safe-Inferredl Safe-Inferred 79FghcMaps indexed by  keysghcAdd an element, returns previous lookup result and new map. If old element doesn't exist, add the passed element directly, otherwise compute the element to add using the passed function.ghc'Intersection with a combining function.%%Y Safe-Inferred 79:;'ghc(Type of unique deterministic finite mapsThe key is just here to keep us honest. It's always safe to use a single type as key. If two types don't overlap in their uniques it's also safe to index the same map at multiple key types. But this is very much discouraged.ghc+A type of values tagged with insertion timeghcinsertion timeghcPerforms a deterministic fold over the UniqDFM. It's O(n log n) while the corresponding function on  is O(n).ghcPerforms a nondeterministic strict fold over the UniqDFM. It's O(n), same as the corresponding function on . If you use this please provide a justification why it doesn't introduce nondeterminism.ghc Converts  to a list, with elements in deterministic order. It's O(n log n) while the corresponding function on  is O(n).ghc>Partition UniqDFM into two UniqDFMs according to the predicateghc(Delete a list of elements from a UniqDFMghc7This allows for lossy conversion from UniqDFM to UniqFMghc(Apply a function to a particular elementghc(Apply a function to a particular elementghcThe expression (alterUDFM f k map) alters value x at k, or absence thereof. alterUDFM can be used to insert, delete, or update a value in UniqDFM. Use addToUDFM, delFromUDFM or adjustUDFM when possible, they are more efficient.ghc,Map a function over every value in a UniqDFMghc Cast the key domain of a UniqFM.As long as the domains don't overlap in their uniques this is safe.ghcDeterministic, in O(n log n).ghcDeterministic, in O(n log n).ghcThe things to be pretty printedghc3The pretty printing function to use on the elementsghc + where the things have been pretty printed00\ Safe-Inferred7aghcWhat's the point you might ask? We might have changed an object without it's key changing. In which case this lookup makes sense.ghc converts a  a into a  a0 assuming, without checking, that it maps each  to a value that has that . See Note [UniqSet invariant].$$ Safe-Inferred!ghcGraph nodes. Represents a thing that can conflict with another thing. For the register allocater the nodes represent registers.ghc"A unique identifier for this node.ghcThe class of this node, determines the set of colors that can be used.ghcThe color of this node, if any.ghc9Neighbors which must be colored differently to this node.ghc(Colors that cannot be used by this node.ghc>Colors that this node would prefer to be, in descending order.ghc>Neighbors that this node would like to be colored the same as.ghcThe Interference graph. There used to be more fields, but they were turfed out in a previous revision. maybe we'll want more later..ghcAll active nodes in the graph.ghcA fn to check if a node is trivially colorable For graphs who's color classes are disjoint then a node is 'trivially colorable' when it has less neighbors and exclusions than available colors for that node.For graph's who's color classes overlap, ie some colors alias other colors, then this can be a bit more tricky. There is a general way to calculate this, but it's likely be too slow for use in the code. The coloring algorithm takes a canned function which can be optimised by the user to be specific to the specific graph being colored.for details, see "A Generalised Algorithm for Graph-Coloring Register Allocation" Smith, Ramsey, Holloway - PLDI 2004.ghcAn empty graph.ghc5Modify the finite map holding the nodes in the graph.ghcAn empty node.k Safe-Inferred4,]ghcA  whose domain is sets of /s, each of which share a common value of type ele. Every such set ("equivalence class") has a distinct representative . Supports merging the entries of multiple such sets in a union-find like fashion.An accurate model is that of [(Set key, Maybe ele)]!: A finite mapping from sets of keys to possibly absent entries ele+, where the sets don't overlap. Example:  m = [({u1,u3}, Just ele1), ({u2}, Just ele2), ({u4,u7}, Nothing)] 9 On this model we support the following main operations: m u3 == Just ele1,  m u4 == Nothing,  m u5 == Nothing. m u1 u3 is a no-op, but  m u1 u2 merges {u1,u3} and {u2} to point to  Just ele2 and returns the old entry of {u1,u3},  Just ele1. m u3 ele4 sets the entry of {u1,u3} to  Just ele4.8As well as a few means for traversal/conversion to list.ghcEither  Indirect x., meaning the value is represented by that of x , or an Entry6 containing containing the actual value it represents.ghclookupSUDFM env x looks up an entry for x, looking through all s until it finds a shared .$Examples in terms of the model (see ): >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u3 == Just ele1 >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u4 == Nothing >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Nothing)] u2 == NothingghcequateUSDFM env x y makes x and y+ point to the same entry, thereby merging x's class with y 's. If both x and y$ are in the domain of the map, then y.'s entry will be chosen as the new entry and x's old entry will be returned.$Examples in terms of the model (see ): >>> equateUSDFM [] u1 u2 == (Nothing, [({u1,u2}, Nothing)]) >>> equateUSDFM [({u1,u3}, Just ele1)] u3 u4 == (Nothing, [({u1,u3,u4}, Just ele1)]) >>> equateUSDFM [({u1,u3}, Just ele1)] u4 u3 == (Nothing, [({u1,u3,u4}, Just ele1)]) >>> equateUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u3 u2 == (Just ele1, [({u2,u1,u3}, Just ele2)])ghcaddToUSDFM env x a sets the entry x is associated with to a1, thereby modifying its whole equivalence class.$Examples in terms of the model (see ): >>> addToUSDFM [] u1 ele1 == [({u1}, Just ele1)] >>> addToUSDFM [({u1,u3}, Just ele1)] u3 ele2 == [({u1,u3}, Just ele2)]] Safe-Inferred7,Z Safe-Inferred.vghcA non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code.U Safe-Inferred)*067 ghcInformation we keep around during interface file serialization/deserialization. Namely we keep the functions for serializing and deserializing s and s. We do this because we actually use serialization in two distinct settings,+When serializing interface files themselvesWhen computing the fingerprint of an IfaceDecl (which we computing by hashing its Binary serialization)These two settings have different needs while serializing Names:Names in interface files are serialized via a symbol table (see Note [Symbol table representation of names] in GHC.Iface.Binary).During fingerprinting a binding Name is serialized as the OccName and a non-binding Name is serialized as the fingerprint of the thing they represent. See Note [Fingerprinting IfaceDecls] for further discussion.ghcserialize a non-binding ( (e.g. a reference to another binding).ghcserialize a binding  (e.g. the name of an IfaceDecl)ghcEncode the argument in it's full length. This is different from many default binary instances which make no guarantee about the actual encoding and might do things use variable length encoding.ghcDo not rely on instance sizes for general types, we use variable length encoding for many of them.ghc$Get access to the underlying buffer.ghc%SeekBin but without calling expandBinghc&Takes a size and action writing up to size bytes. After the action has run advance the index to the buffer by size bytes.ghc"forwardPut put_A put_B" outputs A after B but allows A to be read before B by using a forward referenceghc-Read a value stored using a forward referenceghcSerialize the constructor strictly but lazily serialize a value inside a K.This way we can check for the presence of a value without deserializing the value itself.ghc"Deserialize a value serialized by .ghc;This instance doesn't rely on the determinism of the keys' ,! instance, so it works e.g. for s too.ghchow to deserialize sghchow to serialize non-binding sghchow to serialize binding sW Safe-Inferred )*09) Safe-Inferred'79:;O& ghcA Module is a pair of a   and a  . ghcA unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of  , which in turn is used in Name=, which is used to give names to entities when typechecking.#There are two possible forms for a  :1) It can be a , in which case we just have a  that uniquely identifies some fully compiled, installed library we have on disk.2) It can be an . When we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an , which explicitly records the instantiation, so that we can substitute over it. ghc6A generic module is a pair of a unit identifier and a  . ghcA UnitId identifies a built library in a database and is used to generate unique symbols, etc. It's usually of the form:pkgname-1.2:libname+hash(These UnitId are provided to us via the  -this-unit-id flag.The library in question may be definite or indefinite; if it is indefinite, none of the holes have been filled (we never install partially instantiated libraries as we can cheaply instantiate them on-the-fly, cf VirtUnit). Put another way, an installed unit id is either fully instantiated, or not instantiated at all. ghcUnit the module belongs to ghcModule name (e.g. A.B.C)ghc"This data type just pairs a value - with an IsBootInterface flag. In practice,  is usually a Module or  ModuleName'.ghc3A definite unit (i.e. without any free module hole)ghcA  is an   with the invariant that it only refers to a definite library; i.e., one we have generated code for.ghcThe full hashed unit identifier, including the component id and the hash.ghcAn instantiated unit.It identifies an indefinite library (with holes) that has been instantiated.This unit may be indefinite or not (i.e. with remaining holes or not). If it is definite, we don't know if it has already been compiled and installed in a database. Nevertheless, we have a mechanism called "improvement" to try to match a fully instantiated unit with existing compiled and installed units: see Note [VirtUnit to RealUnit improvement].?An indefinite unit identifier pretty-prints to something like p[H= H ,A=aimpl:A>] (p is the  5, and the brackets enclose the module substitution).ghcA private, uniquely identifying representation of an InstantiatedUnit. This string is completely private to GHC and is just used to get a unique.ghcCached unique of .ghc)The (indefinite) unit being instantiated.ghcThe sorted (by  ) instantiations of this unit.ghc$A cache of the free module holes of &. This lets us efficiently tell if a  has been fully instantiated (empty set of free module holes) and whether or not a substitution can have any effect.ghcInstalled definite unit (either a fully instantiated unit or a closed unit)ghcVirtual unit instantiated on-the-fly. It may be definite if all the holes are instantiated but we don't have code objects for it.ghcFake hole unitghcA unit key in the databaseghcClass for types that are used as unit identifiers (UnitKey, UnitId, Unit)We need this class because we create new unit ids for virtual units (see VirtUnit) and they have to to be made from units with different kinds of identifiers.ghcAn  is a  " whose unit is identified with an .ghcA  is like an  but we expect to find it in one of the home units rather than the package database.ghcA  is a  # whose unit is identified with an  .ghc2Compares unit ids lexically, rather than by their sghc+Retrieve the set of free module holes of a  .ghcCalculate the free holes of a  . If this set is non-empty, this module was defined in an indefinite library that had required signatures.If a module has free holes, that means that substitutions can operate on it; if it has no free holes, substituting over a module has no effect.ghc Create a new ' given an explicit module substitution.ghc*Smart constructor for instantiated GenUnitghcGenerate a uniquely identifying hash (internal unit-id) for an instantiated unit.This is a one-way function. If the indefinite unit has not been instantiated at all, we return its unit-id.This hash is completely internal to GHC and is not used for symbol names or file paths. It is different from the hash Cabal would produce for the same instantiated unit.ghc2Generate a hash for a sorted module instantiation.ghc+Create a new simple unit identifier from a . Internally, this is primarily used to specify wired-in unit identifiers.ghcMap over the unit type of a  ghc4Map over the unit identifier of unit instantiations.ghcReturn the UnitId of the Unit. For on-the-fly instantiated units, return the UnitId of the indefinite unit this unit is an instance of.ghc=Return the virtual UnitId of an on-the-fly instantiated unit.ghcA  % is definite if it has no free holes.ghcThis is the package Id for the current program. It is the default package Id if you don't specify a package name. We don't add this prefix to symbol names, since there can be only one main package per program.          u Safe-InferredQ'  m Safe-InferredYp ghcModule LocationWhere a module lives on the file system: the actual locations of the .hs, .hi, .dyn_hi, .o, .dyn_o and .hie files, if we have them.For a module in another unit, the ml_hs_file and ml_obj_file components of ModLocation are undefined.The locations specified by a ModLocation may or may not correspond to actual files yet: for example, even if the object file doesn't exist, the ModLocation still contains the path to where the object file will reside if/when it is created.The paths of anything which can affect recompilation should be placed inside ModLocation.When a ModLocation is created none of the filepaths will have -boot suffixes. This is because in --make mode the ModLocation is put in the finder cache which is indexed by ModuleName, when a ModLocation is retrieved from the FinderCache the boot suffixes are appended. The other case is in -c mode, there the ModLocation immediately gets given the boot suffixes in mkOneShotModLocation.ghcThe source file, if we have one. Package modules probably don't have source files.ghcWhere the .hi file is, whether or not it exists yet. Always of form foo.hi, even if there is an hi-boot file (we add the -boot suffix later)ghc9Where the .dyn_hi file is, whether or not it exists yet.ghcWhere the .o file is, whether or not it exists yet. (might not exist either because the module hasn't been compiled yet, or because it is part of a unit with a .a file)ghc5Where the .dy file is, whether or not it exists yet.ghc6Where the .hie file is, whether or not it exists yet.ghcAdd the -boot suffix to .hs, .hi and .o filesghc Remove the -boot suffix to .hs, .hi and .o filesghcAdd the -boot suffix if the Bool argument is TrueghcAdd the -boot4 suffix to all file paths associated with the moduleghcAdd the -boot suffix to all output file paths associated with the module, not including the input file itselfn Safe-Inferred[ghcA map keyed off of ghcA map keyed off of  s (actually, their s) Has deterministic folds and can be deterministically converted to a listghcA map keyed off of  s (actually, their s)ghc A set of  sghcA map keyed off of  s00o Safe-Inferred %&`I ghcA  % is definite if it has no free holes.ghc!Get a string representation of a   that's unique and stable across recompilations. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"ghcThis gives a stable ordering, as opposed to the Ord instance which gives an ordering based on the Uniques of the components, which may not be stable from run to run of the compiler.ghc Test if a   corresponds to a given , modulo instantiation.ghcGiven a possibly on-the-fly instantiated module, split it into a   that we definitely can find on-disk, as well as an instantiation if we need to instantiate it on the fly. If the instantiation is Nothing" no on-the-fly renaming is needed.ghcReturn the unit-id this unit is an instance of and the module instantiations (if any).ghc4Remove instantiations of the given instantiated unitghc;Remove instantiations of the given module instantiated unitghc$Test if a Module is not instantiatedghcCreate a hole Module     q Safe-Inferreda Safe-Inferredd ghc$Hexadecimal representation of an intUsed for uniques. We could use base-62 as GHC usually does but this is likely faster.ghcReturn z-encoded unit:moduleghcthe global linkable unit of a module exports this symbol, depend on it to include that unit (used for cost centres)ghcMake JS symbol corresponding to the given Haskell symbol in the given moduleghcMake JS symbol corresponding to the given Haskell symbol in the given moduleghc+Make JS symbol for given module and unique.ghcMake symbol "h$XYZ" or "h$$XYZ"ghc"h$$" constant stringghc"h$" constant stringr Safe-InferredtsghcInformation about the home unit (i.e., the until that will contain the modules we are compiling)The unit identifier of the instantiating units is left open to allow switching from UnitKey (what is provided by the user) to UnitId (internal unit identifier) with .TODO: this isn't implemented yet. UnitKeys are still converted too early into UnitIds in GHC.Unit.State.readUnitDataBaseghc.Definite home unit (i.e. that we can compile).Nothing: not an instantiated unit Just (i,insts): made definite by instantiating "i" with "insts"ghc6Indefinite home unit (i.e. that we can only typecheck)All the holes are instantiated with fake modules from the Hole unit. See Note [Representation of module/name variables] in GHC.UnitghcReturn home unit idghcReturn home unit instantiationsghcReturn the unit id of the unit that is instantiated by the home unit.-E.g. if home unit = q[A=p:B,...] we return q.If the home unit is not an instance of another unit, we return its own unit id (it is an instance of itself if you will).ghcReturn the unit id of the unit that is instantiated by the home unit.4E.g. if home unit = q[A=p:B,...] we return (Just q).If the home unit is not an instance of another unit, we return Nothing.ghc&Return the home unit as a normal unit.We infer from the home unit itself the kind of unit we create: 1. If the home unit is definite, we must be compiling so we return a real unit. The definite home unit may be the result of a unit instantiation, say `p = q[A=r:X]`. In this case we could have returned a virtual unit `q[A=r:X]` but it's not what the clients of this function expect, especially because p is lost when we do this. The unit id of a virtual unit is made up internally so `unitId(q[A=r:X])` is not equal to p. If the home unit is indefinite we can only create a virtual unit from it. It's ok because we must be only typechecking the home unit so we won't produce any code object that rely on the unit id of this virtual unit.ghc4Map over the unit identifier for instantiating unitsghc/Test if we are type-checking an indefinite unit7(if it is not, we should never use on-the-fly renaming)ghc(Test if we are compiling a definite unit3(if it is, we should never use on-the-fly renaming)ghc9Test if we are compiling by instantiating a definite unitghc!Test if the unit is the home unitghc'Test if the unit-id is the home unit-idghc+Test if the unit-id is not the home unit-idghc9Test if the home unit is an instance of the given unit-idghc+Test if the module comes from the home unitghc+Test if the module comes from the home unitghc6Test if a module doesn't come from the given home unitghc6Test if a module doesn't come from the given home unitghc6Test if a module doesn't come from the given home unitghc6Test if a module doesn't come from the given home unitghcMake a module in home unitghcMake a module in home unitghcReturn the module that is used to instantiate the given home module name. If the ModuleName doesn't refer to a signature, return the actual home module."E.g., the instantiating module of A in  p[A=q[]:B] is q[]:B%. the instantiating module of A in p is p:A.ghcReturn the module that is used to instantiate the given home module.If the given module isn't a module hole, return the actual home module."E.g., the instantiating module of p:A in  p[A=q[]:B] is q[]:B%. the instantiating module of r:A in  p[A=q[]:B] is r:A%. the instantiating module of p:A in p is p:A%. the instantiating module of r:A in p is r:A.v Safe-Inferred9u ^ Safe-Inferred7| ghcA String Literal in the source, including its original raw format for use by source to source manipulation tools.ghcFractional LiteralUsed (instead of Rational) to represent exactly the floating point literal that we encountered in the user's source program. This allows us to pretty-print exactly what the user wrote, which is important e.g. for floating point numbers that can't represented as Doubles (we used to via Double for pretty-printing). See also #2245. Note [FractionalLit representation] in GHC.HsToCore.Match.Literal The actual value then is: sign * fl_signi * (fl_exp_base^fl_exp) where sign = if fl_neg then (-1) else 1For example FL { fl_neg = True, fl_signi = 5.3, fl_exp = 4, fl_exp_base = Base10 } denotes -5300ghc'How the value was written in the sourceghcIntegral LiteralUsed (instead of Integer) to represent negative zegative zero which is required for NegativeLiterals extension to correctly parse `-0::Double` as negative zero. See also #13211.ghcFor when code is generated, e.g. TH, deriving. The pretty printer will then make its own representation of the item.ghc/Special combinator for showing string literals.ghc7The integer should already be negated if it's negative.ghc=The arguments should already be negated if they are negative.ghcCompare fractional lits with small exponents for value equality but large values for syntactic equality.ghcBe wary of using this instance to compare for equal *values* when exponents are large. The same value expressed in different syntactic form won't compare as equal when any of the exponents is >= 100.ghcBe wary of using this instance to compare for equal *values* when exponents are large. The same value expressed in different syntactic form won't compare as equal when any of the exponents is >= 100.!!s Safe-Inferred7 ghc Package-qualifier after renamingRenaming detects if "this" or the unit-id of the home-unit was used as a package qualifier. ghcNo package qualifier ghcImport from home-unit ghcImport from another unit ghc"Package-qualifier as it was parsed ghcNo package qualifier ghcRaw package qualifier string.   t Safe-Inferred ghc.hs file ghc .hs-boot file ghc .hsig file ghc Tests if an  9 is a boot file, primarily for constructing elements of  BuildModule. We conflate signatures and modules because they are bound in the same namespace; only boot interfaces can be disambiguated with `import {-# SOURCE #-}`.  _ Safe-Inferredo ghcSafe Haskell information for ModIface Simply a wrapper around SafeHaskellMode to separate iface and flagsghcThe various Safe Haskell modesghcinferred unsafeghcdeclared and checkedghcdeclared and checkedghcdeclared and checkedghcinferred as safeghc-fno-safe-haskell stateghcIs an import a safe import?  p Safe-Inferred7Pghc A C type, used in CAPI FFI calls :   '{-# CTYPE' , , ,  '#-}',ghc,How to call a particular function in C-land.ghcMight invoke Haskell GC, or do a call back, or switch threads, etc. So make sure things are tidy before the call. Additionally, in the threaded RTS we arrange for the external call to be executed by a separate OS thread, i.e., _concurrently_ to the execution of other Haskell threads.ghcLike PlaySafe, but additionally the worker thread running this foreign call may be unceremoniously killed, so it must be scheduled on an unbound thread.ghcNone of the above can happen; the call will return without interacting with the runtime system at all. Specifically:No GC No call backs No blockingNo precise exceptions!!d Safe-Inferred7ghcCaptures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.[ Safe-Inferred7Lghc9An index into a given cost centre module,name,flavour setghc2Per-module state for tracking cost centre indices.See documentation of  for more details.ghcInitialize cost centre state.ghc-Get a new index for a given cost centre name.X Safe-InferredghcReadingghcWriting  e Safe-Inferred 7ghc#A contiguous chunk of documentationghc'|' is the decoratorghc is the decoratorghc'$ string' is the decoratorghc%The decorator is the given number of rsghcHaskell Documentation StringRich structure to support exact printing The location around each chunk doesn't include the decoratorsghc#The first chunk is preceded by "--  decorator" and each following chunk is preceded by "--" Example: -- | This is a docstring for foo$. It is the line with the decorator '|' and is always included -- This continues that docstring and is the second element in the NonEmpty list foo :: a -> aghc The docstring is preceded by "{- decorator" and followed by "-}" The chunk contains balanced pairs of '{-' and '-}'ghcA docstring generated either internally or via TH Pretty printed with the '-- |' decorator This is because it may contain unbalanced pairs of '{-' and '-}' and not form a valid ghcAnnotate a pretty printed thing with its doc The docstring comes after if is  Otherwise it comes before. Note - we convert MultiLineDocString HsDocStringPrevious to HsDocStringNext because we can't control if something else will be pretty printed on the same lineghc Create a  from a UTF8-encoded .ghc:Pretty print with decorators, exactly as the user wrote itghc:Pretty print with decorators, exactly as the user wrote itghc.Just get the docstring, without any decoratorsghc&Don't add a newline to a single stringghcJust get the docstring, without any decorators Separates docstrings using "nn", which is how haddock likes to render themV Safe-InferredIghcRepresents the  as a bit set.+Assumes that all elements are non-negative.This is only efficient for values that are sufficiently small, for example in the lower hundreds.g Safe-Inferred&ghc-Enumerates the simple on-or-off dynamic flagsghc.Append dump output to files instead of stdout.ghc Use foo.ways. dumpFlag instead of foo. dumpFlagghc8Enable floating out of let-bindings in the simplifierghcEnable floating out of let-bindings at the top level in the simplifier N.B. See Note [RHS Floating]ghcdeprecated, no effect and behaviour is now default. Allowed switching of a special demand transformer for dictionary selectorsghc)Use the cfg based block layout algorithm.ghc+Layout based on last instruction per block.ghc;Do W/W split for unlifting even if we won't unbox anything.ghcIgnore manual SCC annotationsghc -fPICghc -fPIEghc -pieghcUse regular thunks even when we could use std ap thunks in order to get entry countsghc -fcompact-unwindghcSuppress timestamps in dumpsghc-Suppress per binding Core size stats in dumpsghcDebugging flagsghc#Dump the cfg used for block layout.ghcInitial STG (CoreToStg output)ghcSTG after unariseghcSTG (after stg2stg)ghc!Result of tag inference analysis.ghcFinal STG (before cmm gen)ghc)Helper function to query whether a given  is enabled or not.ghcIs the flag implicitly enabled when the verbosity is high enough?ghcThe set of flags which affect optimisation for the purposes of recompilation avoidance. Specifically, these include flags which affect code generation but not the semantics of the program.See Note [Ignoring some flag changes] in GHC.Iface.Recomp.Flags)ghcThe set of flags which affect code generation and can change a program's runtime behavior (other than performance). These include flags which affect:?user visible debugging information (e.g. info table provenance);the ability to catch runtime errors (e.g. -fignore-asserts)6the runtime result of the program (e.g. -fomit-yields)5which code or interface file declarations are emittedWe also considered placing flags which affect asympototic space behavior (e.g. -ffull-laziness) however this would mean that changing optimisation levels would trigger recompilation even with -fignore-optim-changes, regressing #13604.Also, arguably Opt_IgnoreAsserts should be here as well; however, we place it instead in  since it is implied by -O[12]( and therefore would also break #13604. See #23369.ghc!Return the names of a WarningFlagOne flag may have several names because of US/UK spelling. The first one is the "preferred one" that will be displayed in warning messages.ghcWarning groups.As all warnings are in the Weverything set, it is ignored when displaying to the user which group a warning is in.ghcWarning group hierarchies, where there is an explicit inclusion relation.Each inner list is a hierarchy of warning groups, ordered from smallest to largest, where each group is a superset of the one before it.Separating this from  allows for multiple hierarchies with no inherent relation to be defined.3The special-case Weverything group is not included.ghcFind the smallest group in every hierarchy which a warning belongs to, excluding Weverything.ghc+Warnings enabled unless specified otherwiseghcThings you get with -WghcThings you get with -WallghcThings you get with -Weverything, i.e. *all* known warnings flagsghcThings you get with -Wcompat.This is intended to group together warnings that will be enabled by default at some point in the future, so that library authors eager to make their code future compatible to fix issues before they even generate warnings.ghc"Things you get with -Wunused-bindsghcGetter for verbosity settingghc(Getter for the set of enabled dump flagsa Safe-Inferred 7_ghcFlag to indicate whether the FieldSelectors extension is enabled.ghc.Selector functions are available (the default)ghc$Selector functions are not availableghcFlag to indicate whether the DuplicateRecordFields extension is enabled.ghc+Fields may be duplicated in a single moduleghc3Fields must be unique within a module (the default)ghc:Fields in an algebraic record type; see Note [FieldLabel].ghcUser-visible label of the fieldghcWas DuplicateRecordFields- on in the defining module for this datatype?ghcWas FieldSelectors enabled in the defining module for this datatype? See Note [NoFieldSelectors] in GHC.Rename.EnvghcRecord selector functionghc2A map from labels to all the auxiliary informationghcRecord selector OccNames are built from the underlying field name and the name of the first data constructor of the type, to support duplicate record field names. See Note [Why selector names include data constructors].ghcUndo the name mangling described in Note [FieldLabel] to produce a Name that has the user-visible OccName (but the selector's unique). This should be used only when generating output, when we want to show the label, but may need to qualify it with a module prefix.ghcSelector name mangling should be used if either DuplicateRecordFields or NoFieldSelectors is enabled, so that the OccName of the field can be used for something else. See Note [FieldLabel], and Note [NoFieldSelectors] in GHC.Rename.Env.ghc We need the  Binary Name> constraint here even though there is an instance defined in GHC.Types.Name, because the we have a SOURCE import, so the instance is not in scope. And the instance cannot be added to Name.hs-boot because GHC.Utils.Binary itself depends on GHC.Types.Name."(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred")*-7<"ghcA newtype wrapper around  for JS identifiers.ghcA newtype wrapper around < to ensure we never generate a < that becomes a NaN, see 'Eq SaneDouble', 'Ord SaneDouble' for details on Sane-nessghcJS Unary Operatorsghc Logical Not: !ghc Bitwise Not: ~ghc Negation: -ghc Unary Plus: +xghcnew xghctypeof xghcdelete xghcyield xghcvoid xghcPrefix Increment: ++xghcPostfix Increment: x++ghcPrefix Decrement: --xghcPostfix Decrement: x--ghcJS Binary Operators. We do not deeply embed the comma operator and the assignment operatorsghcEquality: ghcStrict Equality: ===ghcInEquality: !=ghcStrict InEquality !==ghcGreater Than: VghcGreater Than or Equal: ghcLess Than: <ghcLess Than or Equal: <=ghcAddition: +¡ghcSubtraction: -ághcMultiplication *ġghcDivision: /šghcRemainder: %ơghcLeft Shift: <<ǡghcRight Shift: >>ȡghcUnsigned RightShift: >>>ɡghcBitwise And: &ʡghcBitwise Or: |ˡghcBitwise XOr: ^̡ghcLogical And: &&͡ghcLogical Or: ||Ρghc  instanceofϡghc inСghcJavaScript valuesѡghcA variable referenceҡghc/A JavaScript list, or what JS calls an ArrayӡghcA DoubleԡghcA BigIntաghcA String֡ghcA RegexסghcA JS HashMap:  {"foo": 0}ءghc A function١ghcAn  Unsaturated value, see ڡghcJavaScript Expressionsۡghc$All values are trivially expressionsܡghcSelection: Obj.foo, see ݡghcIndexing: Obj[foo], see ޡghcInfix Expressions, see ڡ pattern synonymsߡghcUnary Expressionsghc If-expressionghc ApplicationghcAn  Unsaturated expression. See ghcA Label used for , specifically ,  and of course ghcJavaScript statements, see the  https://tc39.es/ecma262/#sec-ecmascript-language-statements-and-declarationsECMA262 Reference for detailsghc$Variable declarations: var foo [= e]ghcReturnghcIfghcWhile, bool is "do" when Trueghc For-in, bool is "each' when TrueghcSwitchghcTryghcBlocksghc ApplicationghcUnary operatorsghcBinding form:  foo = barghc Unsaturated blocks see ghc/Statement Labels, makes me nostalgic for qbasicghcBreakghcContinueghc'A supply of identifiers, possibly emptyghc'pattern synonym to create string valuesghc(pattern synonym to create integer valuesghc pattern synonym for logical And &&ghcpattern synonym for logical Or ||ghc pattern synonym for Bitwise Not ~ghc pattern synonym for Bitwise XOr ^ghc pattern synonym for Bitwise And &ghcpattern synonym for Bitwise Or |ghcpattern synonym for remainder %ghcpattern synonym for division *ghc#pattern synonym for multiplication *ghc pattern synonym for subtraction -ghcpattern synonym for addition +ghc#pattern synonym for unary negation -ghc pattern synonym for logical not !ghc&pattern synonym for postfix decrement --xghc%pattern synonym for prefix decrement --xghc&pattern synonym for postfix increment x++ghc%pattern synonym for prefix increment ++xghc(pattern synonym for a unary operator newghc-Given a Pseudo-saturate a value with garbage  unsatId identifiers.ghc)Append a statement to another statement.  only returns a  that is not a  when either mx or @my is an empty . That is: > (BlockStat [] , y ) = y > (x , BlockStat []) = xڡۡܡݡޡߡСԡաѡҡӡ֡סء١¡áġšʡɡˡ̡͡ơǡȡΡϡڡۡܡݡޡߡСԡաѡҡӡ֡סء١¡áġšʡɡˡ̡͡ơǡȡΡϡ Safe-Inferred")*-Hghc0Union type to allow regular traversal by compos.ghcCompos and ops for generic traversal as defined over the JMacro ADT.9Utility class to coerce the ADT into a regular structure.ghcMap on every variable identȢghcGiven an optional prefix, fills in all free variable names with a supply of names generated by the prefix.â¢ȢĢŢƢǢâ¢ȢĢŢƢǢ Safe-Inferred")*-ɦghcRender a syntax tree as a pretty-printable document (simply showing the resultant doc produces a nice, well formatted String).ghcRender a syntax tree as a pretty-printable document, using a given prefix to all generated names. Use this with distinct prefixes to ensure distinct generated names between independent calls to render(Prefix)Js.ghcHang with braces:hdr { body }"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry  experimental Safe-Inferred "ˮghcRender as an hexadecimal number in reversed order (because it's faster and we don't care about the actual value)."(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred ")*ރghcThe  class is heavily used in the Introduction function. It ensures that all identifiers in the EDSL are tracked and named with an .ghcThe  class handles injection of of things into the EDSL as a JS statement. This ends up being polymorphic sugar for JS blocks, see helper function 1. Instantiate for any necessary data structures.ghcThings that can be marshalled into javascript values. Instantiate for any necessary data structures.ghc1Create a new anonymous function. The result is a ڡ expression. Usage: jLam $ \x -> jVar x + one_ jLam $ \f -> (jLam $ \x -> (f `app` (x `app` x))) `app` (jLam $ \x -> (f `app` (x `app` x)))ghcIntroduce a new variable into scope for the duration of the enclosed expression. The result is a block statement. Usage: jVar $ x y -> mconcat [jVar x ||= one_, jVar y ||= two_, jVar x + jVar y]ghc$Create a 'for in' statement. Usage: .jForIn {expression} $ x -> {block involving x}ghc8As with "jForIn" but creating a "for each in" statement.ghc8As with "jForIn" but creating a "for each in" statement.ghc!construct a JS variable referenceghc*Convert a ShortText to a Javascript Stringghc Create a for statementghc4construct a js declaration with the given identifierghcThe empty JS HashMapghcA singleton JS HashMapghc)insert a key-value pair into a JS HashMapghc5Construct a JS HashMap from a list of key-value pairsghcThe empty JS statementghcJS infix Equality operatorsghcJS infix Equality operatorsghcJS infix Equality operatorsghcJS infix Equality operatorsghcJS infix Ord operatorsghcJS infix Ord operatorsghcJS infix Ord operatorsghcJS infix Ord operatorsghcJS infix bit operatorsghcJS infix bit operatorsghcJS infix bit operatorsghcJS infix bit shift operatorsghcJS infix bit shift operatorsghcJS infix bit shift operatorsghcGiven a ڡ, return the its type.ghcJS if-expression if_ e1 e2 e3 ==> e1 ? e2 : e3ghc4If-expression which returns statements, see related  'if e s1 s2 ==> if(e) { s1 } else { s2 }ghc(A when-statement as syntactic sugar via  2jwhenS cond block ==> if(cond) { block } else { }ghc"If-expression which returns blocks -ifBlockS e s1 s2 ==> if(e) { s1 } else { s2 }ghc*if-expression that returns 1 if condition  = true, 0 otherwise if10 e ==> e ? 1 : 0£ghc*if-expression that returns 0 if condition  = true, 1 otherwise if01 e ==> e ? 0 : 1ãghc'an expression application, see related ģ app f xs ==> f(xs)ģghc1A statement application, see the expression form ãţghc Return a ڡƣghc("for" loop with increment at end of bodyǣghc("for" loop with increment at end of bodyȣghcPrefix-increment a ڡɣghcPostfix-increment a ڡʣghcPrefix-decrement a ڡˣghcPostfix-decrement a ڡ̣ghc'Byte indexing of o with a 64-bit offsetͣghc'Byte indexing of o with a 32-bit offsetΣghc'Byte indexing of o with a 16-bit offsetϣghc&Byte indexing of o with a 8-bit offsetУghc'a bit mask to retrieve the lower 8-bitsѣghc(a bit mask to retrieve the lower 16-bitsңghc Sign-extend/narrow a 8-bit valueӣghc!Sign-extend/narrow a 16-bit valueԣghcSelect a property prop, from and object obj obj .^ prop ==> obj.propգghc"Assign a variable to an expression foo |= expr ==> var foo = expr;֣ghcDeclare a variable and then Assign the variable to an expression $foo |= expr ==> var foo; foo = expr;ףghc#return the expression at idx of obj obj .! idx ==> obj[idx]ݣghcThe JS literal ޣghcThe JS literal 0ߣghcThe JS literal 1ghcThe JS literal 2ghcThe JS literal 3ghcThe JS literal dghcThe JS literal trueghcThe JS literal falseghcCache "dXXX" field namesghcCache "h$dXXX" namesghcCache "h$cXXX" namesghcConvert A JS expression to a JS statement where applicable. This only affects applications; , If-expressions; , and Unary expression; ߡ.֣գף£ãģţƣǣȣɣʣˣϣΣ̣ͣУѣңӣأ٣ڣۣԣܣݣޣߣ֣գף£ãģţƣǣȣɣʣˣϣΣ̣ͣУѣңӣأ٣ڣۣԣܣݣޣߣ66667777889 9 9 ԣ8գ2֣2ף8 Safe-Inferred"TghcReturn registersExtra results from foreign calls can be stored here (while first result is directly returned)ghcStack registersghcGeneral purpose "registers"1The JS backend arbitrarily supports 128 registersghc#List of registers, starting from R1ghc#List of registers, starting from R2ghc,List of registers, starting from R1 as JExprghc,List of registers, starting from R2 as JExpr¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤߤ¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤߤ Safe-Inferredzghc9Pretty print a graph in a somewhat human readable format.ghcPretty print a graph in graphviz .dot format. Conflicts get solid edges. Coalescences get dashed edges.ghcNodes in the graph are doubly linked, but we only want one edge for each conflict if the graphviz graph. Traverse over the graph, but make sure to only print the edges for each node once.ghcWhat graphviz color to use for each node color It's usually safe to return X11 style colors here, ie "red", "green" etc or a hex triplet #aaff55 etc Safe-Inferred?ghcLookup a node from the graph.ghc>Get a node from the graph, throwing an error if it's not thereghc-Add a node to the graph, linking up its edgesghc/Delete a node and all its edges from the graph.ghcModify a node in the graph. returns Nothing if the node isn't present.ghcGet the size of the graph, O(n)ghcUnion two graphs together.ghcAdd a conflict between nodes to the graph, creating the nodes required. Conflicts are virtual regs which need to be colored differently.ghcDelete a conflict edge. k1 -> k2 returns Nothing if the node isn't in the graphghcAdd some conflicts to the graph, creating nodes if required. All the nodes in the set are taken to conflict with each other.ghcAdd an exclusion to the graph, creating nodes if required. These are extra colors that the node cannot use.ghcAdd a coalescence edge to the graph, creating nodes if required. It is considered advantageous to assign the same color to nodes in a coalescence.ghc4Delete a coalescence edge (k1 -> k2) from the graph.ghcAdd a color preference to the graph, creating nodes if required. The most recently added preference is the most preferred. The algorithm tries to assign a node it's preferred color if possible.ghcDo aggressive coalescing on this graph. returns the new graph and the list of pairs of nodes that got coalesced together. for each pair, the resulting node will have the least key and be second in the pair.ghcCoalesce this pair of nodes unconditionally / aggressively. The resulting node is the one with the least key.returns: Just the pair of keys if the nodes were coalesced the second element of the pair being the least one3Nothing if either of the nodes weren't in the graphghcFreeze a node This is for the iterative coalescer. By freezing a node we give up on ever coalescing it. Move all its coalesce edges into the frozen set - and update back edges from other nodes.ghcFreeze one node in the graph This if for the iterative coalescer. Look for a move related node of low degree and freeze it.We probably don't need to scan the whole graph looking for the node of absolute lowest degree. Just sample the first few and choose the one with the lowest degree out of those. Also, we don't make any distinction between conflicts of different classes.. this is just a heuristic, after all.IDEA: freezing a node might free it up for Simplify.. would be good to check for triv right here, and add it to a worklist if known triv/non-move nodes.ghcFreeze all the nodes in the graph for debugging the iterative allocator.ghc7Find all the nodes in the graph that meet some criteriaghcvalidate the internal structure of a graph all its edges should point to valid nodes If they don't then throw an errorghcIf this node is colored, check that all the nodes which conflict with it have different colors.ghcSlurp out a map of how many nodes had a certain number of conflict neighboursghcSet the color of a certain nodeghcIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing)ghcIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing)ghc!keys of the nodes to be coalescedghckey of the node to freezeghc the graphghcgraph with that node frozenghc(extra debugging info to display on errorghc-whether this graph is supposed to be colored.ghcgraph to validateghcvalidated graphghcTrue if this node is okghc9(conflict neighbours, num nodes with that many conflicts) Safe-Inferred( ghc*Edge direction based on DFS Classificationghc7Loop back towards the root node. Eg backjumps in loopsghcv -> vghc&Representation for nodes of the Graph.The payload1 is user data, just carried around in this moduleThe key is the node identifier. Key has an Ord instance for performance reasons.The [key] are the dependencies of the node; it's ok to have extra keys in the dependencies that are not the key of any Node in the graphghc User dataghcUser defined node idghc#Dependencies/successors of the nodeghcFind a reasonably short cycle a->b->c->a, in a strongly connected component. The input nodes are presumed to be a SCC, so you can start anywhere.ghc1Given a list of roots return all reachable nodes.ghcEfficiently construct a map which maps each key to it's set of transitive dependencies. Only works on acyclic input.ghcEfficiently construct a map which maps each key to it's set of transitive dependencies. Less efficient than  allReachable$, but works on cyclic input as well.ghcGiven a start vertex, a way to get successors from a node and a list of (directed) edges classify the types of edges.%% Safe-InferredghcTry to color a graph with this set of colors. Uses Chaitin's algorithm to color the graph. The graph is scanned for nodes which are deamed 'trivially colorable'. These nodes are pushed onto a stack and removed from the graph. Once this process is complete the graph can be colored by removing nodes from the stack (ie in reverse order) and assigning them colors different to their neighbors.ghcScan through the conflict graph separating out trivially colorable and potentially uncolorable (problem) nodes.Checking whether a node is trivially colorable or not is a reasonably expensive operation, so after a triv node is found and removed from the graph it's no good to return to the start of the graph and recheck a bunch of nodes that will probably still be non-trivially colorable.To ward against this, during each pass through the graph we collect up a list of triv nodes that were found, and only remove them once we've finished the pass. The more nodes we can delete at once the more likely it is that nodes we've already checked will become trivially colorable for the next pass.TODO: add work lists to finding triv nodes is easier. If we've just scanned the graph, and removed triv nodes, then the only nodes that we need to rescan are the ones we've removed edges from.ghc)Try to assign a color to all these nodes.ghcSelect a color for a certain node taking into account preferences, neighbors and exclusions. returns Nothing if no color can be assigned to this node.ghc"whether to do iterative coalescingghc6how many times we've tried to color this graph so far.ghc>map of (node class -> set of colors available for this class).ghc3fn to decide whether a node is trivially colorable.ghcfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghcthe graph to color.ghc"whether to do iterative coalescingghc2fn to decide whether a node is trivially colorableghcfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghcthe graph to scanghc>map of (node class -> set of colors available for this class).ghc the graphghcnodes to assign a color to.+ Safe-Inferred RТghc3The slots that are still available to be allocated.Ѣghc#Assignment of vregs to stack slots.ҢghcIdentifier for a stack slot.Ӣghc-An empty stack map, with all slots available.ԢghcIf this vreg unique already has a stack assignment then return the slot number, otherwise allocate a new slot, and update the map.բghc4Return the number of stack slots that were allocatedҢ΢ϢТѢӢԢբҢ΢ϢТѢӢԢբ Safe-Inferred 7(F7 ghcSpecify whether to default kind variables, and type variables of kind  RuntimeRep  Multiplicity. ghcDefault kind variables:default kind variables of kind Type to Type,default  RuntimeRep  Multiplicity kind variables to  LiftedRep Many, respectively.When this strategy is used, it means that we have determined that the variables we are considering defaulting are all kind variables.;Usually, we pass this option when -XNoPolyKinds is enabled. ghc=Default (or don't default) non-standard variables, of kinds  RuntimeRep,   and  Multiplicity. ghc2Specify whether to default type variables of kind  RuntimeRep  Multiplicity. ghc*Default type variables of the given kinds:default  RuntimeRep variables to  LiftedRepdefault   variables to  default  Multiplicity variables to Many ghc/Try not to default type variables of the kinds  RuntimeRep  Multiplicity.Note that these might get defaulted anyway, if they are kind variables and `-XNoPolyKinds` is enabled. ghcFlag to see whether we're type-checking terms or kind-checking types ghcAn integer or infinity ghcInline Specification ghcRule Match Information ghc Phase Number ghcDefault Method Specification ghc Inside Lambda ghcOccurs inside a non-linear lambda Substituting a redex for this occurrence is dangerous because it might duplicate work. ghcInteresting Context ghcFunction: is applied Data value: scrutinised by a case with at least one non-DEFAULT branch ghc!identifier Occurrence Information ghc2There are many occurrences, or unknown occurrences ghcMarks unused variables. Sometimes useful for lambda and case-bound variables. ghc3Occurs exactly once (per branch), not inside a rule ghcThis identifier breaks a loop of mutually recursive functions. The field marks whether it is only a loop breaker due to a reference in a rule ghcEmbedding Projection pair!ghc7Are we dealing with an unboxed tuple or an unboxed sum?!Used when validity checking, see check_ubx_tuple_or_sum.!ghc2A general-purpose pretty-printing precedence type.!ghc'This instance must not overlap another !- instance. However, it may be overlapped by ! instances, and it may overlap ! instances.!ghcSilently ignore this instance if you find a more specific one that matches the constraint you are trying to resolveExample: constraint (Foo [Int]) instance Foo [Int] instance {-# OVERLAPPABLE #-} Foo [a]Since the second instance has the Overlappable flag, the first instance will be chosen (otherwise its ambiguous which to choose)!ghcSilently ignore any more general instances that may be used to solve the constraint.Example: constraint (Foo [Int]) instance {-# OVERLAPPING #-} Foo [Int] instance Foo [a]Since the first instance has the Overlapping flag, the second---more general---instance will be ignored (otherwise it is ambiguous which to choose)!ghcEquivalent to having both ! and ! flags.!ghcBehave like Overlappable and Overlapping, and in addition pick an arbitrary one if there are multiple matching candidates, and don't worry about later instantiationExample: constraint (Foo [b]) instance {-# INCOHERENT -} Foo [Int] instance Foo [a] Without the Incoherent flag, we'd complain that instantiating b would change which instance was chosen. See also Note [Incoherent instances] in GHC.Core.InstEnv!ghcThe semantics allowed for overlapping instances for a particular instance. See Note [Safe Haskell isSafeOverlap] in GHC.Core.InstEnv for a explanation of the ! field. :  '{-# OVERLAPPABLE'" or '{-# OVERLAPPING'" or '{-# OVERLAPS'" or '{-# INCOHERENT',  `#-}`,!ghcRecursivity Flag!ghc4Should an argument be passed evaluated *and* tagged.!ghcIf the Id is a lambda-bound variable then it may have lambda-bound variable info. Sometimes we know whether the lambda binding this variable is a "one-shot" lambda; that is, whether it is applied at most once.This information may be useful in optimisation, as computations may safely be floated inside such a lambda without risk of duplicating work.+See also Note [OneShotInfo overview] above.!ghcNo information!ghc#The lambda is applied at most once.!ghcA power-of-two alignment!ghc A *zero-indexed* constructor tag!ghcFullArgCount is the number of type or value arguments in an application, or the number of type or value binders in a lambda. Note: it includes both type and value arguments!!ghcThe number of arguments that a join point takes. Unlike the arity of a function, this is a purely syntactic property and is fixed when the join point is created (or converted from a value). Both type and value arguments are counted.!ghcRepresentation ArityThe number of represented arguments that can be applied to a value before it does "real work". So: fib 100 has representation arity 0 x -> fib x has representation arity 1 (# x, y #) -> fib (x + y) has representation arity 2!ghcThe number of value arguments that can be applied to a value before it does "real work". So: fib 100 has arity 0 x -> fib x has arity 1 See also Note [Definition of arity] in GHC.Core.Opt.Arity!ghcTags are allocated from here for real constructors or for superclass selectors!ghc$It is always safe to assume that an Id) has no lambda-bound variable information!ghc=Pretty print an alternative in an unboxed sum e.g. "| a | |"."ghc0Outputs string for pragma name for any of INLINE INLINABLENOINLINE. This differs from the Outputable instance for the InlineSpec type where the pragma name string as well as the accompanying SourceText (if any) is printed."ghc3Pretty-print without displaying the user-specified  ."ghc*Pretty-print including the user-specified  ."ghcA representation of infinityghcAdd two  sghc Multiply two  s"ghc Subtract an   from an  "ghcTurn a positive number into an  , where 0 represents infinity"ghcInject any integer into an  "ghcIf there is any  interesting identifier occurrence, then the aggregated occurrence info of that identifier is considered interesting."ghcIf any occurrence of an identifier is inside a lambda, then the occurrence info of that identifier marks it as occurring inside a lambda!ghc#The pretty printing function to useghcThe things to be pretty printedghcAlternative (one-based)ghcArityghc  where the alternative havs been pretty printed and finally packed into a paragraph.!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!! ! !!! !! !!!!!! !!! !!!!!!!! !! ! !!!"""""""!"""!""""""" """" !!! """"" "" "" "!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!! ! !!! !! !!!!!! !!! !!!!!!!! !! ! !!!"""""""!"""!""""""" """" !!! """"" "" "" " Safe-Inferred4;%ghcTest if the given Integer is representable with a platform Int%ghc?Test if the given Integer is representable with a platform Word%ghcFor some architectures the C calling convention is that any integer shorter than 64 bits is replaced by its 64 bits representation using sign or zero extension.%ghcTry to locate "DerivedConstants.h" file in the given dirs and to parse the PlatformConstants from it.See Note [Platform constants]%%%%%%%%%%%%%%%%%%%^_`%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%^_`%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Safe-Inferred8ghcGenerate a section type (e.g.  @progbits). See #13937.ghcTarget platformghc section typeghcpretty assembler fragment Safe-Inferred<: =ghcSettings for what GHC this is.=ghcPaths to various files and directories used by GHC, including those that provide more settings.=ghc)Settings for other executables GHC calls.Probably should further split down by phase, or split between platform-specific and platform-agnostic.=ghcN.B. On Windows we don't have a linker which supports object merging, hence the @ . See Note [Object merging] in GHC.Driver.Pipeline.Execute for details.=ghcLLVM: opt llvm optimiser=ghcLLVM: llc static compiler=ghcLLVM: c compiler=ghc?cached Fingerprint of sOpt_P See Note [Repeated -optP hashing]>ghcLLVM: llvm optimiser>ghcLLVM: llc static compiler>ghcLLVM: c compiler>ghc iserv options>ghcDynamic library suffix>>>>>>>>====================================>>>>>>===========%%%%%%%%%%%%%%%%%%%%>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>====================================>>>>>>===========%%%%%%%%%%%%%%%%%%%%>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Safe-Inferred>ghc TopDir pathghc&Settings filepath (for error messages)ghcRaw settings file contentsNoneG0:ghcA way4Don't change the constructor order as it is used by ; to create a unique tag (e.g. thr_debug_p) which is expected by other tools (e.g. Cabal).:ghc,for GHC API clients building custom variants:ghc'(RTS only) Multithreaded runtime system:ghc1Debugging, enable trace messages and extra checks:ghc:Profiling, enable cost-centre stacks and profiling reports:ghcDynamic linking:ghcTest if a way is enabled:ghcTest if a way is not enabled:ghc Add a way:ghc Remove a way;ghc)Check if a combination of ways is allowed;ghc'Unique tag associated to a list of ways;ghc-Unique build-tag associated to a list of waysRTS only ways are filtered out because they have no impact on the build.;ghc$Unique build-tag associated to a way;ghcReturn true for ways that only impact the RTS, not the generated code;ghc.Filter ways that have an impact on compilation;ghcFilter RTS-only ways (ways that don't have an impact on compilation);ghc*Turn these flags on when enabling this way;ghc+Turn these flags off when enabling this way;ghc;Pass these options to the C compiler when enabling this way;ghc3Pass these options to linker when enabling this way;ghc=Pass these options to the preprocessor when enabling this way;ghcConsult the RTS to find whether it has been built with profiling enabled.;ghcConsult the RTS to find whether GHC itself has been built with dynamic linking. This can't be statically known at compile-time, because we build both the static and dynamic versions together with -dynamic-too.;ghc/Consult the RTS to find whether it is threaded.;ghc/Consult the RTS to find whether it is debugged.;ghc.Consult the RTS to find whether it is tracing.;ghc Host ways.;ghcHost "full" ways (i.e. ways that have an impact on the compilation, not RTS only ways).These ways must be used when compiling codes targeting the internal interpreter.:::::::::::;;;;;;;;;;;;;;;;;;;;:::::::::::;;;;;;;;;;;;;;;;;;;;  Safe-Inferred %&M >ghcInformation about an installed unit (units are identified by their internal UnitId)>ghcInformation about an installed unit (units are identified by their database UnitKey)>ghc#Information about an installed unitWe parameterize on the unit identifier: * UnitKey: identifier used in the database (cf >5) * UnitId: identifier used to generate code (cf >)These two identifiers are different for wired-in packages. See Note [About units] in GHC.Unit>ghc9Convert a DbUnitInfo (read from a package database) into >>ghcMap over the unit parameter>ghcMake a   from a > If the unit is definite, make a  from  field."If the unit is indefinite, make a  from  and 8 fields. Note that in this case we don't keep track of . It can be retrieved later with "improvement", i.e. matching on `unitInstanceOf/unitInstantiations` fields (see Note [About units] in GHC.Unit).>ghc$Create a UnitPprInfo from a UnitInfo>ghc3Find all the include directories in the given units>ghc2Find all the C-compiler options in the given units>ghcFind all the library directories in the given units for the given ways>ghc*Find all the frameworks in the given units>ghcFind all the package framework paths in these and the preload packagesghc Either the  or  as appropriate for the way.:>>>>>>>>>>>>p>>>>>>>>>:>>>>>>>>>>>>p>>>>>>>>> Safe-InferredP=;ghcA platform profile fully describes the kind of objects that are generated for a platform.% doesn't fully describe the ABI of an object. Compiler ways (profiling, debug, dynamic) also modify the ABI.;ghcPlatform;ghcWays;ghcGet platform constants;ghcIs profiling enabled;ghcWord size in bytes;ghc Unique build tag for the profile;;;;;;;;;;;;;;;; Safe-InferredQͥghcMaximum number of arguments after lambda lifting a recursive function.ΥghcMaximum number of arguments after lambda lifting non-recursive function.ϥghcLambda lift even when this turns a known call into an unknown call.ʥ˥̥ͥΥϥʥ˥̥ͥΥϥ Safe-InferredY_ghc8An ArgDescr describes the argument pattern of a function_ghcWe represent liveness bitmaps as a Bitmap (whose internal representation really is a bitmap). These are pinned onto case return vectors to indicate the state of the stack for the garbage collector.In the compiled program, liveness bitmaps that fit inside a single word (StgWord) are stored as a single word, while larger bitmaps are stored as a pointer to an array of words._ghcTrue <=> This is a static closure. Affects how we garbage-collect it. Static closure have an extra static link field at the end. Constructors do not have a static variant; see Note [static constructors]_ghcA description of the layout of a closure. Corresponds directly to the closure types in includes/rts/storage/ClosureTypes.h._ghcWord offset, or word count_ghcByte offset, or byte count_ghcRound up the given byte count to the next byte count that's a multiple of the machine's word size._ghc Round up base to a multiple of size._ghc7Convert the given number of words to a number of bytes.This function morally has type WordOff -> ByteOff , but uses Num a to allow for overloading._ghcFirst round the given byte count up to a multiple of the machine's word size and then convert the result to words._ghcHalf word size in bytes_ghcSize of a closure header (StgHeader in includes/rts/storage/Closures.h)_ghcSize of the profiling part of a closure header (StgProfHeader in includes/rts/storage/Closures.h)ghcThe garbage collector requires that every closure is at least as big as this._ghc(The total size of the closure, in words._ghcThe byte offset into the card table of the card for a given element_ghc>Convert a number of elements to a number of cards, rounding up_ghc"The size of a card table, in bytes_ghc"The size of a card table, in words_ghc%Derives the RTS closure type from an ___________________________________________________________________________________________________________________________________________________ Safe-Inferred\z?ghc*Compute the output file name of a program.StaticLink boolean is used to indicate if the program is actually a static library (e.g., on iOS).Use the provided filename (if any), otherwise use "main.exe" (Windows), "a.out (otherwise without StaticLink set), "liba.a". In every case, add the extension if it is missing.?? Safe-Inferred_ >ghcUntyped Phase description>ghc -E>ghc -C>ghc -S>ghc -c?ghcWhen we are given files (modified by -x arguments) we need to determine if they are Haskellish or not to figure out how we should try to compile it. The rules are: If no -x flag was specified, we check to see if the file looks like a module name, has no extension, or has a Haskell source extension.If an -x flag was specified, we just make sure the specified suffix is a Haskell one.?ghcForeign language of the phase if the phase deals with a foreign code1>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>?>?>>???????????1>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>?>?>>??????????? Safe-Inferredcԥghc&A bitmap represented by a sequence of _ s on the target architecture. These are used for bitmaps in info tables and other generated code which need to be emitted as sequences of StgWords.եghc%Make a bitmap from a sequence of bits֥ghc0Make a bitmap where the slots specified are the zeros in the bitmap. eg. [0,1,3], size 4 ==> 0x4 (we leave any bits outside the size as zero, just to make the bitmap easier to read). The list of Ints must& be already sorted and duplicate-free.ץghcMagic number, must agree with BITMAP_BITS_SHIFT in InfoTables.h. Some kinds of bitmap pack a size/bitmap into a single word if possible, or fall back to an external pointer when the bitmap is too large. This value represents the largest size of bitmap that can be packed into a single word.֥ghc size in bitsghc*sorted indices of zeros free of duplicatesԥե֥ץԥե֥ץ Safe-Inferredd:ghc Rule options:ghcTarget platform:ghc-Enable more advanced numeric constant folding:ghcCut down precision of Rational values to that of Float/Double if disabled:ghcEnable rules for bignums:::::::::::: Safe-Inferredjghc!Read in assembly file and processghc4These are the rewrites that the mangler will performghcRewrite a line of assembly source with the given rewrites, taking the first rewrite that applies.ghcThis rewrites .type$ annotations of function symbols to %object+. This is done as the linker can relocate  %functions through the Procedure Linking Table (PLT). This is bad since we expect that the info table will appear directly before the symbol's location. In the case that the PLT is used, this will be not an info table but instead some random PLT garbage.ghcThis rewrites aligned AVX instructions to their unaligned counterparts on x86-64. This is necessary because the stack is not adequately aligned for aligned AVX spills, so LLVM would emit code that adjusts the stack pointer and disable tail call optimization. Both would be catastrophic here so GHC tells LLVM that the stack is 32-byte aligned (even though it isn't) and then rewrites the instructions in the mangler.ghcThis rewrites (tail) calls to avoid creating PLT entries for functions on riscv64. The replacement will load the address from the GOT, which is resolved to point to the real address of the function.ghcreplaceOnce match replace bs1 replaces the first occurrence of the substring match in bs with replace.ghcThis function splits a line of assembly code into the label and the rest of the code. Safe-Inferredmi ?ghcTarget platform?ghc Context for LLVM code generation?ghc+Fill undefined literals with garbage values?ghcSplit sections?ghc(x86) BMI instructions?ghcversion of Llvm we're using?ghc&True ==> warn unsupported Llvm version?ghctarget triple passed to LLVM?ghc=Supported LLVM configurations. see Note [LLVM configuration]?ghcThe (inclusive) lower bound on the LLVM Version that is currently supported.?ghcThe (not-inclusive) upper bound bound on the LLVM Version that is currently supported.???????????????????????????????????????????????????????????? Safe-Inferredo?ghc3Cache LLVM configuration read from files in top_dir5See Note [LLVM configuration] in GHC.CmmToLlvm.ConfigCurrently implemented with unsafe lazy IO. But it could be implemented with an IORef as the exposed interface is in IO.?????? Safe-Inferreds :ghcis -falignment-sanitisation enabled?:ghc.The width of the current platform's word size.:ghc3The width of the current platform's half-word size.:ghc7A bit-mask for the lower half-word of current platform.:ghcA width in bits.:ghcA width in bytes. %widthFromBytes (widthInBytes w) === w:ghc*Partial* A width from the number of bytes.:ghc:log_2 of the width in bytes, useful for generating shifts.:ghcNarrow a signed or unsigned value to the given width. The result will reside in  [0, +2^width). narrowU W8 256 == 256narrowU W8 255 == 255narrowU W8 128 == 128narrowU W8 127 == 127narrowU W8 0 == 0narrowU W8 (-127) == 129narrowU W8 (-128) == 128narrowU W8 (-129) == 127narrowU W8 (-255) == 1narrowU W8 (-256) == 0:ghcNarrow a signed value to the given width. The result will reside in [-2^(width-1), +2^(width-1)). narrowS W8 256 == 0narrowS W8 255 == -1narrowS W8 128 == -128narrowS W8 127 == 127narrowS W8 0 == 0narrowS W8 (-127) == -127narrowS W8 (-128) == -128narrowS W8 (-129) == 127narrowS W8 (-255) == 1narrowS W8 (-256) == 0:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Safe-Inferredz~ghc#Native code generator configurationghcTarget platformghcContext for ASM code generationghc1The name of the module we are currently compilingghcMandatory proc alignmentghc/Generate code to link against dynamic librariesghc Enable Position-Independent Codeghc If inlining memcpy produces less than this threshold (in pseudo-instruction unit), do itghc Ditto for memsetghcSplit sectionsghcPerform ASM linting passghcPerform CMM constant foldingghc(x86) SSE instructionsghc(x86) BMI instructionsghcCFG edge weightsghc$Use CFG based block layout algorithmghc+Layout based on last instruction per block.ghcEnable Dwarf generationghcEnable unwindingsghc0Strip out block information from generated Dwarfghc0Expose symbol table entries for internal symbolsghc$Enable GHC-specific source note DIEsghc%Enable static control-flow predictionghcEnable shortcutting (don't jump to blocks only containing a jump)ghcCompute block unwinding tablesghc+Whether to enable the dead-code eliminationghcReturn Word sizeghc=Size in bytes of the pre-allocated spill space on the C stackghcReturn Word size## Safe-Inferred {;ghc'Parameters: 1. Identifier 2. Type0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Safe-Inferred^;ghc$The operation to perform atomically.;ghcC11 memory ordering semantics.;ghcrelaxed ordering;ghcacquire ordering;ghcrelease ordering;ghcsequentially consistent<ghc(Atomic read-modify-write. Arguments are  [dest, n].<ghcAtomic read. Arguments are [addr].<ghcAtomic write. Arguments are  [addr, value].<ghc'Atomic compare-and-swap. Arguments are [dest, expected, new]. Sequentially consistent. Possible future refactoring: should this be an< variant?<ghcAtomic swap. Arguments are  [dest, new]<ghcMachine-level primops; ones which we can reasonably delegate to the native code generators to handle.)Most operations are parameterised by the : that they operate on. Some operations have separate signed and unsigned versions, and float and integer versions.Note that there are variety of places in the native code generator where we assume that the code produced for a MachOp does not introduce new blocks.=ghcReturns L if the MachOp has commutable arguments. This is used in the platform-independent Cmm optimisations.If in doubt, return I. This generates worse code on the native routes, but is otherwise harmless.=ghcReturns L$ if the MachOp is associative (i.e. (x+y)+z == x+(y+z)=) This is used in the platform-independent Cmm optimisations.If in doubt, return I. This generates worse code on the native routes, but is otherwise harmless.=ghcReturns L if the MachOp is a comparison.If in doubt, return False. This generates worse code on the native routes, but is otherwise harmless.=ghcReturns Just w6 if the operation is an integer comparison with width w, or Nothing otherwise.=ghc.Returns the MachRep of the result of a MachOp.=ghcThis function is used for debugging only: we can check whether an application of a MachOp is "type-correct" by checking that the MachReps of its arguments are the same as the MachOp expects. This is used when linting a CmmExpr.=ghc!Return (results_hints,args_hints)=ghcThe alignment of a memcpy-ish operation.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=====================================================================;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<===;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=====================================================================;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<===;;;;;;;;;;;; Safe-Inferred"   Safe-Inferred ڥghcTarget Profileۥghc Optimize Cmm Control Flow or notܥghc"Do Cmm Linting Optimization or notݥghcEliminate common blocks or notޥghc&Perform sink after stack layout or notߥghc.Instrument memory accesses for ThreadSanitizerghc5Generate stack unwinding instructions (for debugging)ghc/Generate code to link against dynamic librariesghc1Should the Cmm pass replace Stg switch statementsghc#Should Cmm split proc points or notghc retrieve the target Cmm platform إ٥ڥۥܥݥޥߥ إ٥ڥۥܥݥޥߥ Safe-Inferred :ghcForeign export stubs:ghcWe don't have any stubs:ghc!There are some stubs. Parameters:?1) Header file prototypes for "foreign exported" functions2) C stubs to use when calling "foreign exported" functions:ghcInitializers to be run at startup See Note [Initializers and finalizers in Cmm] in GHC.Cmm.InitFini.:ghc Finalizers to be run at shutdown:ghc!initializerCStub fn_nm decls body is a :: containing C initializer function (e.g. an entry of the  .init_array section) named fn_nm7 with the given body and the given set of declarations.:ghcfinalizerCStub fn_nm decls body is a :8 containing C finalizer function (e.g. an entry of the  .fini_array section) named fn_nm7 with the given body and the given set of declarations.::::::::::::::::::::::::::::y Safe-Inferred=#ghcGet the  associated with a known-key . #######$###############$######$$ #######$###############$######$$( Safe-Inferred"7w ghcOther names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName. ghcOccurrence NameIn this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"$ghcAlters (replaces or removes) those elements of the map that are mentioned in the second map$ghcCreate a name which is actually defined by the compiler itself&ghc0Create a name brought into being by the compiler&ghcMake a name for a foreign call&ghc Make the ? into an internal name, regardless of what it was to begin with&ghcCompare Names lexicographically This only works for Names that originate in the source code or have been tidied.&ghc ' v == not (' v).'ghcIs this a term variable ( ) that is not! a coercion variable? Satisfies ' v ==> ' v == not (' v).'ghc' returns True% for type variables as well as local s These are the variables that we need to pay attention to when finding free variables, or doing dependency analysis.'ghc' returns True of s and s that must have a binding in this module. The converse is not quite right: there are some global s that must have bindings, such as record selectors. But that doesn't matter, because it's only used for assertions'ghcisExportedIdVar means "don't throw this away"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''&&&&&&&&&&&&&'''&&&&&&&' &&&&''''''''&&&&&&'''''''''''''''''''''''''''&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''&&&&&&&&&&&&&&&'''&&&&&&&' &&&&''''''''&&&&&&'''''''''''''''''''''''''''& Safe-InferredC'ghc+Deterministic Type or Coercion Variable Set'ghcDeterministic Type Variable Set'ghcDeterministic Identifier Set'ghcDeterministic Variable Set'ghcType or Coercion Variable Set'ghcCoercion Variable Set'ghcType Variable Set'ghcIdentifier Set'ghc A non-deterministic Variable SetA non-deterministic set of variables. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DVarSet if the set eventually gets converted into a list or folded over in a way where the order changes the generated code, for example when abstracting variables.(ghc5map the function over the list, and union the results(ghcDetermines the pluralisation suffix appropriate for the length of a set in the same way that plural from Outputable does for lists.(ghcPretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetEltsUFM. Passing a list to the pretty-printing function allows the caller to decide on the order of Vars (eg. toposort them) without them having to use nonDetEltsUFM at the call site. This prevents from let-binding non-deterministically ordered lists and reusing them where determinism matters.(ghc5Map the function over the list, and union the results(ghcTrue if empty intersection(ghcTrue if non-empty intersection(ghc2Partition DVarSet according to the predicate given(ghc'Delete a list of variables from DVarSet(ghc"Add a list of variables to DVarSet(ghcConvert a DVarSet to a VarSet by forgetting the order of insertion(ghctransCloVarSet for DVarSet(ghcThe things to be pretty printedghc4The pretty printing function to use on the elementsghc + where the things have been pretty printed'''''''(''(('(('(((((((((((((((((((((((''''(((((((((((((((((((((((((((((('''''''(''(('(('(((((((((((((((((((((((''''(((((((((((((((((((((((((((((( Safe-InferredJ(ghc.Predicate on possible free variables: returns True! iff the variable is interestingghcRun a free variable computation, returning a list of distinct free variables in deterministic order and a non-deterministic set containing those variables.(ghcRun a free variable computation, returning a list of distinct free variables in deterministic order.(ghcRun a free variable computation, returning a deterministic set of free variables. Note that this is just a wrapper around the version that returns a deterministic list. If you need a list you should use (.(ghcRun a free variable computation, returning a non-deterministic set of free variables. Don't use if the set will be later converted to a list and the order of that list will impact the generated code.(ghcAdd a variable - when free, to the returned free variables. Ignores duplicates and respects the filtering function.(ghcReturn no free variables.(ghc%Union two free variable computations.(ghc5Mark the variable as not free by putting it in scope.(ghc%Mark many free variables as not free.(ghc#Filter a free variable computation.(ghcMap a free variable computation over a list and union the results.(ghc&Union many free variable computations.(ghcAdd multiple variables - when free, to the returned free variables. Ignores duplicates and respects the filtering function.(((((((((((((((((((((((((((( Safe-Inferred)*/1Ӿ (((((((((( (((((((((( Safe-Inferredghccomplete bipartite graphghccomplete graphghc Resolves all 0, by pushing them in, and simplifies `D D @ = @`ghcShallow empty check.(((((((((((((((((((((((((((((((((((((((((( Safe-Inferred"(ghc'Deterministic Type Variable Environment(ghcDeterministic Identifier Environment Sadly not always indexed by Id, but it is in the common case.(ghc"Deterministic Variable Environment(ghcCoercion Variable Environment(ghc%Type or Coercion Variable Environment(ghcType Variable Environment(ghcIdentifier Environment(ghcVariable Environment(ghcTidy EnvironmentWhen tidying up print names, we keep a mapping of in-scope occ-names (the $+) and a Var-to-Var of the current renamings(ghcRename Environment 2When we are comparing (or matching) types or terms, we are faced with "going under" corresponding binders. E.g. when comparing: \x. e1 ~ \y. e2Basically we want to rename [x -> y] or [y -> x], but there are lots of things we must be careful of. In particular, x might be free in e2 , or y in e1. So the idea is that we come up with a fresh binder that is free in neither, and rename x and y, respectively. That means we must maintain: 'A renaming for the left-hand expression)A renaming for the right-hand expressionsAn in-scope setFurthermore, when matching, we want to be able to have an 'occurs check', to prevent: \x. f ~ \y. ymatching with [f -> y]. So for each expression we want to know that set of locally-bound variables. That is precisely the domain of the mappings 1. and 2., but we must ensure that we always extend the mappings as we go in.-All of this information is bundled up in the ((ghc3A set of variables that are in scope at some point.Note that this is a superset of the variables that are currently in scope. See Note [The InScopeSet invariant]."Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.)ghcLook up a variable the (. This lets you map from the variable's identity (unique) to its full value.)ghcuniqAway in_scope v finds a unique that is not used in the in-scope set, and gives that to v. See Note [Local uniques] and Note [The InScopeSet invariant].)ghcunsafeGetFreshUnique in_scope3 finds a unique that is not in-scope in the given (. This must be used very carefully since one can very easily introduce non-unique %s this way. See Note [Local uniques].)ghcRetrieve the left mapping)ghcRetrieve the right mapping)ghcApplies ) to several variables: the two variable lists must be of equal length)ghcrnBndr2 env bL bR goes under a binder bL5 in the Left term, and binder bR, in the Right term. It finds a new binder, new_b&, and returns an environment mapping  bL -> new_b and  bR -> new_b)ghc Similar to )= but returns the new variable as well as the new environment)ghc Similar to )7 but used when there's a binder on the left side only.)ghc Similar to )8 but used when there's a binder on the right side only.)ghc Similar to )5 but used for eta expansion See Note [Eta expansion])ghc Similar to )5 but used for eta expansion See Note [Eta expansion])ghc?Look up the renaming of an occurrence in the left or right term)ghc?Look up the renaming of an occurrence in the left or right term)ghc?Look up the renaming of an occurrence in the left or right term)ghc?Look up the renaming of an occurrence in the left or right term)ghc)Tells whether a variable is locally bound)ghc)Tells whether a variable is locally bound)ghc`anyInRnEnvR env set` == `any (inRnEnvR rn_env) (toList set)` but lazy in the second argument if the right side of the env is empty.)ghc$Wipe the left or right side renaming)ghc$Wipe the left or right side renaming)ghc"swap the meaning of left and right)ghc+Only keep variables contained in the VarSet((((())))))))))))))))))))))))))))))))))((()))))))))))))))))))))))(((()))))()))))))())))))))))))))))))))))))))))()))((((())))))))))))))))))))))))))))))))))((()))))))))))))))))))))))(((()))))()))))))())))))))))))))))))))))))))))())) Safe-Inferred )ghcIds which have no CAF references. This is a result of analysis of C--. It is always safe to use an empty ). TODO Refer to Note.)ghc A number of )s in dependency order: earlier ) scope over later ) In a single (def, use) pair, the defs also scope over the uses)ghc(Just ds, us) => The use of any member of the ds, implies that all the us+ are used too. Also, us may mention ds. Nothing => Nothing is defined in this group, but nevertheless all the uses are essential. Used for instance declarations, for example)ghc&A set of names that are used somewhere)ghc)A set of names that are defined somewhere)ghc,True if there is a non-empty intersection. s1 ) s2 doesn't compute s2 if s1 is empty*ghcGet the elements of a NameSet with some stable ordering. This only works for Names that originate in the source code or have been tidied. See Note [Deterministic UniqFM] to learn about nondeterminism*ghc Just like *, but ) are not eliminated from the ) returned*ghc Collect all )>, regardless of whether the group is itself used, but remove ) on the way*ghc Given some ) and some ), find all the uses, transitively. The result is a superset of the input ),; and includes things defined in the input ) (but only if they are used).)))))))))))))))))))*)**********))))********))).)))))))))))))))))))*)**********))))********))) Safe-Inferred*ghcDeterministic Name Environment#See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM' for explanation why we need DNameEnv.*ghcName Environment,********************************************,******************************************** Safe-Inferred9ghcFixity information for an . We keep the OccName in the range so that we can generate an interface from it9ghc2Fixity environment mapping names to their fixities9ghcCreates cached lookup for the  mi_fix_fn field of ModIface99999999999999 Safe-Inferred770ghcA Cost Centre Stack is something that can be attached to a closure. This is either:$the current cost centre stack (CCCS)a pre-defined cost centre stack (there are several pre-defined CCSs, see below).0ghcThe flavour of a cost centre.Index fields represent 0-based indices giving source-code ordering of centres with the same module, name, and flavour.ghcAuto-generated top-level thunk, they all go into the same bucketghcExplicitly annotated expressionghcExplicitly annotated expressionghc Explicitly annotated declarationghcGenerated by HPC for coverageghc.Annotated by the one of the prof-last* passes.ghc.Annotated by the one of the prof-last* passes.0ghcA Cost Centre is a single  {-# SCC #-} annotation.0ghcTwo cost centres may have the same name and module but different SrcSpans, so we need a way to distinguish them easily and give them different object-code labels. So every CostCentre has an associated flavour that indicates how it was generated, and flavours that allow multiple instances of the same name and module have a deterministic 0-based index.0ghcName of the cost centre itself0ghc Name of module defining this CC.ghc Extract the index from a flavour0ghc.Is this a cost-centre which records scc counts0ghc)Is this a cost-centre which can be sccd ?0ghcPrint a flavour in CoreghcPrint a flavour's index in Coreghc(Print the flavour component of a C labelghc.Print the flavour index component of a C label'000000000000000000000000000000000000000'000000000000000000000000000000000000000 Safe-Inferred7,*ghcUsed where we may have an ordinary name or a record field label. See Note [GreNames] in GHC.Types.Name.Reader.*ghcA collection of *& - several things that are "available"*ghc2Records what things are "available", i.e. in scope*ghcAn ordinary identifier in scope, or a field label without a parent type (see Note [Representing pattern synonym fields in AvailInfo]).*ghcA type or class in scopeThe AvailTC Invariant=: If the type or class is itself to be in scope, it must be first in this list. Thus, typically: AvailTC Eq [Eq, ==, \/=]*ghcCompare lexicographically*ghc Does this * export the parent decl? This depends on the invariant that the parent is first if it appears at all.*ghcJust the main name made available, i.e. not the available pieces of type or class brought into scope by the **ghcAll names made available by the availability information (excluding overloaded selectors)*ghcAll names made available by the availability information (including overloaded selectors)*ghcNames for non-fields made available by the availability information*ghc5Fields made available by the availability information*ghcNames and fields made available by the availability information.*ghcNames and fields made available by the availability information, other than the main decl itself.*ghcA  for internal use, but not for output to the user. For fields, the   will be the selector. See Note [GreNames] in GHC.Types.Name.Reader.*ghcA 3 suitable for output to the user. For fields, the   will be the field label. See Note [GreNames] in GHC.Types.Name.Reader.*ghc trims an * to keep only a single name*ghcfilters *s by the given predicate*ghc filters an * by the given predicate*ghc Combines *s from the same family avails may have several items with the same availName E.g import Ix( Ix(..), index ) will give Ix(Ix,index,range) and Ix(index) We want to combine these; addAvail does that*ghc/Used when deciding if the interface has changed*ghcThe name of the type or classghcThe available pieces of type or class (see Note [Representing fields in AvailInfo])."**********************************"********************************** Safe-Inferred7 1*ghcImport Item Specification'Describes import info a particular Name*ghc4The import had no import list, or had a hiding list*ghc$The import had an import list. The * field is True iff the thing was named  explicitly in the import specs rather than being imported as part of a "..." group. Consider: import C( T(..) )Here the constructors of T! are not named explicitly; only T is named explicitly.*ghc Import Declaration SpecificationDescribes a particular import declaration and is shared among all the  Provenances for that decl*ghcModule imported, e.g.  import Muggle Note the Muggle5 may well not be the defining module for this thing!*ghcImport alias, e.g. from as M (or Muggle if there is no as clause)*ghcWas this import qualified?*ghc-The location of the entire import declaration*ghcImport SpecificationThe * of something says how it came to be imported It's quite elaborate so that we can give accurate unused-name warnings.*ghcSee Note [Parents]+ghcGlobal Reader ElementAn element of the ++ghcSee Note [GreNames]+ghcSee Note [Parents]+ghcTrue  = the thing was defined locally+ghcIn scope through these imports+ghcGlobal Reader Environment Keyed by  3; when looking up a qualified name we look up the   part, and then check the  Provenance to see if the appropriate qualification is valid. This saves routinely doubling the size of the env by adding both qualified and unqualified names to the domain.The list in the codomain is required because there may be name clashes These only get reported on lookup, not on constructionINVARIANT 1: All the members of the list have distinct +$ fields; that is, no duplicate NamesINVARIANT 2: Imported provenance => Name is an ExternalName However LocalDefs can have an InternalName. This happens only when type-checking a [d| ... |] Template Haskell quotation; see this note in GHC.Rename.Names Note [Top-level Names in Template Haskell decl quotes]INVARIANT 3: If the GlobalRdrEnv maps [occ -> gre], then greOccName gre = occNB: greOccName gre is usually the same as nameOccName (greMangledName gre), but not always in the case of record selectors; see Note [GreNames]+ghc0Local Reader Environment See Note [LocalRdrEnv]+ghc Reader NameDo not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as +Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.  `bar` ( ~ ) :  ,  '(' or '[' or '[:' ,  ')' or ']' or ':]',,  '`' ,  ,+ghcUnqualified name1Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a + with ++ghcQualified name)A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are Bar.x, Bar.y or Bar.Foo. Create such a + with ++ghc Original name$An original name; the module is the defining module. This is used when GHC generates code that will be fed into the renamer (e.g. from deriving clauses), but where we want to say "Use Prelude.map dammit". One of these can be created with ++ghc Exact nameWe know exactly the . This is used: ,When the parser parses built-in syntax like [] and (,), but wants a + from it8By Template Haskell, when TH has generated a unique nameSuch a + can be created by using + on a +ghcMake a qualified +& in the given namespace and where the   and the   are taken from the first and second elements of the tuple respectively+ghcmake a + where all the elements point to the same Provenance (useful for "hiding" imports, or imports with no details).+ghcSee Note [GreNames]+ghcA - for the GRE for internal use. Careful: the   of this $ is not necessarily the same as the + (see Note [GreNames]).+ghcA 3 for the GRE suitable for output to the user. Its   will be the + (see Note [GreNames]).+ghc.The SrcSpan of the name pointed to by the GRE.+ghc>The module in which the name pointed to by the GRE is defined.+ghcTakes a list of distinct GREs and folds them into AvailInfos. This is more efficient than mapping each individual GRE to an AvailInfo and the folding using *& but needs the uniqueness assumption.+ghcLook for this + in the global environment. Omits record fields without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).+ghcLook for this + in the global environment. Includes record fields without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).+ghcLook for precisely this  in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same  .+ghcLook for precisely this * in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same  .+ghcLook for a particular record field selector in the environment, where the selector name and field label may be different: the GlobalRdrEnv is keyed on the label. See Note [GreNames] for why this happens.+ghcLook for precisely this ! in the environment, but with an  % that might differ from that of the . See + and Note [GreNames].+ghcIs this a record field defined with DuplicateRecordFields? (See Note [GreNames])+ghcIs this a record field defined with NoFieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)+ghcIs this a record field defined with FieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)+ghc2Returns the field label of this GRE, if it has one+ghc>Test if an unqualified version of this thing would be in scope+ghc2Takes a list of GREs which have the right OccName x: Pick those GREs that are in scope * Qualified, as 4 if want_qual is Qual M _ * Unqualified, as x if want_unqual is Unqual _Return each such GRE, with its ImportSpecs filtered, to reflect how it is in scope qualified or unqualified respectively. See Note [GRE filtering]+ghcPick GREs that are in scope *both* qualified *and* unqualified Return each GRE that is, as a pair (qual_gre, unqual_gre) These two GREs are the original GRE with imports filtered to express how it is in scope qualified an unqualified respectively9Used only for the 'module M' item in export list; see ghcisBuiltInSyntax filter out names for built-in syntax They just clutter up the environment (esp tuples), and the parser will generate Exact RdrNames for them, so the cluttered envt is no use. Really, it's only useful for GHC.Base and GHC.Tuple.+ghc>Apply a transformation function to the GREs for these OccNames+ghcIs in scope unqualified?+ghc,Is in scope qualified with the given module?+ghcPrint out one place where the name was define/imported (With -dppr-debug, print them all)+ghc.Indicate if the given name is the "@" operator++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++******+++***************+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++******+++***************+++++ Safe-Inferred%P+ghc$The name the module is imported with+ghc#the source span of the whole import+ghcwhether this is a safe import+ghc"whether this is an "hiding" import+ghc(all the things the module could provide.4NB. BangPattern here: otherwise this leaks. (#15111)+ghc"whether this is a qualified import+ghcIf a module was "imported" by the user, we associate it with more detailed usage information +; a module imported by the system only gets used for usage information.+ghcRecords the modules directly imported by a module for extracting e.g. usage information, and also to give better error message +++++++++++++ +++++++++++++ Safe-Inferred9+e9ghcA collection of annotations9ghcThe kind of annotation target found in the middle end of the compiler9ghcAn annotation target9ghcWe are annotating something with a name: a type or identifier9ghc%We are annotating a particular module9ghcRepresents an annotation after it has been sufficiently desugared from it's initial form of 9ghcThe target of the annotation9ghc An empty annotation environment.9ghcConstruct a new annotation environment that contains the list of annotations provided.9ghc,Add the given annotation to the environment.9ghc"Union two annotation environments.9ghc5Find the annotations attached to the given target as  values of your choice. If no deserializer is specified, only transient annotations will be returned.9ghc5Find the annotations attached to the given target as  values of your choice. If no deserializer is specified, only transient annotations will be returned.ghcFind payloads for the given 9 in an 9.9ghcDeserialize all annotations of a given type. This happens lazily, that is no deserialization will take place until the [a] is actually demanded and the [a] can also be empty (the UniqFM is not filtered).9ghcThe "payload" of an annotation allows recovery of its value at a given type, and can be persisted to an interface file9999999999999999999999999999999999 Safe-Inferred 79`֒,ghcCaptures the sort order of sub elements. This is needed when the sub-elements have been split (as in a HsLocalBind which holds separate binds and sigs) or for infix patterns where the order has been re-arranged. It is captured explicitly so that after the Delta phase a SrcSpan is used purely as an index into the annotations, allowing transformations of the AST including the introduction of new Located items or re-arranging existing ones.,ghcexact print annotation used for capturing the locations of annotations in pragmas.,ghcA , can capture the locations of surrounding adornments, such as parens or backquotes. This data type identifies what particular pair are being used.,ghc'(' ')',ghc '(#' '#)',ghc'`',ghc'[' ']',ghcexact print annotations for a RdrName. There are many kinds of adornment that can be attached to a given RdrName. This type captures them, as detailed on the individual constructors.,ghc&Used for a name with an adornment, so `foo`, (bar),ghc Used for (,,,), or @(,,,)#,ghc Used for  (# | | #),ghc Used for (), (##), [],ghc Used for ->, as an identifier,ghc Used for an item with a leading '1. The annotation for unquoted item is stored in ,.,ghcUsed when adding a , to an existing ,' which has no Api Annotation (via the , constructor.,ghcExact print annotation for the Context data type.,ghclocation and encoding of the '=>' , if present.,ghc!zero or more opening parentheses.,ghc!zero or more closing parentheses.,ghc$Detail of the "brackets" used in an , exact print annotation.,ghc'(', ')',ghc '(#', '#)',ghc'[', ']',ghcexact print annotation for an item having surrounding "brackets", such as tuples or lists,ghcAnnotation for the "container" of a list. This captures surrounding items such as braces if present, and introductory keywords such as 'where'.,ghc#start point of a list having layout,ghccontext, such as 'where' keyword,ghc)items appearing after the list, such as '=>' for a context,ghcAnnotation for items appearing in a list. They can have one or more trailing punctuations items, such as commas or semicolons.,ghcCaptures the location of punctuation occurring between items, normally in a list. It is captured as a trailing annotation.,ghc Trailing ';',ghc Trailing ',',ghc Trailing '|',ghcGeneral representation of a 0 type carrying a parameterised annotation type.,ghc,We mostly use 'SrcSpanAnn'' with an 'EpAnn'',ghc&The 'SrcSpanAnn'' type wraps a normal , together with an extra annotation type. This is mapped to a specific  usage in the AST through the XRec and Anno type families.,ghcWhen we are parsing we add comments that belong a particular AST element, and print them together with the element, interleaving them into the output stream. But when editing the AST to move fragments around it is useful to be able to first separate the comments into those occurring before the AST element and those following it. The , constructor is used to do this. The GHC parser will only insert the , form.,ghc'If tools modify the parsed source, the , variant can directly provide the spacing for this item relative to the previous one when printing. This allows AST fragments with a particular anchor to be freely moved, without worrying about recalculating the appropriate anchor span.,ghcAn , records the base location for the start of the syntactic element holding the annotations, and is used as the point of reference for calculating delta positions for contained annotations. It is also normally used as the reference point for the spacing of the element relative to its container. If it is moved, that relationship is tracked in the , instead.,ghcBase location for the start of the syntactic element holding the annotations.,ghcThe exact print annotations (EPAs) are kept in the HsSyn AST for the GhcPs phase. We do not always have EPAs though, only for code that has been parsed as they do not exist for generated code. This type captures that they may be missing.A goal of the annotations is that an AST can be edited, including moving subtrees from one place to another, duplicating them, and so on. This means that each fragment must be self-contained. To this end, each annotated fragment keeps track of the anchor position it was originally captured at, being simply the start span of the topmost element of the ast fragment. This gives us a way to later re-calculate all Located items in this layer of the AST, as well as any annotations captured. The comments associated with the AST fragment are also captured here.The , type parameter allows this general structure to be specialised to the specific set of locations of original exact print annotation elements. So for HsLet we havetype instance XLet GhcPs = EpAnn AnnsLet data AnnsLet = AnnsLet { alLet :: EpaLocation, alIn :: EpaLocation } deriving DataThe spacing between the items under the scope of a given EpAnn is normally derived from the original ,. But if a sub-element is not in its original position, the required spacing can be directly captured in the , field of the , Anchor. This allows us to freely move elements around, and stitch together new AST fragments out of old ones, and have them still printed out in a precise way.,ghc?No Annotation for generated code, e.g. from TH, deriving, etc.,ghcBase location for the start of the syntactic element holding the annotations.,ghcAnnotations added by the Parser,ghc6Comments enclosed in the SrcSpan of the element this , is attached to,ghcSpacing between output items when exact printing. It captures the spacing from the current print position on the page to the position required for the thing about to be printed. This is either on the same line in which case is is simply the number of spaces to emit, or it is some number of lines down, with a given column offset. The exact printing algorithm keeps track of the column offset pertaining to the current anchor position, so the ,5 is the additional spaces to add in this case. See  8https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations for details.,ghcdeltaLine should always be > 0,ghcTokens embedded in the AST have an EpaLocation, unless they come from generated code (e.g. by TH).,ghcThe anchor for an ,. The Parser inserts the , variant, giving the exact location of the original item in the parsed source. This can be replaced by the , version, to provide a position for the item relative to the end of the previous item in the source. This is useful when editing an AST prior to exact printing the changed one. The list of comments in the , variant captures any comments between the prior output and the thing being marked here, since we cannot otherwise sort the relative order.,ghc$Captures an annotation, storing the ,2 and its location. The parser only ever inserts , fields with a RealSrcSpan being the original location of the annotation in the source file. The , can also store a delta position if the AST has been modified and needs to be pretty printed again. The usual way an , is created is using the mj ("make jump") function, and then it can be inserted into the appropriate annotation.,ghc;a docstring that can be pretty printed using pprHsDocString,ghc(doc options (prune, ignore-exports, etc),ghccomment starting by "--",ghccomment in {- -},ghc)empty comment, capturing location of EOF,ghc?The location of the prior token, used in exact printing. The , appears as an , containing its location. The difference between the end of the prior token and the start of this location is used for the spacing when exact printing the comment.,ghc'-ghc'=>', unicode variant-ghc'::'-ghc'::', unicode variant-ghck-ghc'..'-ghcUnicode variant-ghcfor function name in matches where there are multiple equations for the function.-ghc for CType-ghc'infix' or 'infixl' or 'infixr'-ghc'<-'-ghc'<-', unicode variant-ghcThe E unicode arrow-ghc -ghc;where a name loses its location in the AST, this carries it-ghc'{-# DEPRECATED' etc. Opening of pragmas where the capitalisation of the string can be changed by the user. The actual text used is stored in a  SourceText on the relevant pragma item.-ghc'(|'-ghc'(|', unicode variant-ghc'{'-ghc'[e|' or '[e||'-ghc'[|'-ghc'[|', unicode variant-ghc'('-ghc'['-ghc'(#'-ghcprefix  -- TemplateHaskell-ghcprefix   -- TemplateHaskell-ghc% -- for HsExplicitMult-ghc'%1' -- for HsLinearArrow-ghc->-ghc->, unicode variant-ghc';'-ghc'''-ghcstatic-ghc double '''-ghcC-ghc() for types-ghc e.g. INTEGER-ghc*String value, will need quotes when output-ghc'|'-ghcvia-ghc-<-ghc-<, unicode variant-ghc->-ghc->, unicode variant-ghc-<<-ghc-<<, unicode variant-ghc>>--ghc>>-, unicode variant-ghc;Convert a normal annotation into its unicode equivalent one-ghcSmart constructor for a ,+. It preserves the invariant that for the , constructor , is always > 0.-ghc%Used in the parser only, extract the  from an ,!. The parser will never insert a ,#, so the partial function is safe.-ghc Maps the , to the related opening and closing AnnKeywordId. Used when actually printing the item.-ghc Convert a , to an ,-ghc,Helper function used in the parser to add a ," items to an existing annotation.-ghc,Helper function used in the parser to add a ," items to an existing annotation.-ghcHelper function used in the parser to add a comma location to an existing annotation.-ghcHelper function (temporary) during transition of names Discards any annotations-ghcHelper function (temporary) during transition of names Discards any annotations-ghcHelper function (temporary) during transition of names Discards any annotations-ghcHelper function (temporary) during transition of names Discards any annotations.ghcShort form for ,.ghcThe annotations need to all come after the anchor. Make sure this is the case.ghcThe annotations need to all come after the anchor. Make sure this is the case..ghcCombine locations from two % things and add them to a third thing.ghcAdd additional comments to a ,, used for manipulating the AST prior to exact printing the changed one..ghc#Replace any existing comments on a ,, used for manipulating the AST prior to exact printing the changed one..ghcAdd additional comments, used for manipulating the AST prior to exact printing the changed one..ghcReplace any existing comments, used for manipulating the AST prior to exact printing the changed one..ghcTransfer comments and trailing items from the annotations in the first ,! argument to those in the second..ghcRemove the exact print annotations payload, leaving only the anchor and comments..ghcRemove the comments, leaving the exact print annotations payload,ghc!Api Annotations for comments only,-------,,,----------------------------------------------------------------------------------------------,,,,,,,,,,,,,-,,,,,,,,--,,,,,,,,--,,,,,,,,,,,,,--.,,,,,,-...,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+,,,,,,,,------------------...................................,-------,,,----------------------------------------------------------------------------------------------,,,,,,,,,,,,,-,,,,,,,,--,,,,,,,,--,,,,,,,,,,,,,--.,,,,,,-...,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+,,,,,,,,------------------................................... Safe-Inferred 79:;e//////////////////////////////////////// Safe-Inferredf9ghcUsed when we want to fingerprint a structure without depending on the fingerprints of external Names that it refers to.999999 Safe-Inferred )*/167j/ghc1Constraint type to bundle up the requirement for   on both the id and the  of it. See Note [NoGhcTc]./ghc.Maps the "normal" id type for a given GHC pass/ghcAllows us to check what phase we're in at GHC's runtime. For example, this class allows us to write > f :: forall p. IsPass p => HsExpr (GhcPass p) -> blah > f e = case ghcPass @p of > GhcPs -> ... in this RHS we have HsExpr GhcPs... > GhcRn -> ... in this RHS we have HsExpr GhcRn... > GhcTc -> ... in this RHS we have HsExpr GhcTc... which is very useful, for example, when pretty-printing. See Note [IsPass]./ghcUsed as a data type index for the hsSyn AST; also serves as a singleton type for PassghcMarks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur. See Note [NoGhcTc]//////////////////////////////////////////// Safe-Inferred 67t^/ghc4Maps of docs that were added via Template Haskell's putDoc./ghc4The added module header documentation, if it exists./ghc(The documentation added to declarations./ghc.The documentation added to function arguments./ghc6The documentation added to class and family instances./ghcModule header./ghcDocs for declarations: functions, data types, instances, methods etc. A list because sometimes subsequent haddock comments can be combined into one/ghc>Docs for arguments. E.g. function arguments, method arguments./ghcMap from chunk name to content.This map will be empty unless we have an explicit export list from which we can reference the chunks./ghcHaddock options from OPTIONS_HADDOCK or from  -haddock-opts./ghcThe ! used in the module, for example ./ghc7The full set of language extensions used in the module./ghcA simplified version of ./ghcAnnotate a value with the probable identifiers found in it These will be used by haddock to generate links.The identifiers are bundled along with their location in the source file. This is useful for tooling to know exactly where they originate.This type is currently used in two places - for regular documentation comments, with a set to <, and for adding identifier information to warnings, where a is  StringLiteral/ghc8A docstring with the (probable) identifiers found in it./ghcExtract a mapping from the lexed identifiers to the names they may correspond to./ghcPretty print a thing with its doc The docstring will include the comment decorators '-- |', '{-|' etc and will come either before or after depending on how it was written i.e it will come after the thing if it is a '-- ^' or '{-^' and before otherwise./ghcSee  pprWithHsDoc/ghc6Print a doc with its identifiers, useful for debugging/ghcFor compatibility with the existing @-ddump-parsed' output, we only show the docstring.Use pprHsDoc to show / 's internals./ghcWe might re-export avails from multiple modules with a single export declaration. E.g. when we have 7module M (module X) where import R0 as X import R1 as X;//////////////////////////////////"////////////////////////////////// Safe-Inferred 7" ghcIndicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently./ghc(Located name with possible adornment - s :  , /ghcA name in an import or export specification which may have adornments. Used primarily for accurate pretty printing of ParsedSource, and API Annotation placement. The : is the location of the adornment in the original source./ghcno extra/ghc pattern X/ghc type (:+:)/ghc2Wildcard in an import or export sublist, like the .. in import Mod ( T(Mk1, Mk2, ..) ).0ghcno wildcard in this list0ghc6wildcard after the given # of items in this list The Int< is in the range [0..n], where n is the length of the list.0ghcImported or exported entity.0ghcImported or Exported Variable0ghc+Imported or exported Thing with Absent list+The thing is a Class/Type (can't tell) - s : , ,0ghc8Imported or exported Thing with All imported or exportedThe thing is a Class"Type and the All refers to methods constructorss :  , ,#, 0ghc:Imported or exported Thing With given imported or exportedThe thing is a Class/Type and the imported or exported things are methods/constructors and record fields; see Note [IEThingWith] - s : %, %, %, 0ghc$Imported or exported module contents (Export Only)s : 0ghcDoc section heading0ghcSome documentation0ghcReference to named doc0ghcLocated Import or Export0ghc>Whether the import list is exactly what to import, or whether hiding was used, and therefore everything but what was listed should be imported0ghcImport DeclarationA single Haskell import declaration.0ghcs,  for ideclSource,, ,, ,, - attached to location in ideclImportList0ghc Module name.0ghcPackage qualifier.0ghcIsBoot  = {-# SOURCE #-} import0ghcTrue => safe import0ghcIf/how the import is qualified.0ghc as Module0ghc5Explicit import list (EverythingBut => hiding, names)0ghcIf/how an import is  qualified.0ghc qualified! appears in prepositive position.0ghc qualified" appears in postpositive position.0ghcNot qualified.0ghcLocated Import Declaration0ghcWhen in a list this may have : 0ghcWhen in a list this may have : * ///////00000000000000000000000000000000*00000 0000000000000000000000000/00////// Safe-Inferred1679ghcGHC generates an 0 to represent the invisible `import Prelude` that appears in any file that omits `import Prelude`, setting this field to indicate that the import doesn't appear in the original source. True => implicit import (of Prelude)9ghcGiven two possible located  qualified tokens, compute a style (in a conforming Haskell program only one of the two can be not J). This is called from  GHC.Parser.9ghcConvenience function to answer the question if an import decl. is qualified. 000000000000/////000000000000000000//0099999999999999999999999999999999999999999999999999 Safe-Inferred 67<0ghc Warning information for a module0ghcNothing deprecated0ghcWhole module deprecated0ghcSome specific things deprecated0ghc Warning Text6reason/explanation from a WARNING or DEPRECATED pragma0ghcConstructs the cache for the  mi_warn_fn field of a ModIface 00000000000 00000000000 Safe-Inferred )*17?ghc,For now, we work only with nominal equality.?ghccoaxrProves returns Nothing when it doesn't like the supplied arguments. When this happens in a coercion that means that the coercion is ill-formed, and Core Lint checks for that.?ghc-A more explicit representation for `t1 ~ t2`.?ghcA ?: is a "coercion constructor", i.e. a named equality axiom.?ghcThe  [CoAxBranch] passed into the mapping function is a list of all previous branches, reversed???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????? Safe-Inferred@ghcInformation about an associated type family default implementation. This is used solely for validity checking. See (Note [Type-checking default assoc decls] in  GHC.Tc.TyCl."@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@| Safe-Inferreda%ghcThe class of a register. Used in the register allocator. We treat all registers in a class as being interchangeable.%%%%%%%%} Safe-Inferred%ghc"A register, either virtual or real%ghcRealRegs are machine regs which are available for allocation, in the usual way. We know what class they are, because that's part of the processor's architecture.%ghc4An identifier for a primitive real machine register.%ghcThe patch function supplied by the allocator maps VirtualReg to RealReg regs, but sometimes we want to apply it to plain old Reg.%ghcPrint a reg in a generic manner If you want the architecture specific names, then use the pprReg function from the appropriate Ppr module.%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Safe-Inferred Safe-Inferred Safe-Inferred֢ghc"A subcomponent of another registerڢghcA register of some classghcWorst case displacementa node N of classN has some number of neighbors, all of which are from classC.(worst neighbors classN classC) is the maximum number of potential colors for N that can be lost by coloring its neighbors.This should be hand coded/cached for each particular architecture, because the compute time is very long..ghcFor a node N of classN and neighbors of classesC (bound classN classesC) is the maximum number of potential colors for N that can be lost by coloring its neighbors.ghcThe total squeese on a particular node with a list of neighbors.A version of this should be constructed for each particular architecture, possibly including uses of bound, so that aliased registers don't get counted twice, as per the paper.ghcpowerset (for lists)ghcpowersetLS (list of sets)ghcso we can put regs in UniqSetsݢޢߢڢۢܢ֢עآ٢ݢޢߢڢۢܢ֢עآ٢ Safe-Inferredghc!Determine the class of a registerghc4Determine all the regs that make up a certain class.ghcDetermine the common name of a reg returns Nothing if this reg is not part of the machine.ghc!Which regs alias what other regs.ghcOptimised versions of RegColorBase.{worst, squeese} specific to x86 Safe-Inferred9ghcShould this name be considered in-scope, even though it technically isn't?This ensures that we don't filter out information because, e.g., Data.Kind.Type isn't imported. See Note [pretendNameIsInScope].0515711117777777776777776865801874666410033333333330514955331526665808003343434444444533333422444444444444444444444444444444444444433334444434444333444433444433335555555544453333334444444443433335555555555553333443333333333333444444444444444444444443333333333333333333333333334444445555555555522222444445554455555444444444222222222222222333333333333333333333333333301100100111111111111111111111111111111111111111111111111111111111111111111111111111111112222111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222275825557776776666666666666666666666666667777777777777777788878888888558585858885853335558588833887778788588833333999999999999999999999999999998889999999999999999999999999999999965755558888899558888885676776767777777677756668888888878888566777767885885888858888888885555555458678888855556666666858888888888855555856887566856767877555555555555555555555555555665665666666666666666666666666666666666666666666666666666666666666667777777777777777777777777777777777777777777777777777777788888788888888888888888888889999990515711117777777776777776865801874666410033333333330514955331526665808003343434444444533333422444444444444444444444444444444444444433334444434444333444433444433335555555544453333334444444443433335555555555553333443333333333333444444444444444444444443333333333333333333333333334444445555555555522222444445554455555444444444222222222222222333333333333333333333333333301100100111111111111111111111111111111111111111111111111111111111111111111111111111111112222111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222275825557776776666666666666666666666666667777777777777777788878888888558585858885853335558588833887778788588833333999999999999999999999999999998889999999999999999999999999999999965755558888899558888885676776767777777677756668888888878888566777767885885888858888888885555555458678888855556666666858888888888855555856887566856767877555555555555555555555555555665665666666666666666666666666666666666666666666666666666666666666667777777777777777777777777777777777777777777777777777777788888788888888888888888888889999997 Safe-Inferred 7ghcTyCons represent type constructors. Type constructors are introduced by things such as:1) Data declarations: data Foo = ... creates the Foo type constructor of kind *2) Type synonyms: type Foo = ... creates the Foo type constructor 3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *4) Class declarations: class Foo where creates the Foo type constructor of kind *This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.If you edit this type, you may need to update the GHC formalism See Note [GHC Formalism] in GHC.Core.LintghcName of the constructorghcMake a  for the Typeable* representation of the given wired-in typeghc Is this the  for an unboxed tuple?ghc Does this  represent a tuple?NB: when compiling  Data.Tuple, the tycons won't reply True to , because they are built as  AlgTyCons. However they get spat into the interface file as tuple tycons, so I don't think it matters.@ghcPaints a picture of what a  represents, in broad strokes. This is used towards more informative error messages.@ghc e.g., the (->) .@ghcA @ is an abstraction of a type. It contains information that the code generator needs in order to pass arguments, return results, and store values of this type. See also Note [RuntimeRep and PrimRep] in GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.@ghcUnlifted pointer@ghcSigned, 8-bit value@ghcSigned, 16-bit value@ghcSigned, 32-bit value@ghcSigned, 64 bit value@ghcSigned, word-sized value@ghcUnsigned, 8 bit value@ghcUnsigned, 16 bit value@ghcUnsigned, 32 bit value@ghcUnsigned, 64 bit value@ghcUnsigned, word-sized value@ghcA pointer, but not) to a Haskell value (use '(Un)liftedRep')@ghcA vector@ghc;Information pertaining to the expansion of a type synonym (type)@ghcRepresents an open type family without a fixed right hand side. Additional instances can appear at any time.7These are introduced by either a top level declaration: data family T a :: *Or an associated data type declaration, within a class declaration: !class C a b where data T b :: *Aghc"An open type synonym family e.g. type family F x y :: * -> *Aghc$A closed type synonym family e.g. &type family F x where { F Int = Bool }AghcA closed type synonym family declared in an hs-boot file with type family F a where ..Aghc0Built-in type family used by the TypeNats solverAghcDescribes the flavour of an algebraic type constructor. For classes and data families, this flavour includes a reference to the parent .AghcAn ordinary algebraic type constructor. This includes unlifted and representation-polymorphic datatypes and newtypes and unboxed tuples, but NOT unboxed sums; see UnboxedSumTyCon.AghcAn unboxed sum type constructor. This is distinct from VanillaAlgTyCon because we currently don't allow unboxed sums to be Typeable since there are too many of them. See #13276.AghcType constructors representing a class dictionary. See Note [ATyCon for classes] in GHC.Core.TyCo.RepAghcType constructors representing an *instance* of a *data* family. Parameters:1) The type family in question*2) Instance types; free variables are the A of the current  (not the family one). INVARIANT: the number of types matches the arity of the family 3) A CoTyCon identifying the representation type with the type instance familyAghcSome promoted datacons signify extra info relevant to GHC. For example, the @ constructor of A corresponds to the @ constructor of @. This data structure allows us to store this information right in the 6. The other approach would be to look up things like A's @ by known-key every time. See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepTypeAghcan ordinary promoted data conAghcA constructor of A. The argument to the function should be the list of arguments to the promoted datacon.AghcA constructor of AAghcA constructor of AAghcA constructor of AAghcRepresents right-hand-sides of s for algebraic typesAghcSays that we know nothing about this data type, except that it's represented by a pointer. Used when we export a data type abstractly into an .hi file.AghcInformation about those s derived from a data declaration. This includes data types with no constructors at all.AghcAn unboxed sum type.AghcInformation about those s derived from a newtype declarationAghcThe data type constructors; can be empty if the user declares the type to have no constructors'INVARIANT: Kept in order of increasing #/ tag (see the tag assignment in mkTyConTagMap)AghcCached value: length data_consAghcCached value: is this an enumeration type? See Note [Enumeration types]AghcL if the data type constructor has a known, fixed levity when fully applied to its arguments, False otherwise.This can only be I with UnliftedDatatypes, e.g. 5data A :: TYPE (BoxedRep l) where { MkA :: Int -> A }This boolean is cached to make it cheaper to check for levity and representation-polymorphism in tcHasFixedRuntimeRep.AghcThe unique constructor for the newtype. It has no existentialsAghc.Is this a boxed, unboxed or constraint tuple?AghcCached value: the argument type of the constructor, which is just the representation type of the  (remember that newtypes do not exist at runtime so need a different representation type). The free s of this type are the A from the corresponding Aghc Same as the A0, but this time eta-reduced. Hence the list of ?s in this field may be shorter than the declared arity of the .AghcL if the newtype has a known, fixed representation when fully applied to its arguments, I# otherwise. This can only ever be I with UnliftedNewtypes.Example: newtype N (a :: TYPE r) = MkN a=Invariant: nt_fixed_rep nt = tcHasFixedRuntimeRep (nt_rhs nt)This boolean is cached to make it cheaper to check if a variable binding is representation-polymorphic in tcHasFixedRuntimeRep.ghc"Algebraic data types, from - data declarations - newtype declarations - data instance declarations - type instance declarations - the TyCon generated by a class declaration - boxed tuples - unboxed tuples - constraint tuples - unboxed sums Datanewtypetype families are handled by . See A for more information.ghcRepresents type synonymsghcRepresents families (both type and data) Argument roles are all NominalghcPrimitive types; cannot be defined in Haskell. This includes the usual suspects (such as Int#0) as well as foreign-imported types and kinds (*, #, and ?)ghc%Represents promoted data constructor.ghcThese exist only during type-checking. See Note [How TcTyCons work] in  GHC.Tc.TyClghcThe C type that should be used for this type when using the FFI and CAPIghcWas the data type declared with GADT syntax? If so, that doesn't mean it's a true GADT; only that the "where" form was used. This field is used only to guide pretty-printingghcThe "stupid theta" for the data type (always empty for GADTs). A "stupid theta" is the context to the left of an algebraic type declaration, e.g. Eq a in the declaration data Eq a => T a .... See Note [The stupid context] in GHC.Core.DataCon.ghcContains information about the data constructors of the algebraic typeAghc,Maps a label to information about the fieldghcThe flavour of this algebraic tycon. Gives the class or family declaration  for derived 8s representing class or family instances, respectively.ghc8Contains information about the expansion of the synonymghcName of result type variable, used for pretty-printing with --show-iface and for reifying TyCon in Template HaskellghcType family flavour: open, closed, abstract, built-in. See comments for FamTyConFlavghcFor *associated* type/data families The class tycon in which the family is declared See Note [Associated families and their parent class]ghcis this a type family injective in its type variables? Nothing if no injectivity annotation was givenghcThe Typeable' representation. A cached version of  ( tc).ghcCorresponding data constructorghcSee comments with AghcScoped tyvars over the tycon's body The range is always a skolem or TcTyVar, be MonoTcTyCon only: see Note [Scoped tyvars in a TcTyCon]ghcIs this TcTyCon already generalized? Used only to make zonking more efficientghc What sort of  this represents.AghcA Unique of this TyCon. Invariant: identical to Unique of Name stored in tyConName field.Aghc Full bindersAghc Result kindAghc TyVar bindersAghcKind of this TyConAghcArityAghcA pre-allocated TyConApp tycon []AghcThe role for each type variable This list has length = tyConArity See also Note [TyCon Role signatures]AghcMake a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent setAghc(mkTyConTy tc) returns (TyConApp tc []) but arranges to share that TyConApp among all calls See Note [Sharing nullary TyConApps] So it's just an alias for tyConNullaryTy!Aghc Create an A from the data constructors, for a potentially levity-polymorphic datatype (with UnliftedDatatypes).Aghc Create an A from the data constructors.Use mkLevPolyDataConRhs if the datatype can be levity-polymorphic or if it comes from a "data type" declarationAghcExtract those #s that we are able to learn about. Note that visibility in this sense does not correspond to visibility in the context of any particular user program!ghcChecks the invariants of a A/ given the appropriate type class name, if anyAghcThe name (and defining module) for the Typeable representation (TyCon) of a type constructor.&See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.AghcThe size of a @ in bytes.This applies also when used in a constructor, where we allow packing the fields. For instance, in data Foo = Foo Float# Float# the two fields will take only 8 bytes, which for 64-bit arch will be equal to 1 word. See also mkVirtHeapOffsetsWithPadding for details of how data fields are laid out.AghcReturn if Rep stands for floating type, returns Nothing for vector types.Aghc-The labels for the fields of this particular ghc-The labels for the fields of this particular Aghc(Look up a field label belonging to this ghcMake a map from strings to FieldLabels from all the data constructors of this algebraic tyconAghc#This is the making of an algebraic .AghcSimpler specialization of A for classesAghcMakes a tycon suitable for use during type-checking. It stores a variety of details about the definition of the TyCon, but no right-hand side. It lives only during the type-checking of a mutually-recursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See also Note [Kind checking recursive type and class declarations] in  GHC.Tc.TyCl.Aghc5No scoped type variables (to be used with mkTcTyCon).AghcCreate an primitive  , such as Int#, Type or  RealWorld# Primitive TyCons are marshalable iff not lifted. If you'd like to change this, modify marshalablePrimTyCon.AghcCreate a type synonym AghcCreate a type family Aghc#Create a promoted data constructor  Somewhat dodgily, we give it the same Name as the data constructor itself; when we pretty-print the TyCon we add a quote; see the Outputable TyCon instanceAghc Test if the 8 is algebraic but abstract (invisible data constructors)Aghc Does this 7 represent something that cannot be defined in Haskell?AghcReturns True if the supplied  resulted from either a data or newtype declarationAghcReturns True9 for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.AghcReturns True for data types that are  definitely represented by heap-allocated constructors. These are scrutinised by Core-level case: expressions, and they get info tables allocated for them.-Generally, the function will be true for all data types and false for newtype1s, unboxed tuples, unboxed sums and type family &s. But it is not guaranteed to return True in all cases that it could.%NB: for a data type family, only the instance 2s get an info table. The family declaration  does notAghc Was this  declared as "type data"? See Note [Type data declarations] in GHC.Rename.Module.AghcA is true of s for which this property holds (where r is the role passed in): If (T a1 b1 c1) ~r (T a2 b2 c2), then (a1 ~r1 a2), (b1 ~r2 b2), and (c1 ~r3 c2) (where r1, r2, and r3, are the roles given by tyConRolesX tc r) See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.CanonicalAghcA is true of s for which this property holds (where r is the role passed in): If (T tys ~r t), then (t's head ~r T). See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.CanonicalAghc Is this an A of a  that is generative and injective with respect to representational equality?AghcIs this  that for a newtypeAghcTake a  apart into the s it scopes over, the  it expands into, and (possibly) a coercion from the representation type to the newtype . Returns Nothing if this is not possible.Aghc Is this a * representing a regular H98 type synonym (type)?AghcIs this tycon neither a type family nor a synonym that expands to a type family?AghcIs this a forgetful type synonym? If this is a type synonym whose RHS does not mention one (or more) of its bound variables, returns True. Thus, False means that all bound variables appear on the RHS; True may not mean anything, as the test to set this flag is conservative.AghcTrue iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)It'd be unusual to call tyConMustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposableAghcIs this an algebraic  declared with the GADT syntax?AghcIs this an algebraic ( which is just an enumeration of values?Aghc Is this a ., synonym or otherwise, that defines a family?Aghc Is this a >, synonym or otherwise, that defines a family with instances?AghcIs this a synonym 1 that can have may have further instances appear?AghcIs this a synonym 1 that can have may have further instances appear?Aghc"Is this an open type family TyCon?Aghc0Is this a non-empty closed type family? Returns J( for abstract or empty closed families.AghcExtract type variable naming the result of injective type familyAghcA tc returns A is if tc is an injective tycon (where is states for which A tc is injective), or A otherwise.Aghc%Is this TyCon for an associated type?AghcGet the enclosing class TyCon (if there is one) for the given TyCon.AghcGet the enclosing class TyCon (if there is one) for the given TyConFlavourAghc Is this the  for a boxed tuple?Aghc Is this the  for an unboxed sum?Bghc T a .... See Note [The stupid context] in GHC.Core.DataCon.Bghc Extract the s bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.BghcExtract the information pertaining to the right hand side of a type synonym (type) declaration.BghcExtract the flavour of a type family (with all the extra information that it carries)BghcIs this  that for a class instance?BghcIf this  is that for a class instance, return the class it is for. Otherwise returns NothingBghc#Return the associated types of the , if anyBghcIs this ! that for a data family instance?BghcIf this  is that of a data family instance, return the family in question and the instance types. Otherwise, return NothingBghcIf this - is that of a data family instance, return a  which represents a coercion identifying the representation type with the type instance family. Otherwise, return NothingBghc Extract any RuntimeRepInfo from this TyConghcCan this flavour of  appear unsaturated?BghcIs this flavour of & an open type family or a data family?BghcReturns whether or not this  is definite, or a hole that may be filled in at some later point. See Note [Skolem abstract data] Aghc whether the # has a fixed levityghcTrue if this is a "type data" declaration See Note [Type data declarations] in GHC.Rename.ModuleAghcBinders of the ghc Result kindghcThe roles for each TyVarghc>The C type this type corresponds to when using the CAPI FFIghcStupid theta: see ghc#Information about data constructorsghc0What flavour is it? (e.g. vanilla, type family)ghcWas the  declared with GADT syntax?AghcResult kind of the ghc%Whether the tuple is boxed or unboxedAghcKind of the resulting Aghcresult kind onlyghcScoped type variables; see Note [How TcTyCons work] in GHC.Tc.TyClghc$Is this TcTyCon generalised already?ghc What sort of  this representsAghcresult kind Must answer L to isFixedRuntimeRepKind (i.e., no representation polymorphism). (If you need a representation-polymorphic PrimTyCon, change tcHasFixedRuntimeRep, marshalablePrimTyCon, reifyTyCon for PrimTyCons.)Aghcresult kindAghcresult kindBghc Arguments to ghc Returns a  substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application ^ Expand a type synonym application Return Nothing if the TyCon is not a synonym, or if not enough arguments are suppliedAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA@@AAAAAAAAAAAAA@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBAAABAAABBBBBAAAAAAAAAAAAAAAAAAAAAAABBBBBBBABBBBBBBBBABABBBBBABBBBBBBAABABABBB@@@BBBBABA@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA@@AAAAAAAAAAAAA@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBAAABAAABBBBBAAAAAAAAAAAAAAAAAAAAAAABBBBBBBAAAABBBBBBBBBAAAABABBBBBABBBBBBBAABABAAABBAB@@@BBBBABA@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAA Safe-Inferred ghc,True if there is a non-empty intersection. s1  s2 doesn't compute s2 if s1 is empty Safe-Inferred PKghcDeterministic TyCon Environment#See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM( for explanation why we need DTyConEnv.KghcTyCon Environment&KKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLL&KKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLL Safe-Inferred&Lghc Initialise a L with L.Lghc8The default upper bound (100) for the number of times a L is allowed to encounter each .Lghc1Change the upper bound for the number of times a L is allowed to encounter each .LLLLLLLLLL; Safe-Inferred7%A"ghcA collection of sghc0The key type representing kinds in the compiler.ghc/Type synonym used for types of kind RuntimeRep.ghcA type of the form p of constraint kind represents a value whose type is the Haskell predicate p/, where a predicate is what occurs before the => in a Haskell type.We use  as documentation to mark those types that we guarantee to have this kind.0It can be expanded into its representation, but:(The type checker must treat it as opaque1The rest of the compiler treats it as transparentConsider these examples: f :: (Eq a) => a -> Int g :: (?x :: Int -> Int) => a -> Int h :: (r\l) => {r} => {l::Int | r} Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"ghcMult is a type alias for Type.Mult must contain Type because multiplicity variables are mere type variables (of kind Multiplicity) in Haskell. So the simplest implementation is to make Mult be Type.Multiplicities can be formed with: - One: GHC.Types.One (= oneDataCon) - Many: GHC.Types.Many (= manyDataCon) - Multiplication: GHC.Types.MultMul (= multMulTyCon)So that Mult feels a bit more structured, we provide pattern synonyms and smart constructors for these.ghc&A shorthand for data with an attached  element (the multiplicity).ghcA semantically more meaningful type to represent what may or may not be a useful .ghcFor simplicity, we have just one UnivCo that represents a coercion from some type to some other type, with (in general) no restrictions on the type. The UnivCoProvenance specifies more exactly what the coercion really is and why a program should (or shouldn't!) trust the coercion. It is reasonable to consider each constructor of  as a totally independent coercion form; their only commonality is that they don't tell you what types they coercion between. (That info is in the B constructor of .ghcA  is concrete evidence of the equality/convertibility of two types.ghc creates a nullary C$. In general you should rather use :, which picks the shared nullary TyConApp from inside the TyCon (via tyConNullaryTy. But we have to build the TyConApp tc [] in that TyCon field; that's what  is for.ghcLike mkTyCoForAllTy, but does not check the occurrence of the binder See Note [Unused coercion variable in ForAllTy]Bghc>What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.Bghc.The returned env is used in the extended scopeBghcA coercion to be filled in by the type-checker. See Note [Coercion holes]Bghc>See Note [Phantom coercions]. Only in Phantom roled coercionsBghcFrom the fact that any two coercions are considered equivalent. See Note [ProofIrrelProv]. Can be used in Nominal or Representational coercionsBghcFrom a plugin, which asserts that this coercion is sound. The string is for the use of the plugin.Bghc;See Note [Coercion holes] Only present during typecheckingCghcA type labeled C might have knot-tied tycons in it. See Note [Type checking recursive type and class declarations] in  GHC.Tc.TyClCghc;Vanilla type or kind variable (*never* a coercion variable)Cghc+Type application to something other than a  . Parameters:1) Function: must not be a C or C, must be another C, or C See Note [Respecting definitional equality] (EQ1) about the no C requirement2) Argument typeCghcApplication of a , including newtypes and1 synonyms. Invariant: saturated applications of FunTyCon must use C and saturated synonyms must use their own constructors. However,  unsaturated FunTyCons do appear as Cs. Parameters:%1) Type constructor being applied to.2) Type arguments. Might not have enough type arguments here to saturate the constructor. Even type synonyms are not necessarily saturated; for example unsaturated type synonyms can appear as the right hand side of a type synonym.CghcA  type. Note [When we quantify over a coercion variable] INVARIANT: If the binder is a coercion variable, it must be mentioned in the Type. See Note [Unused coercion variable in ForAllTy]CghcFUN m t1 t2 Very common, so an important special case See Note [Function types]Cghc/Type literals are similar to type constructors.CghcA kind cast. The coercion is always nominal. INVARIANT: The cast is never reflexive (EQ2) INVARIANT: The Type is not a CastTy (use TransCo instead) (EQ3) INVARIANT: The Type is not a ForAllTy over a tyvar (EQ4) See Note [Respecting definitional equality]CghcInjection of a Coercion into a type This should only ever be used in the RHS of an AppTy, in the list of a TyConApp, when applying a promoted GADT data constructorCghc+Type synonym used for types of kind Levity.Cghc3The key representation of types within the compilerCghcMake nested arrow types | Special, common, case: Arrow type with mult ManyCghc/Wraps foralls over the type using the provided s from left to rightCghc/Wraps foralls over the type using the provided s from left to rightCghc+A view function that looks through nothing.CghcApply a function to both the Mult and the Type in a 'Scaled Type'CCCCCCCCCCCCCCCCCCC&&&&&&&&BBBBBBBBBBBBBBBBBBCCCCCCBBBBBBBBBBBBBBBCCBBBBBBCCCCCCCCCCCCCCCCCCCC!BBBBBBBCCCCCBCCCCCCCCCCCCCCCCCCCCC&&&&&&&&&&BBBBBBBBBBBBBBBBBBCCCCCCBBBBBBBBBBBBBBBCCBBBBBBCCCCCCCCCCCCCCCCCCCC!BBBBBBBCCCCCBCCC3C3C3 Safe-Inferred'׫ث٫ګ۫ܫݫޫ߫¬ìĬŬƬǬȬɬʬˬ̬ͬάϬЬѬҬӬԬլ֬׬ج٬ڬ۬ܬݬެ߬­íĭŭƭǭȭɭʭ˭̭ͭέϭЭѭҭӭԭխ֭׭ح٭ڭۭܭݭޭ߭®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ֮׮خٮڮۮܮݮޮ߮¯ïįůƯǯȯɯʯ˯̯ͯίϯЯѯүӯԯկ֯ׯدٯگۯܯݯޯ߯׫ث٫ګ۫ܫݫޫ߫¬ìĬŬƬǬȬɬʬˬ̬ͬάϬЬѬҬӬԬլ֬׬ج٬۬ܬ߬ڬެݬ­íĭŭƭǭ˭ȭ̭ͭέϭʭɭЭѭҭӭԭխ֭׭ح٭ڭۭܭݭޭ߭®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ֮׮خٮڮۮܮݮޮ߮¯ïįůƯǯȯɯʯ˯̯ͯίϯЯѯүӯԯկ֯ׯدٯگۯܯݯޯ߯ Safe-Inferred:lghcCreate a primitive  with the given , arguments of kind  with the given -s, and the given result kind representation.Only use this in GHC.Builtin.Types.Prim.ghcCreate a primitive nullary  with the given ! and result kind representation.Only use this in GHC.Builtin.Types.Prim.ghcCreate a primitive  like , except the last argument is levity-polymorphic, where the levity argument is implicit and comes before other argumentsOnly use this in GHC.Builtin.Types.Prim.Cghc Primitive s that are defined in GHC.Prim but not "exposed". See Note [Unexposed TyCons]Cghc Primitive 3s that are defined in, and exported from, GHC.Prim.DghcThe FUN type constructor. FUN :: forall (m :: Multiplicity) -> forall {rep1 :: RuntimeRep} {rep2 :: RuntimeRep}. TYPE rep1 -> TYPE rep2 -> Type The runtime representations quantification is left inferred. This means they cannot be specified with -XTypeApplications.This is a deliberate choice to allow future extensions to the function arrow.DghcGiven a Role, what TyCon is the type of equality predicates at that role?ghcroles of the arguments (must be non-empty), not including the implicit argument of kind A, which always has  roleghc(representation of the fully-applied typeCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCCCDDCDDCDDCDDCDDCDDCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCDDCDDCDDCDDCDDCDDCDDCDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEECCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCCCDDCDDCDDCDDCDDCDDCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCDDCDDCDDCDDCDDCDDCDDCDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE  Safe-InferredPEghcReturns free variables of types, including kind variables as a non-deterministic set. For type synonyms it does not expand the synonym.ghcGiven a list of tyvars returns a deterministic FV computation that returns the given tyvars with the kind variables free in the kinds of the given tyvars.EghcAdd the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.EghcAdd the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.EghcE that returns free variables of a type in a deterministic set. For explanation of why using '6 is not deterministic see Note [Deterministic FV] in  GHC.Utils.FV.EghcE that returns free variables of a type in deterministic order. For explanation of why using '6 is not deterministic see Note [Deterministic FV] in  GHC.Utils.FV.EghcReturns free variables of types, including kind variables as a deterministic set. For type synonyms it does not expand the synonym.EghcReturns free variables of types, including kind variables as a deterministically ordered list. For type synonyms it does not expand the synonym.EghcThe worker for E and tyCoFVsOfTypeList$. The previous implementation used ' which is O(n+m) and can make the function quadratic. It's exported, so that it can be composed with other functions that compute free variables. See Note [FV naming conventions] in  GHC.Utils.FV.Eta-expanded because that makes it run faster (apparently) See Note [FV eta expansion] in  GHC.Utils.FV for explanation.Eghc6Get a deterministic set of the vars free in a coercionEghcGiven a covar and a coercion, returns True if covar is almost devoid in the coercion. That is, covar can only appear in Refl and GRefl. See last wrinkle in Note [Unused coercion variable in ForAllCo] in GHC.Core.CoercionEghcRetrieve the free variables in this type, splitting them based on whether they are used visibly or invisibly. Invisible ones come first.Eghc Returns the free variables of a  that are in injective positions. Specifically, it finds the free variables while:Expanding type synonymsIgnoring the coercion in  (ty |> co)'Ignoring the non-injective fields of a CFor example, if F& is a non-injective type family, then: 9injectiveTyVarsOf( Either c (Maybe (a, F b c)) ) = {a,c} If E ty = itvs, then knowing ty fixes itvs. More formally, if a is in E ty and S1(ty) ~ S2(ty), then S1(a) ~ S2(a) , where S1 and S2 are arbitrary substitutions.See Note [When does a tycon application need an explicit kind signature?].Eghc Returns the free variables of a  that are in injective positions. Specifically, it finds the free variables while:Expanding type synonymsIgnoring the coercion in  (ty |> co)'Ignoring the non-injective fields of a CSee Note [When does a tycon application need an explicit kind signature?].EghcReturns the set of variables that are used invisibly anywhere within the given type. A variable will be included even if it is used both visibly and invisibly. An invisible use site includes: * In the kind of a variable * In the kind of a bound variable in a forall * In a coercion * In a Specified or Inferred argument to a function See Note [VarBndrs, ForAllTyBinders, TyConBinders, and visibility] in GHC.Core.TyCo.RepEghcLike E, but for many types.EghcDo a topological sort on a list of tyvars, so that binders occur before occurrences E.g. given [ a::k, k::*, b::k ] it'll return a well-scoped list [ k::*, a::k, b::k ]This is a deterministic sorting operation (that is, doesn't depend on Uniques).It is also meant to be stable: that is, variables should not be reordered unnecessarily. This is specified in Note [ScopedSort] See also Note [Ordering of implicit variables] in GHC.Rename.HsTypeEghc+Get the free vars of a type in scoped orderEghc*Get the free vars of types in scoped orderEghcAll type constructors occurring in the type; looking through type synonyms, but not newtypes. When it finds a Class, it returns the class TyCon.EghcShould we look under injective type families? See Note [Coverage condition for injective type families] in GHC.Tc.Instance.Family.Eghclook under injective type families? See Note [Coverage condition for injective type families] in GHC.Tc.Instance.Family.7EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE7EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE Safe-InferredU FghcThis tidies up a type for printing in an error message, or in an interface file.;It doesn't change the uniques at all, just the print names.Fghc Add the free s to the env in tidy form, so that we can tidy the type they are free inFghc Treat a new  as a binder, and give it a fresh tidy name using the environment if one has not already been allocated. See also FFghcTidy a list of Types-See Note [Strictness in tidyType and friends]Fghc Tidy a Type-See Note [Strictness in tidyType and friends]Fghc:Grabs the free type variables, tidies them and then uses F to work over the type itselfFghcCalls F= on a top-level type (i.e. with an empty tidying environment)FghcTidy a Coercion-See Note [Strictness in tidyType and friends]FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF Safe-Inferredr-EghcA substitution of s for &sEghcA substitution of s for s and s for &sEghcA substitution of Exprs for non-coercion sEghc!Type & coercion & id substitutionThe Subst data type defined in this module contains substitution for tyvar, covar and id. However, operations on IdSubstEnv (mapping from Id to CoreExpr%) that require the definition of the Expr data type are defined in GHC.Core.Subst to avoid circular module dependency.EghcComposes two substitutions, applying the second one provided first, like in function composition. This function leaves IdSubstEnv untouched because IdSubstEnv is not used during substitution for types.EghcChecks whether the tyvar and covar environments are empty. This function should be used over E when substituting for types, because types currently do not contain expressions; we can safely disregard the expression environment when deciding whether to skip a substitution. Using E gives us a non-trivial performance boost (up to 70% less allocation for T18223)EghcMake a TCvSubst with specified tyvar subst and empty covar substEghcMake a TCvSubst with specified covar subst and empty tyvar substEghcWhat to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.Fghc.The returned env is used in the extended scopeFghcThis is used only for TcTyCons a) To zonk TcTyCons b) To turn TcTyCons into TyCons. See Note [Type checking recursive type and class declarations] in  GHC.Tc.TyClghc Iterates ' until there is no more to synonym to expand. NB: coreFullView is non-recursive and can be inlined; core_full_view is the recursive one See Note [Inlining coreView].ghc Iterates ' until there is no more to synonym to expand. NB: coreFullView is non-recursive and can be inlined; core_full_view is the recursive one See Note [Inlining coreView].ghcexpandSynTyConApp_maybe tc tys! expands the RHS of type synonym tc instantiated at arguments tys , or returns J if tc is not a synonym.ghc A helper for 3 to avoid inlining this cold path into call-sites.Precondition: the call is saturated or over-saturated; i.e. length tvs <= length arg_tysFghcExpand out all type synonyms. Actually, it'd suffice to expand out just the ones that discard type variables (e.g. type Funny a = Int) But we don't know which those are currently, so we just expand all.F only expands out type synonyms mentioned in the type, not in the kinds of any TyCon or TyVar mentioned in the type.Keep this synchronized with synonymTyConsOfTypeghc&An INLINE helper for function such as F below.isTyConKeyApp_maybe key ty returns Just tys iff the type  ty = T tys*, where T's unique = key key must not be 5; to test for functions, use G:. Thanks to this fact, we don't have to pattern match on C here.FghcExtract the RuntimeRep classifier of a type from its kind. For example, kindRep * = LiftedRep; Panics if this is not possible. Treats * and Constraint as the sameFghcGiven a kind (TYPE rr) or (CONSTRAINT rr), extract its RuntimeRep classifier rr. For example,  kindRep_maybe * = Just LiftedRep Returns J% if the kind is not of form (TYPE rr)Fghc9Returns True if the kind classifies unlifted types (like 'Int#') and False otherwise. Note that this returns False for representation-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.FghcCheck whether a kind is of the form `TYPE (BoxedRep Lifted)` or `TYPE (BoxedRep Unlifted)`.Returns:/`Just Lifted` for `TYPE (BoxedRep Lifted)` and ,3`Just Unlifted` for `TYPE (BoxedRep Unlifted)` and  UnliftedType,J for anything else, e.g. `TYPE IntRep`, `TYPE (BoxedRep l)`, etc.FghcCheck whether a type of kind A is lifted.F is:True of LiftedRep :: RuntimeRepFalse of type variables, type family applications, and of other reps such as IntRep :: RuntimeRep.FghcCheck whether a type of kind A is unlifted.True of definitely unlifted As such as @, @, @, ... False of @,6False for type variables and type family applications.ghc'An INLINE helper for functions such as F and F.%Checks whether the type is a nullary  application, for a  with the given .FghcIs a tyvar of type A?FghcIs a tyvar of type A?FghcIs a tyvar of type  Multiplicity?Fghc(splitRuntimeRep_maybe rr) takes a Type rr :: RuntimeRep, and returns the (TyCon,[Type]) for the RuntimeRep, if possible, where the TyCon is one of the promoted DataCons of RuntimeRep. Remember: the unique on TyCon that is a a promoted DataCon is the same as the unique on the DataCon See Note [Promoted data constructors] in GHC.Core.TyCon May not be possible if rr1 is a type variable or type family applicationFghcSee .ghc`isBoxedRuntimeRep_maybe (rep :: RuntimeRep)` returns `Just lev` if rep% expands to `Boxed lev` and returns J otherwise.Types with this runtime rep are represented by pointers on the GC'd heap.FghcCheck whether a type of kind A! is lifted, unlifted, or unknown. `isLiftedRuntimeRep rr` returns:`Just Lifted` if rr is `LiftedRep :: RuntimeRep``Just Unlifted` if rr is definitely unlifted, e.g. @J if not known (e.g. it's a type variable or a type family application).Fghc levity_maybe takes a Type of kind Levity, and returns its levity May not be possible for a type variable or type family applicationFghc2Attempts to obtain the type variable underlying a , and panics with the given message if this is not a type variable type. See also 'Fghc2Attempts to obtain the type variable underlying a , without any expansionFghcIf the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind tyFghcAttempt to take a type application apart, whether it is a function, type constructor, or plain type application. Note that type family applications are NEVER unsaturated by this!Fghc1Attempts to take a type application apart, as in F%, and panics if this is not possibleFghcDoes the AppTy split as in F6, but assumes that any coreView stuff is already doneFghcJust like splitAppTyNoView_maybe, but does not split (c => t) See Note [Decomposing fat arrow c=>t]FghcRecursively splits a type as far as is possible, leaving a residual type being applied to and the type arguments applied to it. Never fails, even if that means returning an empty list of type applications.FghcLike F(, but doesn't look through type synonymsFghc>Is this a numeric literal. We also look through type synonyms.Fghc=Is this a symbol literal. We also look through type synonyms.Fghc;Is this a char literal? We also look through type synonyms.Fghc2Is this a type literal (symbol, numeric, or char)?FghcIs this type a custom user error? If so, give us the kind and the error message.Fghc=Render a type corresponding to a user type error into a SDoc.GghcGiven the components of a FunTy figure out the corresponding TyConApp.Gghc=Return Just if this TyConApp should be represented as a FunTyGghc?Return Just if this TyConAppCo should be represented as a FunCoGghcThis one works out the FunTyFlag from the argument type See GHC.Types.Var Note [FunTyFlag]Gghc=Like mkFunctionType, compute the FunTyFlag from the argumentsGghcAttempts to extract the multiplicity, argument and result types from a type, and panics if that is not possible. See also GGghcAttempts to extract the multiplicity, argument and result types from a typeGghcExtract the function result type and panic if that is not possibleGghc Just like G/ but for a single argument Try not to iterate ', because it's inefficient to substitute one variable at a time; instead use 'piResultTys"Extract the function argument type and panic if that is not possibleGghc(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn) where f :: f_ty G" is interesting because: 1. f_ty may have more for-alls than there are args 2. Less obviously, it may have fewer for-alls For case 2. think of: piResultTys (forall a.a) [forall b.b, Int] This really can happen, but only (I think) in situations involving undefined. For example: undefined :: forall a. a Term: undefined (forall b. b->b) Int This term should have type (Int -> Int), but notice that there are more type args than foralls in ds type.Gghc), as that's not a TyCon in the type-checker.Note that this may fail (in funTyConAppTy_maybe) in the case of a C" with an argument of unknown kind C0 (e.g. `FunTy (a :: k) Int`, since the kind of a isn't of the form `TYPE rep`. This isn't usually a problem but may be temporarily the cas during canonicalization: see Note [Decomposing FunTy] in GHC.Tc.Solver.Canonical and Note [The Purely Kinded Type Invariant (PKTI)] in GHC.Tc.Gen.HsType, Wrinkle around FunTyConsequently, you may need to zonk your type before using this function.Gghc Unwrap one layer of newtype on a type constructor and its arguments, using an eta-reduced version of the newtype2 if possible. This requires tys to have at least newTyConInstArity tycon elements.ghcLike ', but avoids checking the coercion for reflexivity, as that can be expensive.Gghc Make a dependent forall over an & variableGghcLike G, but tv should be a tyvarGghcLike C/, but assumes all variables are dependent and &, a common caseGghcLike G#, but tvs should be a list of tyvarGghcLike ,, but assumes the variable is dependent and &, a common caseGghcLike C/, but assumes all variables are dependent and &, a common caseGghcLike mkForAllTys, but assumes all variables are dependent and visibleGghcGiven a list of type-level vars and the free vars of a result kind, makes PiTyBinders, preferring anonymous binders if the variable is, in fact, not dependent. e.g. mkTyConBindersPreferAnon  k->k(k:*),(b:k),(c:k)- We want (k:*) Named, (b:k) Anon, (c:k) AnonAll non-coercion binders are visible.Gghc Bool -> Double) == [(Int, FTF_T_T), (Bool, FTF_T_T)] getRuntimeArgTys (Identity Int -> Bool -> Double) == [(Identity Int, FTF_T_T), (Bool, FTF_T_T)] getRuntimeArgTys (Int -> Identity (Bool -> Identity Double)) == [(Int, FTF_T_T), (Bool, FTF_T_T)] getRuntimeArgTys (forall a. Show a => Identity a -> a -> Int -> Bool) == [(Show a, FTF_C_T), (Identity a, FTF_T_T),(a, FTF_T_T),(Int, FTF_T_T)] Note that, in the last case, the returned types might mention an out-of-scope type variable. This function is used only when we really care about the kinds' of the returned types, so this is OK.*Warning**: this function can return an infinite list. For example:  newtype N a = MkN (a -> N a) getRuntimeArgTys (N a) == repeat (a, FTF_T_T) GghcLike G, but returns only *invisible* binders, including constraints. Stops at the first visible binder.GghcSame as G$, but stop when - you have found n &+s, - or you run out of invisible bindersGghcGiven a  and a list of argument types, filter out any invisible (i.e., & or & ) arguments.GghcGiven a . and a list of argument types, filter out any & arguments.GghcGiven a list of things paired with their visibilities, partition the things into (invisible things, visible things).GghcGiven a + and a list of argument types to which the 5 is applied, determine each argument's visibility (&, &, or &).)Wrinkle: consider the following scenario: T :: forall k. k -> k tyConForAllTyFlags T [forall m. m -> m -> m, S, R, Q]After substituting, we get T (forall m. m -> m -> m) :: (forall m. m -> m -> m) -> forall n. n -> n -> n'Thus, the first argument is invisible, S is visible, R is invisible again, and Q is visible.GghcGiven a + and a list of argument types to which the 5 is applied, determine each argument's visibility (&, &, or &).(Most of the time, the arguments will be &, but not always. Consider f :: forall a. a -> Type. In  f Type Bool, the first argument (Type) is & and the second argument (Bool) is &?. It is precisely this sort of higher-rank situation in which G comes in handy, since  f Type Bool$ would be represented in Core using Cs. (See also #15792).ghcGiven a function kind and a list of argument types (where each argument's kind aligns with the corresponding position in the argument kind), determine each argument's visibility (&, &, or &).GghcGiven a family instance TyCon and its arg types, return the corresponding family type. E.g: 1data family T a data instance T (Maybe b) = MkT b%Where the instance tycon is :RTL, so: +mkFamilyTyConApp :RTL Int = T (Maybe Int)GghcGet the type on the LHS of a coercion induced by a type/data family instance.GghcDoes this type classify a core (unlifted) Coercion? At either role nominal or representational (t1 ~# t2) or (t1 ~R# t2) See Note [Types for coercions, predicates, and evidence] in GHC.Core.TyCo.RepGghcTries to compute the A/ of the given type. Returns either a definite A, or J if we aren't sure (e.g. the type is representation-polymorphic).+Panics if the kind does not have the shape TYPE r.Gghc,Is the given type definitely unlifted? See Type#type_classification for what an unlifted type is.0Panics on representation-polymorphic types; See G for a more approximate predicate that behaves better in the presence of representation polymorphism.GghcReturns:I if the type is  guaranteed unlifted orL if it lifted, OR we aren't sure (e.g. in a representation-polymorphic case)GghcReturns:I if the type is  guaranteed lifted orL if it is unlifted, OR we aren't sure (e.g. in a representation-polymorphic case)GghcSee Type#type_classification for what a boxed type is. Panics on representation-polymorphic types; See G for a more approximate predicate that behaves better in the presence of representation polymorphism.Gghc3Is this a type of kind RuntimeRep? (e.g. LiftedRep)Gghc+Drops prefix of RuntimeRep constructors in Cs. Useful for e.g. dropping 'LiftedRep arguments of unboxed tuple TyCon applications:dropRuntimeRepArgs [ 'LiftedRep, 'IntRep , String, Int# ] == [String, Int#]ghc Int then j could be a binary join point returning an Int, but it could *not* be a unary join point returning a -> Int.4TODO: See Note [Excess polymorphism and join points]GghcDoes this classify a type allowed to have values? Responds True to things like *, TYPE Lifted, TYPE IntRep, TYPE v, Constraint.)True of a kind `TYPE _` or `CONSTRAINT _`GghcIs this kind equivalent to  i.e. TYPE LiftedRep?GghcIs this kind equivalent to TYPE (BoxedRep l) for some  l :: Levity?GghcIs this kind equivalent to TYPE r (for some unknown r)?This considers  Constraint to be distinct from *.GghcReturns True if a type has a syntactically fixed runtime rep, as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.This function is equivalent to `isFixedRuntimeRepKind . typeKind` but much faster. Precondition: The type has kind (TYPE blah)GghcTrue if the argument types of this function type all have a fixed-runtime-repGghcChecks that a kind of the form ,  Constraint or 'TYPE r is concrete. See G. Precondition:3 The type has kind `TYPE blah` or `CONSTRAINT blah`GghcTests whether the given type is concrete, i.e. it whether it consists only of concrete type constructors, concrete type variables, and applications.3See Note [Concrete types] in GHC.Tc.Utils.Concrete.GghcDoes a  (that is applied to some number of arguments) need to be ascribed with an explicit kind signature to resolve ambiguity if rendered as a source-syntax type? (See Note [When does a tycon application need an explicit kind signature?]; for a full explanation of what this function checks for.)GghcScale a payload by ManyGghcScale a payload by OneGghc8Scale a payload by Many; used for type arguments in coreGghc isLinear t returns True of a if t is a type of (curried) function where at least one argument is linear (or otherwise non-unrestricted). We use this function to check whether it is safe to eta reduce an Id in CorePrep. It is always safe to return L , because L deactivates the optimisation.GghcGiven a  RuntimeRep , applies TYPE to it. On the fly it rewrites TYPE LiftedRep --> liftedTypeKind (a synonym) TYPE UnliftedRep --> unliftedTypeKind (ditto) TYPE ZeroBitRep --> zeroBitTypeKind (ditto) NB: no need to check for TYPE (BoxedRep Lifted), TYPE (BoxedRep Unlifted) because those inner types should already have been rewritten to LiftedRep and UnliftedRep respectively, by mkTyConAppsee Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.TypeGghcJust like mkTYPEappGghcJust like mkTYPEapp_maybeGghcGiven a A, apply BoxedRep to it On the fly, rewrite BoxedRep Lifted --> liftedRepTy (a synonym) BoxedRep Unlifted --> unliftedRepTy (ditto) See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.TypeGghcGiven a `[RuntimeRep]`, apply TupleRep to it On the fly, rewrite TupleRep [] -> zeroBitRepTy (a synonym) See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Typeghc"the variables bound by the synonymghcthe RHS of the synonymghc2the type arguments the synonym is instantiated at.Gghcbindersghcfree variables of resultGghcresult kindGghcShould specified binders count towards injective positions in the kind of the TyCon? (If you're using visible kind applications, then you want True here.ghcThe number of args the  is applied to.ghcDoes  T t_1 ... t_n need a kind signature? (Where n is the number of arguments)&&&&&&&&&&CC&'&&&CCCF'FF''FFFFFFFCCCCCCCCCCGGGGGGDGGGG''A'GGGG'GGGGCCGGGGGGGGGGGGGGGGGGGGGCC'GGGGGFFFFFFF'GFFF'F''GFFGGGGGGG'GGGFFFFFFFFFBBBBBBBCCG''''''''''''''&&'''GFG'GGGGGGGGGGGGGGGGGGG'GG'FFFFFFFFGGGGFGGGGGG'F'FGG'FGGGGGGFFGGG'GGGGGGGG##EEEEEEEEEEEFCEEEEEEEGG'EEEEEEEEEFFFEEEEEEFFFFFFFFFFFFEEFFEFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGG&&&&&&&&&&&&CC'&&&CCCF'FF'&'FFFFFFFCCCCCCCCCCGGGGGGDGGGG''A'GGGG'GGGGCCGGGGGGGGGGGGGGGGGGGGGCC'GGGGGFFFFFFF'GFFF'F''GFFGGGGGGG'GGGFFFFFFFFFBBBBBBBCCG''''''''''''''&&'''GFG'GGGGGGGGGGGGGGGGGGG'GG'FFFFFFFFGGGGFGGGGGG'F'FGG'FGGGGGGFFGGG'GGGGGGGG##EEEEEEEEEEEFCEEEEEEEGG'EEEEEEEEEFFFEEEEEEFFFFFFFFFFFFEEFFEFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGG Safe-Inferred/7^GghcOverloaded Literal ValueGghcInteger-looking literals;GghcFrac-looking literalsGghcString-looking literalsGghcHaskell Overloaded LiteralGghcHaskell LiteralGghc CharacterGghcUnboxed characterGghcStringGghc Packed bytesHghcGenuinely an Int; arises from GHC.Tc.Deriv.Generate, and from TRANSLATIONHghcliteral Int#Hghcliteral Word#Hghcliteral Int64#Hghcliteral Word64#HghcGenuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)HghcGenuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)Hghc Unboxed FloatHghcUnboxed DoubleGGGGGGGGGGHHHHHHHHHHGGGGHGHHHHHHHHHHGGGGGGGGGGGGGH Safe-Inferred167IghcGoverns the kind of expression that the tick gets placed on when annotating for example using mkTick. If we find that we want to put a tickish on an expression ruled out here, we try to float it inwards until we find a suitable expression.IghcPlace ticks exactly on run-time expressions. We can still move the tick through pure compile-time constructs such as other ticks, casts or type lambdas. This is the most restrictive placement rule for ticks, as all tickishs have in common that they want to track runtime processes. The only legal placement rule for counting ticks. NB: We generally try to move these as close to the relevant runtime expression as possible. This means they get pushed through tyoe arguments. E.g. we create `(tick f) Bool` instead of `tick (f Bool)`.IghcAs  PlaceRuntime, but we float the tick through all lambdas. This makes sense where there is little difference between annotating the lambda and annotating the lambda's code.IghcIn addition to floating through lambdas, cost-centre style tickishs can also be moved from constructors, non-function variables and literals. For example: let x = scc ... C (scc ... y) (scc ... 3) in ...Neither the constructor application, the variable or the literal are likely to have any cost worth mentioning. And even if y names a thunk, the call would not care about the evaluation context. Therefore removing all annotations in the above example is safe.IghcSpecifies the scoping behaviour of ticks. This governs the behaviour of ticks that care about the covered code and the cost associated with it. Important for ticks relating to profiling.IghcNo scoping: The tick does not care about what code it covers. Transformations can freely move code inside as well as outside without any additional annotation obligationsIghcSoft scoping: We want all code that is covered to stay covered. Note that this scope type does not forbid transformations from happening, as long as all results of the transformations are still covered by this tick or a copy of it. For example let x = tick ...6 (let y = foo in bar) in baz ===> let x = tick ... bar; y = tick ... foo in bazIs a valid transformation as far as "bar" and "foo" is concerned, because both still are scoped over by the tick.Note though that one might object to the "let" not being covered by the tick any more. However, we are generally lax with this - constant costs don't matter too much, and given that the "let" was effectively merged we can view it as having lost its identity anyway.Also note that this scoping behaviour allows floating a tick "upwards" in pretty much any situation. For example:case foo of x -> tick ... bar ==> tick ... case foo of x -> barWhile this is always legal, we want to make a best effort to only make us of this where it exposes transformation opportunities.IghcCost centre scoping: We don't want any costs to move to other cost-centre stacks. This means we not only want no code or cost to get moved out of their cost centres, but we also object to code getting associated with new cost-centre ticks - or changing the order in which they get applied.A rule of thumb is that we don't want any code to gain new annotations. However, there are notable exceptions, for example:let f = y -> foo in tick ... ... (f x) ... ==> tick ... ... foo[x/y] ...In-lining lambdas like this is always legal, because inlining a function does not change the cost-centre stack when the function is called.IghcAn  {-# SCC #-} profiling annotation, either automatically added by the desugarer as a result of -auto-all, or added by the user.IghcA "tick" used by HPC to track the execution of each subexpression in the original source code.IghcA breakpoint for the GHCi debugger. This behaves like an HPC tick, but has a list of free variables which will be available for inspection in GHCi when the program stops at the breakpoint.NB. we must take account of these Ids when (a) counting free variables, and (b) substituting (don't substitute for them)IghcA source note.Source notes are pure annotations: Their presence should neither influence compilation nor execution. The semantics are given by causality: The presence of a source note means that a local change in the referenced source code span will possibly provoke the generated code to change. On the flip-side, the functionality of annotated code *must* be invariant against changes to all source code *except* the spans referenced in the source notes (see "Causality of optimized Haskell" paper for details).Therefore extending the scope of any given source note is always valid. Note that it is still undesirable though, as this reduces their usefulness for debugging and profiling. Therefore we will generally try only to make use of this property where it is necessary to enable optimizations.Ighcthe cost centreIghcbump the entry count?Ighc;scopes over the enclosed expression (i.e. not just a tick)Ighcthe order of this list is important: it matches the order of the lists in the appropriate entry in .9Careful about substitution! See Note [substTickish] in GHC.Core.Subst.IghcSource coveredIghc4Name for source location (uses same names as CCs)Ighc)Tickish in Cmm context (annotations only)ghc;Allows attaching extra information to points in expressionsUsed as a data type index for the GenTickish annotations. See Note [Tickish passes]IghcA "counting tick" (where tickishCounts is True) is one that counts evaluations in some way. We cannot discard a counting tick, and the compiler should preserve the number of counting ticks as far as possible.However, we still allow the simplifier to increase or decrease sharing, so in practice the actual number of ticks may vary, except that we never change the value from zero to non-zero or vice versa.Ighc/Returns the intended scoping rule for a TickishIghcReturns whether the tick scoping rule is at least as permissive as the given scoping rule.IghcReturns True for ticks that can be floated upwards easily even where it might change execution counts, such as: Just (tick ... foo) ==> tick ... (Just foo)This is a combination of tickishSoftScope and  tickishCounts. Note that in principle splittable ticks can become floatable using mkNoTick -- even though there's currently no tickish for which that is the case.IghcReturns True" for a tick that is both counting and> scoping and can be split into its (tick, scope) parts using I and mkNoTick respectively.IghcReturn True if this source annotation compiles to some backend code. Without this flag, the tickish is seen as a simple annotation that does not have any associated evaluation code.What this means that we are allowed to disregard the tick if doing so means that we can skip generating any code in the first place. A typical example is top-level bindings: foo = tick ...% y -> ... ==> foo = y -> tick ... ...Here there is just no operational difference between the first and the second version. Therefore code generation should simply translate the code as if it found the latter.Ighc)Placement behaviour we want for the ticksIghcReturns whether one tick "contains" the other one, therefore making the second tick redundant.ghc6Keep track of the type of breakpoints in STG, for GHCi&IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII&IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII< Safe-InferredJghcmkMultSup w1 w2" returns a multiplicity such that mkMultSup w1 w2 >= w1 and mkMultSup w1 w2 >= w2.. See Note [Overapproximating multiplicities].Jghc submult w1 w2' check whether a value of multiplicity w1+ is allowed where a value of multiplicity w2& is expected. This is a partial order.FFJJJJBCGGGGGGJIIIJCJFFJJJJBCGGGGGGJIIIJCJ Safe-InferredJghc|lookupUE x env| returns the multiplicity assigned to |x| in |env|, if |x| is not bound in |env|, then returns |Zero| or |Bottom|.JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ Safe-Inferred7ghc!An ordering relation between two s (known below as t1 :: k1 and t2 :: k2)ghc t1 < t2ghct1 ~ t2> and there are no casts in either, therefore we can conclude k1 ~ k2ghct1 ~ t2 yet one of the types contains a cast so they may differ in kind.ghc t1 > t2HghctcEqType implements typechecker equality It behaves just like eqType, but is implemented differently (for now)Hghc Just like H, but will return True for types of different kinds as long as their non-coercion structure is identical.HghcCheck whether two TyConApps are the same; if the number of arguments are different, just checks the common prefix of arguments.ghcType equality comparing both visible and invisible arguments and expanding type synonyms.HghcLike H, but returns True if the visible part of the types are equal, even if they are really unequal (in the invisible bits)HghcLike pickyEqTypeVis$, but returns a Bool for convenienceghcReal worker for H. No kind check!Hghc.Do these denote the same level of visibility? & arguments are visible, others are not. So this function equates & and &. Used for printing.Hghc.Do these denote the same level of visibility? & arguments are visible, others are not. So this function equates & and &. Used for printing.Hghc5Type equality on source types. Does not look through newtypes, s or type families, but it does look through type synonyms. This first checks that the kinds of the types are equal and then checks whether the types are equal, ignoring casts and coercions. (The kind check is a recursive call, but since all kinds have type Type, there is no need to check the types of kinds.) See also Note [Non-trivial definitional equality] in GHC.Core.TyCo.Rep.Hghc7Compare types with respect to a (presumably) non-empty (.HghcType equality on lists of types, looking through type synonyms but not newtypes.Hghc Compare two +s. See Note [nonDetCmpType nondeterminism]ghcTrue  = do not expand type synonymsghcTrue  = compare visible args onlyHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH Safe-Inferred 7,!JghcNumeric literal typeJghcBignat (see Note [BigNum literals])JghcInt# - according to target machineJghcInt8# - exactly 8 bitsJghcInt16# - exactly 16 bitsJghcInt32# - exactly 32 bitsJghcInt64# - exactly 64 bitsJghcWord# - according to target machineJghcWord8# - exactly 8 bitsJghcWord16# - exactly 16 bitsJghcWord32# - exactly 32 bitsJghcWord64# - exactly 64 bitsJghc So-called J s are one of:An unboxed numeric literal or floating-point literal which is presumed to be surrounded by appropriate constructors (Int#2, etc.), so that the overall thing makes sense.#We maintain the invariant that the ? in the J constructor is actually in the (possibly target-dependent) range. The mkLit{Int,Word}*Wrap smart constructors ensure this by applying the target machine's wrapping semantics. Use these in situations where you know the wrapping semantics are correct.The literal derived from the label mentioned in a "foreign label" declaration (J)A J3 to be used in place of values that are never used. A characterA stringThe NULL pointerJghcChar#" - at least 31 bits. Create with JJghcAny numeric literal that can be internally represented with an Integer.JghcA string-literal: stored and emitted UTF-8 encoded, we'll arrange to decode it at runtime. Also emitted with a '\0' terminator. Create with JJghcThe NULL pointer, the only pointer value that can be represented as a Literal. Create with JJghc.A nonsense value; See Note [Rubbish literals].JghcFloat#. Create with JJghcDouble#. Create with JJghcA label literal. Parameters::1) The name of the symbol mentioned in the declaration2) The size (in bytes) of the arguments the label expects. Only applicable with stdcall labels. Just x => ? will be appended to label name when emitting assembly.3) Flag indicating whether the symbol references a function or a dataJghcCoerce a literal number into another using wrapping semantics.JghcNarrow a literal number by converting it into another number type and then converting it back to its original type.Jghc>Check that a given number is in the range of a numeric literalJghcGet the literal rangeJghcCreate a numeric J of the given typeJghc Creates a J of type Int#Jghc Creates a J of type Int#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [Word Int underflow overflow]Jghc Creates a J of type Int# without checking its range.Jghc Creates a J of type Int#, as well as a 9ean flag indicating overflow. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the overflow flag will be set. See Note [Word Int underflow overflow]Jghc Creates a J of type Word#Jghc Creates a J of type Word#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [Word Int underflow overflow]Jghc Creates a J of type Word# without checking its range.Jghc Creates a J of type Word#, as well as a 9ean flag indicating carry. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the carry flag will be set. See Note [Word Int underflow overflow]Jghc Creates a J of type Int8#Jghc Creates a J of type Int8#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Int8# without checking its range.Jghc Creates a J of type Word8#Jghc Creates a J of type Word8#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Word8# without checking its range.Jghc Creates a J of type Int16#Jghc Creates a J of type Int16#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Int16# without checking its range.Jghc Creates a J of type Word16#Jghc Creates a J of type Word16#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Word16# without checking its range.Jghc Creates a J of type Int32#Jghc Creates a J of type Int32#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Int32# without checking its range.Jghc Creates a J of type Word32#Jghc Creates a J of type Word32#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Word32# without checking its range.Jghc Creates a J of type Int64#Jghc Creates a J of type Int64#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Int64# without checking its range.Jghc Creates a J of type Word64#Jghc Creates a J of type Word64#8. If the argument is out of the range, it is wrapped.Jghc Creates a J of type Word64# without checking its range.Jghc Creates a J of type Float#Jghc Creates a J of type Double#Jghc Creates a J of type Char#Jghc Creates a J of type Addr#, which is appropriate for passing to e.g. some of the "error" functions in GHC.Err such as GHC.Err.runtimeErrorJghcTests whether the literal represents a zero of whatever type it isJghcTests whether the literal represents a one of whatever type it isJghc Returns the ? contained in the J', for when that makes sense, i.e. for ; and numbers.Jghc Returns the ? contained in the J', for when that makes sense, i.e. for ; and numbers.JghcApply a function to the ? contained in the J', for when that makes sense, e.g. for ; and numbers. For fixed-size integral literals, the result will be wrapped in accordance with the semantics of the target type. See Note [Word Int underflow overflow]ghc0Narrow a literal number (unchecked result range)Jghc-Extend or narrow a fixed-width literal (e.g. Int16##) to a target word-sized literal (Int# or Word#). Narrowing can only happen on 32-bit architectures when we convert a 64-bit literal into a 32-bit one.Jghc-Extend or narrow a fixed-width literal (e.g. Int16##) to a target word-sized literal (Int# or Word#). Narrowing can only happen on 32-bit architectures when we convert a 64-bit literal into a 32-bit one.JghcTrue if there is absolutely no penalty to duplicating the literal. False principally of strings."Why?", you say? I'm glad you asked. Well, for one duplicating strings would blow up code sizes. Not only this, it's also unsafe.Consider a program that wants to traverse a string. One way it might do this is to first compute the Addr# pointing to the end of the string, and then, starting from the beginning, bump a pointer using eqAddr# to determine the end. For instance, -- Given pointers to the start and end of a string, count how many zeros -- the string contains. countZeros :: Addr# -> Addr# -> -> Int countZeros start end = go start 0 where go off n | off addrEq#- end = n | otherwise = go (off  plusAddr# 1) n' where n' | isTrue# (indexInt8OffAddr# off 0# ==# 0#) = n + 1 | otherwise = n Consider what happens if we considered strings to be trivial (and therefore duplicable) and emitted a call like countZeros "hello"# ("hello"# plusAddr# 5). The beginning and end pointers do not belong to the same string, meaning that an iteration like the above would blow up terribly. This is what happened in #12757.Ultimately the solution here is to make primitive strings a bit more structured, ensuring that the compiler can't inline in ways that will break user code. One approach to this is described in #8472.Jghc?True if code space does not go bad if we duplicate this literalJghcFind the Haskell  the literal occupiesKghcNeeded for the Ord instance of AltCon, which in turn is needed in .JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ Safe-Inferred -KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK1K1K1 Safe-Inferred9:;.KKKKKKKKKKKK Safe-Inferred ? ҦghcA "supernode" stands for a collection of one or more nodes (basic blocks) that have been coalesced by the Hecht-Ullman algorithm. A collection in a supernode constitutes a  reducible subgraph of a control-flow graph. (When an entire control-flow graph is collapsed to a single supernode, the flow graph is reducible.)The idea of node splitting is to collapse a control-flow graph down to a single supernode, then materialize (`inflate'<) the reducible equivalent graph from that supernode. The Ц class defines only the methods needed to collapse; rematerialization is the responsiblity of the client.During the Hecht-Ullman algorithm, every supernode has a unique entry point, which is given by Ӧ. But this invariant is not guaranteed by the class methods and is not a law of the class. The Ԧ function rewrites all labels that appear in a supernode (both definitions and uses). The Ѧ* function replaces every appearance of a defined label with a fresh label. (Appearances include both definitions and uses.)Laws:  superLabel (n <> n') == superLabel n blocks (n <> n') == blocks n  blocks n' mapLabels f (n <> n') = mapLabels f n <> mapLabels f n' mapLabels id == id mapLabels (f . g) == mapLabels f . mapLabels g  (We expect Ѧ to distribute over , but because of the fresh names involved, formulating a precise law is a bit challenging.)զghcThe identity monad as a ئ>. Use this monad when you want efficiency in graph collapse.ܦghcModule : GHC.Data.Graph.Collapse Description : Implement the "collapsing" algorithm Hecht and UllmanA control-flow graph is reducible if and only if it is collapsible according to the definition of Hecht and Ullman (1972). This module implements the collapsing algorithm of Hecht and Ullman, and if it encounters a graph that is not collapsible, it splits nodes until the graph is fully collapsed. It then reports what nodes (if any) had to be split in order to collapse the graph. The information is used upstream to node-split Cmm graphs.The module uses the inductive graph representation cloned from the Functional Graph Library (Hackage package fgl , modules .)If you want to visualize the graph-collapsing algorithm, create an instance of monad ئ. Each step in the algorithm is announced to the monad as a side effect. If you don't care about visualization, you would use the զ. monad, in which these operations are no-ops.ghc Tell if a  has a single predecessor.ghc1Use this function to extract information about a  that you know is in a  . It's like  from , but it must succeed.ghc"Rewrite the label of a given node.ghc&Test if a graph has but a single node.ghcMerge two nodes, return new graph plus list of nodes that newly have a single predecessor. This function implements transformation $T_2$ from the Hecht and Ullman paper (merge the node into its unique predecessor). It then also removes self-edges (transformation $T_1$ from the Hecht and Ullman paper). There is no need for a separate implementation of $T_1$.`consumeBy v u g` returns the graph that results when node v is consumed by node u in graph g. Both v and u are replaced with a new node u' with these properties:LABELS(u') = LABELS(u) " LABELS(v) SUCC(u') = SUCC(u)  SUCC(v) - { u } every node that previously points to u now points to u'It also returns a list of nodes in the result graph that are *newly* single-predecessor nodes.ghcSplit a given node. The node is replaced with a collection of replicas, one for each predecessor. After the split, every predecessor points to a unique replica.ghc;Does a list have more than one element? (in constant time).ghcFind a candidate for splitting by finding a node that has multiple predecessors.ߦghcUsing the algorithm of Hecht and Ullman (1972), collapse a graph into a single node, splitting nodes as needed. Record visualization events in monad m.ҦӦԦЦѦߦئ٦ڦۦզ֦צަܦݦҦӦԦЦѦߦئ٦ڦۦզ֦צަܦݦ Safe-Inferred)*1H KghcGraph' is abstracted over the block type, so that we can build graphs of annotated blocks for example (Compiler.Hoopl.Dataflow needs this).KghcA control-flow graph, which may take any of four shapes (O/O, OC, CO, C/C). A graph open at the entry has a single, distinguished, anonymous entry point; if a graph is closed at the entry, its entry point(s) are supplied by a context.KghcGives access to the anchor points for nonlocal edges as well as the edges themselvesghcBody abstracted over blockKghc5A (possibly empty) collection of closed/closed blocksKghcMaps over all nodes in a graph.Kghc Function K enables a change of representation of blocks, nodes, or both. It lifts a polymorphic block transform into a polymorphic graph transform. When the block representation stabilizes, a similar function should be provided for blocks.KghcReturns a list of blocks reachable from the provided Labels in the reverse postorder.This is the most important traversal over this data structure. It drops unreachable code and puts blocks in an order that is good for solving forward dataflow problems quickly. The reverse order is good for solving backward dataflow problems quickly. The forward order is also reasonably good for emitting instructions, except that it will not usually exploit Forrest Baskett's trick of eliminating the unconditional branch from a loop. For that you would need a more serious analysis, probably based on dominators, to identify loop headers.For forward analyses we want reverse postorder visitation, consider: - A -> [B,C] B -> D C -> D  Postorder: [D, C, B, A] (or [D, B, C, A]) Reverse postorder: [A, B, C, D] (or [A, C, B, D]) This matters for, e.g., forward analysis, because we want to analyze *both* B and C before we analyze D.Kghc"The label of a first node or blockKghcGives control-flow successorsKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK& Safe-Inferred Z` ghc3A kind of universal type, used for types and kinds. Any time a Type0 is pretty-printed, it is first converted to an   before being printed. See Note [Pretty printing via Iface syntax] in GHC.Types.TyThing.Ppr ghc;Stores the arguments in a type application as a list. See &Note [Suppressing invisible arguments].HghcShow forall flag1Unconditionally show the forall quantifier with (H ) or when (H) the names used are free in the binder or when compiling with -fprint-explicit-foralls.HghcDo we want to suppress kind annotations on binders? See Note [Suppressing binder signatures]Hghc!See Note [Holes in IfaceCoercion]HghcThe various types of TyCons which have special, built-in syntax.Hghca regular tyconHghca tuple, e.g.  (a, b, c) or  (#a, b, c#). The arity is the tuple width, not the tycon arity (which is twice the width in the case of unboxed tuples).Hghcan unboxed sum, e.g. (# a | b | c #)HghcA heterogeneous equality TyCon (i.e. eqPrimTyCon, eqReprPrimTyCon, heqTyCon) that is actually being applied to two types of the same kind. This affects pretty-printing only: see Note [Equality predicates in IfaceType]HghcMake an H from an H.Hghc Build the A: from the binders and the result kind. Keep in sync with A in GHC.Core.TyCon.Hghc)Returns true for Type or (TYPE LiftedRep)ghc5Returns true for Constraint or (CONSTRAINT LiftedRep)Ighc Extract an   from an H.Ighc"Extract the variable name from an H.Ighc Extract an   from an H.Ighc"Extract the variable name from an H.ghcDefault A variables to @, A variables to  , and  Multiplicity variables to Many. For example: ($) :: forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b Just :: forall (k :: Multiplicity) a. a % k -> Maybe a  turns in to,. ($) :: forall a (b :: *). (a -> b) -> a -> b  ! Just :: forall a . a -> Maybe a We do this to prevent RuntimeRep, Levity and Multiplicity variables from incurring a significant syntactic overhead in otherwise simple type signatures (e.g. ($)). See Note [Defaulting RuntimeRep variables] and #11549 for further discussion.ghc6The type ('BoxedRep 'Lifted), also known as LiftedRep.ghcThe type 'Lifted :: Levity'.Ighc The type 'Many :: Multiplicity'.IghcLike I, but always uses an explicit forall.Ighc;Render the "forall ... ." or "forall ... ->" bit of a type.ghcRender the ... in (forall ... .) or (forall ... ->). Returns both the list of not-yet-rendered binders and the doc. No anonymous binders here!ghcPretty-print a type-level equality. Returns (Just doc) if the argument is a  saturated application of eqTyCon (~) eqPrimTyCon (~#) eqReprPrimTyCon (~R#) heqTyCon (~~)See Note [Equality predicates in IfaceType] and Note [The equality types story] in GHC.Builtin.Types.PrimghcPretty-prints an application of a type constructor to some arguments (whose visibilities are known). This is polymorphic (over a) since we use this function to pretty-print two different things:  Types (from  pprTyTcApp')Coercions (from I)ghcPretty-print an unboxed sum type. The sum should be saturated: as many visible arguments as the arity of the sum.)NB: this always strips off the invisible A arguments, even with `-fprint-explicit-runtime-reps` and `-fprint-explicit-kinds`.ghcPretty-print a tuple type (boxed tuple, constraint tuple, unboxed tuple). The tuple should be saturated: as many visible arguments as the arity of the tuple.)NB: this always strips off the invisible A arguments, even with `-fprint-explicit-runtime-reps` and `-fprint-explicit-kinds`.IghcPrints "(C a, D b) =>", including the arrow. Used when we want to print a context in a type, so we use ! to decide whether to parenthesise a singleton predicate; e.g. Num a => a -> aIghcPrints a context or ()- if empty You give it the context precedenceghcif printing coercionsghc otherwiseghcdefault A/A variables?ghcdefault  Multiplicity variables?ghc*visibility of the first binder in the listHH HHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHH HHH HHH HHHHHHHHHHH&&&&&&&&HHHHHHHIIHIIHIIHHHHHHIIIIIIIIIIIIIIIIIIIHIIIIIIHHIIIIIIIHH HHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHH HHH HHH HHHHHHHHHHH&&&&&&&&&&HHHHHHHIIHIIHIIHHHHHHIIIIIIIIIIIIIIIIIIIHIIIIIIHHIIIIIII= Safe-Inferred`ghcdebugPprType is a simple pretty printer that prints a type without going through IfaceType. It does not format as prettily as the normal route, but it's much more direct, and that can be useful for debugging. E.g. with -dppr-debug it prints the kind on type-variable  occurrences1 which the normal route fundamentally cannot do.LghcPrint a user-level forall; see Note [When to print foralls] in GHC.Iface.Type.Lghc#Display all kind information (with -fprint-explicit-kinds) when the provided 9 argument is L. See 'Note [Kind arguments in error messages] in  GHC.Tc.Errors.LghcThis variant preserves any use of TYPE in a type, effectively locally setting -fprint-explicit-runtime-reps.LghcPretty prints a , using the family instance in case of a representation tycon. For example: data T [a] = ...In that case we want to print T [a], where T is the family #!!!!!!!!LLLLLLLLLLLLLLLLLLLLL#!!!!!!!!LLLLLLLLLLLLLLLLLLLLL Safe-Inferrede ^ghcPattern SynonymSee Note [Pattern synonym representation] See Note [Pattern synonym signature contexts]ghcArgument types^ghcBuild a new pattern synonym^ghcThe  of the ^+, giving it a unique, rooted identification^ghc Should the ^ be presented infix?^ghcArity of the pattern synonym^ghcIs this a 'vanilla' pattern synonym (no existentials, no provided constraints)?^ghc5Extract the type for any given labelled field of the DataCon^ghcPrint the type of a pattern synonym. The foralls are printed explicitly^ghc&Is the pattern synonym declared infix?ghc9Universally-quantified type variables and required dictsghc;Existentially-quantified type variables and provided dictsghcOriginal argumentsghcOriginal result typeghcMatcherghcBuilderghc/Names of fields for a record pattern synonym^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Safe-Inferred79iLghcTrie of [RoughMatchTc] Examples*  insert [OtherTc] 1 insert [OtherTc] 2 lookup [OtherTc] == [1,2] Lghc/The position only matches the specified KnownTcLghc1The position definitely doesn't match any KnownTcLghcThe position can match anythingLghc!Order of result is deterministic.LghcN.B. Returns a  for matches, which allows us to avoid rebuilding all of the lists we find in ,, which would otherwise be necessary due to  if we returned a list. We use a list for unifiers because the tail is computed lazily and we often only care about the first couple of potential unifiers. Constructing a bag forces the tail which performs much too much work.>See Note [Matching a RoughMap] See Note [Matches vs Unifiers]ghcPlace a L# in normal form, turning all empty s into "s. Necessary after removing items.LghcFilter all elements that might match a particular key with the given predicate.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL9 Safe-Inferred 9@ghc$Sometimes we want to look through a newtype< and get its associated coercion. This function strips off newtype1 layers enough to reveal something that isn't a newtype&. Specifically, here's the invariant: 5topNormaliseNewType_maybe rec_nts ty = Just (co, ty') then (a) co : ty ~R ty'". (b) ty' is not a newtype.The function returns Nothing for non-newtypes, or unsaturated applicationsThis function does *not* look through type families, because it has no access to the type family environment. If you do have that at hand, consider to use topNormaliseType_maybe, which should be a drop-in replacement for topNormaliseNewType_maybe If topNormliseNewType_maybe ty = Just (co, ty'), then co : ty ~R ty'@ghcIf it is the case that c :: (t1 ~ t2)i.e. the kind of c relates t1 and t2, then coercionKind c = Pair t1 t2.@ghcliftCoSubst role lc ty produces a coercion (at role role) that coerces between  lc_left(ty) and  lc_right(ty) , where lc_left is a substitution mapping type variables to the left-hand types of the mapped coercions in lc, and similar for lc_right.@ghcMakes a coercion type from two types: the types whose equality is proven by the relevant @ghcSlowly checks if the coercion is reflexive. Don't call this in a loop, as it walks over the entire coercion.@ghcTests if this coercion is obviously reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. @@ghcTests if this coercion is obviously a generalized reflexive coercion. Guaranteed to work very quickly.@ghc$Make a "coercion between coercions".@ghcGiven co :: (a :: k) ~ (b :: k') produce  co' :: k ~ k'.@ghc!Make a nominal reflexive coercion@ghc%Make a generalized reflexive coercion@ghcInstantiates a .@ghc Create a new  by composing the two given s transitively. (co1 ; co2)@ghc(Create a symmetric version of the given  that asserts equality between the same types but in the other "direction", so a kind of t1 ~ t2 becomes the kind t2 ~ t1.@ghc6Make a universal coercion between two arbitrary types.@ghcMake a phantom coercion between two types. The coercion passed in must be a nominal coercion between the kinds of the types.@ghcBuild a function  from two other s. That is, given  co1 :: a ~ b and  co2 :: x ~ y produce co :: (a -> x) ~ (b -> y) or (a => x) ~ (b => y), depending on the kind of a/b. This (most common) version takes a single FunTyFlag, which is used for both fco_afl and ftf_afr of the FunCo@ghcMake a Coercion from a tycovar, a kind coercion, and a body coercion. The kind of the tycovar should be the left-hand kind of the kind coercion. See Note [Unused coercion variable in ForAllCo]@ghcApply a  to another . The second coercion must be Nominal, unless the first is Phantom. If the first is Phantom, then the second can be either Phantom or Nominal.@ghcApply a type constructor to a list of coercions. It is the caller's responsibility to get the roles correct on argument coercions.@ghcMake a reflexive coercionLghc9The result of stepping in a normalisation function. See M.LghcNothing more to doLghc2Utter failure. The outer function should fail too.LghcWe stepped, yielding new bits; ^ ev is evidence; Usually a co :: old type ~ new typeLghcA function to check if we can reduce a type by one step. Used with M.LghcTests if this MCoercion is obviously generalized reflexive Guaranteed to work very quickly.Lghc'Compose two MCoercions via transitivityLghcGet the reverse of an LghcCast a type by an LghcLike M, but with an LghcThis breaks a  with type T A B C ~ T D E F into a list of  s of kinds A ~ D, B ~ E and E ~ F. Hence: decomposeCo 3 c [r1, r2, r3] = [nth r1 0 c, nth r2 1 c, nth r3 2 c]LghcExtract a covar, if possible. This check is dirty. Be ashamed of yourself. (It's dirty because it cares about the structure of a coercion, which is morally reprehensible.)Lghc-Attempt to take a coercion application apart.LghcLike L(, but only returns Just for tyvar binderLghcLike L(, but only returns Just for covar binderLghcGiven a coercion `co :: (t1 :: TYPE r1) ~ (t2 :: TYPE r2)` produce a coercion `rep_co :: r1 ~ r2` But actually it is possible that co :: (t1 :: CONSTRAINT r1) ~ (t2 :: CONSTRAINT r2) or co :: (t1 :: TYPE r1) ~ (t2 :: CONSTRAINT r2) or co :: (t1 :: CONSTRAINT r1) ~ (t2 :: TYPE r2) See Note [mkRuntimeRepCo]LghcReturns the type coerced if this coercion is a generalized reflexive coercion. Guaranteed to work very quickly.LghcReturns the type coerced if this coercion is reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. LLghcExtracts the coerced type from a reflexive coercion. This potentially walks over the entire coercion, so avoid doing this in a loop.Lghc*Make a representational reflexive coercionLghcApplies multiple  s to another  , from left to right. See also @.ghcLike @, but the inner coercion shouldn't be an obvious reflexive coercion. For example, it is guaranteed in L. The kind of the tycovar should be the left-hand kind of the kind coercion.LghcMake nested ForAllCosLghcMake a Coercion quantified over a type/coercion variable; the variable has the same type in both sides of the coercionghcLike L, but the inner coercion shouldn't be an obvious reflexive coercion. For example, it is guaranteed in L.MghcReturn the left-hand type of the axiom, when the axiom is instantiated at the types given.Mghc5Instantiate the left-hand side of an unbranched axiomMghc$Make a coercion from a coercion holeMghc Extract the nth field of a FunCoMghcGiven ty :: k1,  co :: k1 ~ k2 , produces co' :: ty ~r (ty |> co)MghcGiven r, ty :: k1, and co :: k1 ~N k2 , produces co' :: (ty |> co) ~r tyMghcGiven ty :: k1,  co :: k1 ~ k2, co2:: ty ~r ty', produces @co' :: (ty |> co) ~r ty' It is not only a utility function, but it saves allocation when co is a GRefl coercion.MghcGiven ty :: k1,  co :: k1 ~ k2, co2:: ty' ~r ty, produces @co' :: ty' ~r (ty |> co) It is not only a utility function, but it saves allocation when co is a GRefl coercion.ghcChanges a role, but only a downgrade. See Note [Role twiddling functions]MghcLike , but panics if the change isn't a downgrade. See Note [Role twiddling functions]MghcConverts a coercion to be nominal, if possible. See Note [Role twiddling functions]Mghclike mkKindCo, but aggressively & recursively optimizes to avoid using a KindCo constructor. The output role is nominal.ghcsay g = promoteCoercion h. Then, instCoercion g w yields Just g' , where g' = promoteCoercion (h w)%. fails if this is not possible, if g coerces between a forall and an -> or if second parameter has a representational role and can't be used with an InstCo.ghcRepeated use of MghcCreates a new coercion with both of its types casted by different casts !castCoercionKind2 g r t1 t2 h1 h2, where  g :: t1 ~r t2 , has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal.MghccastCoercionKind1 g r t1 t2 h = coercionKind g r t1 t2 h h That is, it's a specialised form of castCoercionKind, where the two kind coercions are identical castCoercionKind1 g r t1 t2 h, where  g :: t1 ~r t2 , has type (t1 |> h) ~r (t2 |> h). h/ must be nominal. See Note [castCoercionKind1]MghcCreates a new coercion with both of its types casted by different casts castCoercionKind g h1 h2, where  g :: t1 ~r t2 , has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal. It calls coercionKindRole#, so it's quite inefficient (which I stands for) Use castCoercionKind2 instead if t1, t2, and r are known beforehand.MghcMake a forall , where both types related by the coercion are quantified over the same variable.MghcIf `instNewTyCon_maybe T ts = Just (rep_ty, co)` then `co :: T ts ~R# rep_ty`-Checks for a newtype, and for being saturatedMghcTry one stepper and then try the next, if the first doesn't make progress. So if it returns NS_Done, it means that both steppers are satisfiedMghcA L that unwraps newtypes, careful not to fall into a loop. If it would fall into a loop, it produces L.MghcA general function for normalising the top-level of a type. It continues to use the provided L until that function fails, and then this function returns. The roles of the coercions produced by the L must all be the same, which is the role returned from the call to M.Typically ev is Coercion.If topNormaliseTypeX step plus ty = Just (ev, ty') then ty ~ev1~ t1 ~ev2~ t2 ... ~evn~ ty' and ev = ev1 plus ev2 plus ... plus evn If it returns Nothing then no newtype unwrapping could happenMghcSyntactic equality of coercionsMghc Compare two s, with respect to an RnEnv2Mghc,Extend a lifting context with a new mapping.MghcExtend a lifting context with a new mapping, and extend the in-scope setghcExtend a lifting context with existential-variable bindings. See Note [extendLiftingContextEx]Mghc+Erase the environments in a lifting contextMghcLike F , but works on a lifting contextghcThe "lifting" operation which substitutes coercions for type variables in a type to produce a coercion.For the inverse operation, see  liftCoMatchMghc,Is a var in the domain of a lifting context?Mghc"Apply "sym" to all coercions in a LMghc;Extract the underlying substitution from the LiftingContextMghcGet the ( from a @MghcApply @ to multiple sMghcGet a coercion's kind and role.Mghc"Retrieve the role from a coercion.MghcCreates a primitive type equality predicate. Invariant: the types are not CoercionsMghc3Makes a lifted equality predicate at the given roleMghc?Creates a primitive type equality predicate with explicit kindsMghcCreates a primitive representational type equality predicate with explicit kindsMghcAssuming that two types are the same, ignoring coercions, find a nominal coercion between the types. This is useful when optimizing transitivity over coercion applications, where splitting two AppCos might yield different kinds. See Note [EtaAppCo] in GHC.Core.Coercion.Opt.Mghc&Is there a coercion hole in this type?Mghc*Is there a coercion hole in this coercion?MghcSet the type of a B @ghc!role of the created coercion, "r"ghc:: phi1 ~N phi2ghc g1 :: phi1ghc g2 :: phi2ghc :: g1 ~r g2@ghcrole of the built coercion, "r"ghct1 :: k1ghct2 :: k2ghc :: t1 ~r t2@ghc :: t1 ~r t2ghc%:: s1 ~N s2, where s1 :: k1, s2 :: k2ghc:: t1 s1 ~r t2 s2Mghc multiplicityghcargumentghcresultghcOne of the above threeghc desired roleghc current roleghcmust be nominalMghc original LCghcnew variable to map...ghc...to this lifted versionMghc Original LCghcnew variable to map...ghcto this coercionghcoriginal lifting contextghcex. var / value pairsMghccoercion getterghccallbackghccoercion getterghccallbackghccoercion getterghccallbackBBBBBBBBBBBBBBBBCC!!!&MLLLL@@@@@@@MMM@@L@@LLLLMMMMMM@@@MM@@@L@@@LM@L@LL@M@@@@M@MMMM@MMMMMMMMMLLLLLMM@MLL@LLLLLLMMMMMMM!@@LL@LLLLLLLLLLLLLLLLL''LLLEEEEEECEEEFFFFFFFFE@MMMMMMMMMMMMML@LMMMMMMMMM@LLLLLLLFFMMLLMMMMBBBBBBBBBBBBBBBBCC!!!&MLLLL@@@@@@@MMM@@L@@LLLLMMMMMM@@@MM@@@L@@@LM@L@LL@M@@@@M@MMMM@MMMMMMMMMLLLLLMM@MLL@LLLLLLMMMMMMM!@@LL@LLLLLLLLLLLLLLLLL''LLLEEEEEECEEEFFFFFFFFE@MMMMMMMMMMMMML@LMMMMMMMMM@LLLLLLLFFMMLLMMMM Safe-InferredExample: main = do _ <- getCurrentTimeMghcSuggests adding an identifier to the export list of a signature.MghcSuggests increasing the limit for the number of iterations in the simplifier.MghcSuggests to explicitly import Type from the + module, because using "*" to mean  relies on the StarIsType extension, which will become deprecated in the future.Triggered by:  Example: None Test case(s): wcompat-warnings/WCompatWarningsOn.hsMghcSuggests placing the  qualified keyword after the module name.Triggered by: = Example: None Test case(s): module/mod184.hsMghc0Suggests using TemplateHaskell quotation syntax.Triggered by:  only if TemplateHaskell is enabled. Example: None Test case(s): parser should_fail T13450TH.hsMghc;Suggests alternative roles in case we found an illegal one.Triggered by: 2 Example: None Test case(s): roles should_fail Roles7.hsMghcSuggests qualifying the r1 operator in modules where StarIsType is enabled.Triggered by:  Test case(s): warningsshould_compile StarBinder.hsMghc0Suggests that a type signature should have form  variable ::  type( in order to be accepted by GHC.Triggered by:  Test case(s): parser should_failT3811Mghc:Suggests to move an orphan instance or to newtype-wrap it.Triggered by:  Test cases(s): warningsshould_compile&T9178 typecheckshould_compileT4912MghcSuggests to use a standalone deriving declaration when GHC can't derive a typeclass instance in a trivial way.Triggered by: ! Test cases(s): typecheck should_fail tcfail086MghcSuggests the user to fill in the wildcard constraint to disambiguate which constraint that is.6Example: deriving instance _ => Eq (Foo f a)Triggered by: $ Test cases(s): partial-sigs should_fail T13324_fail2Mghc)Suggests to use an identifier other than forall Triggered by: MghcSuggests to use the appropriate Template Haskell tick: a single tick for a term-level $,, or a double tick for a type-level $.Triggered by: .MghcSuggests enabling -ddump-splices to help debug an issue when a  is not in scope or is used in multiple different namespaces (e.g. both as a data constructor and a type constructor).Concomitant with  NoExactName or SameName errors, see e.g. "GHC.Rename.Env.lookupExactOcc_either". Test cases: T5971, T7241, T13937.MghcSuggests adding a tick to refer to something which has been promoted to the type level, e.g. a data constructor.Test cases: T9778, T19984.MghcSomething is split off from its corresponding declaration. For example, a datatype is given a role declaration in a different module.&Test cases: T495, T8485, T2713, T5533.MghcSuggest a similar name that the user might have meant, e.g. suggest  when the user has written travrese.Test case: mod73.MghcRemind the user that the field selector has been suppressed because of -XNoFieldSelectors.4Test cases: NFSSuppressed, records-nofieldselectors.Mghc,Suggest importing from a module, removing a hiding clause, or explain to the user that we couldn't find a module with the given  .,Test cases: mod28, mod36, mod87, mod114, ...MghcSuggest importing a data constructor to bring it into scope Triggered by: Test cases: ccfail004MghcSuggest using pattern matching syntax for a non-bidirectional pattern synonymTest cases: patsyn should_fail,record-exquant typecheck should_failT3176MghcSuggest tips for making a definition visible for the purpose of writing a SPECIALISE pragma for it in a different module.Test cases: noneNghcSuggest to enable the input extension. This is the hint that GHC emits if this is not a "known" fix, i.e. this is GHC giving its best guess on what extension might be necessary to make a certain program compile. For example, GHC might suggests to enable BlockArguments when the user simply formatted incorrectly the input program, so GHC here is trying to be as helpful as possible. If the input   is not empty, it will contain some extra information about the why the extension is required, but it's totally irrelevant/redundant for IDEs and other tools.NghcSuggest to enable the input extensions. The list is to be intended as  disjunctive' i.e. the user is suggested to enable any) of the extensions listed. If the input   is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.NghcSuggest to enable the input extensions. The list is to be intended as  conjunctive' i.e. the user is suggested to enable all& the extensions listed. If the input   is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.NghcSuggest to enable the input extension in order to fix a certain problem. This is the suggestion that GHC emits when is more-or-less clear "what's going on". For example, if both DeriveAnyClass and GeneralizedNewtypeDeriving5 are turned on, the right thing to do is to enabled DerivingStrategies, so in contrast to N GHC will be a bit more "imperative" (i.e. "Use X Y Z in order to ... "). If the input   is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.NghcThe bindings we have available in scope when suggesting an explicit type signature.Nghc8An unknown binding (i.e. too complicated to turn into a )Nghc4Suggests a single extension without extra user info.NghcLike N. but allows supplying extra info for the user.NghcSuggests to enable every extension in the list.NghcLike N. but allows supplying extra info for the user.NghcSuggests to enable any extension in the list.NghcLike N. but allows supplying extra info for the user.NghcWhether a constructor name is printed out as a bare symbol, e.g. :.*True for symbolic names in infix position.Used for pretty-printing.Nghc$Display info about the treatment of r under NoStarIsType.%With StarIsType, three properties of r hold:(a) it is not an infix operator (b) it is always in scope (c) it is a synonym for Data.Kind.TypeHowever, the user might not know that they are working on a module with NoStarIsType and write code that still assumes (a), (b), and (c), which actually do not hold in that module.Violation of (a) shows up in the parser. For instance, in the following examples, we have r! not applied to enough arguments:data A :: * data F :: * -> *Violation of (b) or (c) show up in the renamer and the typechecker respectively. For instance:type K = Either * BoolThis will parse differently depending on whether StarIsType is enabled, but it will parse nonetheless. With NoStarIsType it is parsed as a type operator, thus we have ((*) Either Bool). Now there are two cases to consider: There is no definition of (*) in scope. In this case the renamer will fail to look it up. This is a violation of assumption (b).There is a definition of the (*) type operator in scope (for example coming from GHC.TypeNats). In this case the user will get a kind mismatch error. This is a violation of assumption (c).The user might unknowingly be working on a module with NoStarIsType or use r as  out of habit. So it is important to give a hint whenever an assumption about r is violated. Unfortunately, it is somewhat difficult to deal with (c), so we limit ourselves to (a) and (b).N returns appropriate hints to the user depending on the extensions enabled in the module and the name that triggered the error. That is, if we have NoStarIsType and the error is related to r0 or its Unicode variant, we will suggest using '; otherwise we won't suggest anything.Mghc8fixity declaration, role annotation, type signature, ...ghcthe + for the declaration siteMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNMMNNNNNMMMMMMMMMMMMMMMNNNNNNNNNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNMMNNNNNMMMMMMMMMMMMMMMNNNNNNNNNN Safe-Inferred)*9:;\,NghcA diagnostic code is a namespaced numeric identifier unique to the given diagnostic (error or warning).All diagnostic codes defined within GHC are given the GHC namespace.5See Note [Diagnostic codes] in GHC.Types.Error.Codes.Nghcdiagnostic code prefix (e.g. GHC)Nghcthe actual diagnostic codeNghcUsed to describe warnings and errors o The message has a file/line/column heading, plus "warning:" or "error:", added by mkLocMessage o With N the message is suppressed o Output is intended for end usersNghcIgnore this message, for example in case of suppression of warnings users don't want to see. See Note [Suppressing Messages]NghcThe class for a diagnostic message. The main purpose is to classify a message within GHC, to distinguish it from a debug/dump message vs a proper diagnostic, for which we include a N.NghcLog message intended for compiler developers No file/line/column stuffNghcLog messages intended for end users. No file/line/column stuff.NghcDiagnostics from the compiler. This constructor is very powerful as it allows the construction of a N- with a completely arbitrary permutation of N and N,. As such, users are encouraged to use the mkMCDiagnostic smart constructor instead. Use this constructor directly only if you need to construct and manipulate diagnostic messages directly, for example inside ". In all the other circumstances,  especially when emitting compiler diagnostics, use the smart constructor.The Maybe N field carries a code (if available) for this diagnostic. If you are creating a message not tied to any error-message type, then use Nothing. In the long run, this really should always have a N. See Note [Diagnostic codes].NghcAn envelope for GHC's facts about a running program, parameterised over the domain-specific5 (i.e. parsing, typecheck-renaming, etc) diagnostics.%To say things differently, GHC emits  diagnostics= about the running program, each of which is wrapped into a N that carries specific information like where the error happened, etc. Finally, multiple Ns are aggregated into N that are returned to the user.Nghc=The SrcSpan is used for sorting errors into line-number orderNghc The reason why a N was emitted in the first place. Diagnostic messages are born within GHC with a very precise reason, which can be completely statically-computed (i.e. this is an error or a warning no matter what), or influenced by the specific state of the DynFlags) at the moment of the creation of a new N#. For example, a parsing error is always going to be an error, whereas a 'WarningWithoutFlag Opt_WarnUnusedImports' might turn into an error due to '-Werror' or '-Werror=warn-unused-imports'. Interpreting a N together with its associated N gives us the full picture.NghcBorn as a warning.Nghc"Warning was enabled with the flag.NghcBorn as an error.Nghc A generic N message, without any further classification or provenance: By looking at a N we don't know neither where it was generated nor how to intepret its payload (as it's just a structured document). All we can do is to print it out and look at its N.Nghc A generic Hint message, to be used with N.Nghc4An existential wrapper around an unknown diagnostic.NghcA class identifying a diagnostic. Dictionary.com defines a diagnostic as:"a message output by a computer diagnosing an error in a computer program, computer system, or component device".A N carries the actual description of the message (which, in GHC's case, it can be an error or a warning) and the reason4 why such message was generated in the first place.Nghc1Type of configuration options for the diagnostic.Nghc&Extract the error message text from a N.Nghc9Extract the reason for this diagnostic. For warnings, a N includes the warning flag.NghcExtract any hints a user might use to repair their code to avoid this diagnostic.NghcGet the N associated with this N. This can return J for at least two reasons: >The message might be from a plugin that does not supply codes.The message might not yet have been assigned a code. See the N instance for N.Ideally, case (2) would not happen, but because some errors in GHC still use the old system of just writing the error message in-place (instead of using a dedicated error type and constructor), we do not have error codes for all errors. #18516 tracks our progress toward this goal.NghcA N is isomorphic to a '[SDoc]' but it carries the invariant that the input '[SDoc]' needs to be rendered  decorated into its final form, where the typical case would be adding bullets between each elements of the list. The type of decoration depends on the formatting function used, but in practice GHC uses the formatBulleted.NghcA collection of messages emitted by GHC during error reporting. A diagnostic message is typically a warning or an error. See Note [Messages]. INVARIANT: All the messages in this collection must be relevant, i.e. their N should not be N. The smart constructor N# will filter out any message which N is N.NghcAdds a Message to the input collection of messages. See Note [Discarding Messages].NghcJoins two collections of messages together. See Note [Discarding Messages].Nghc Joins many N s togetherNghcCreates a new N out of a list of  .NghcCreates a new N out of a single  Nghc Joins two N together. The resulting N will have a number of entries which is the sum of the lengths of the input.Nghc5Apply a transformation function to all elements of a N.NghcHelper function to use when no hints can be provided. Currently this function can be used to construct plain N and add hints to them, but once #18516 will be fully executed, the main usage of this function would be in the implementation of the N9 typeclass method, to report the fact that a particular N has no hints.NghcCreate an error N holding just a single  Nghc Create a N% from a list of bulleted SDocs and a NNghcCreate an error N from a list of bulleted SDocsghc Shows an N. Only use this for debugging.NghcMake an error message with location info, specifying whether to show warning groups (if applicable).NghcReturns L if this is, intrinsically, a failure. See Note [Intrinsic And Extrinsic Failures].Nghc5Are there any hard errors here? -Werror warnings are not; detected. If you want to check for -Werror warnings, use N.NghcReturns L if the envelope contains a message that will stop compilation: either an intrinsic error or a fatal (-Werror) warningNghc.Are there any errors or -Werror warnings here?NghcPartitions the N and returns a tuple which first element are the warnings, and the second the errors.NghcWhat kind of message?ghclocationghcmessageNghc%Print warning groups (if applicable)?ghcWhat kind of message?ghclocationghcmessageNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNN NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNN NNNNNNNNNNNNNNNNNNNNNN Safe-Inferred ghcLog hooks stackghcDump hooks stackghcTrace hooks stackghc= to the given valueOghcUpdate LogFlagsOghc Set LogFlagsOghcSet the trace flushing functionThe currently set trace flushing function is passed to the updating functionOghc!Calls the trace flushing functionghc.Default trace flushing function (flush stderr)Oghc Log somethingOghcDump somethingOghcTrace somethingOghcPush a log hookOghcPop a log hookOghcPush a dump hookOghcPop a dump hookOghcPush a trace hookOghcPop a trace hookOghcMake the logger thread-safeOghcLike O but appends an extra newline.OghcThe boolean arguments let's the pretty printer know if it can optimize indent by writing ascii ' ' characters without going through decoding.OghcDefault action for  dumpAction hookghcWrite out a dump.If --dump-to-file is set then this goes to a file. otherwise emit to stdout (via the LogAction parameter).When hdr is empty, we print in a more compact format (no separators and blank lines)Oghc#Run an action with the handle of a , if we are outputting to a file, otherwise J.ghc>Choose where to put a dump file based on LogFlags and DumpFlagOghcDefault action for  traceAction hookOghc Log somethingOghcDump somethingOghcLog a trace messageOghc$Log a dump message (not a dump file)Oghc!Dump if the given DumpFlag is setOghc!Dump if the given DumpFlag is setUnlike O, has a NamePprCtx argumentOghc9Ensure that a dump file is created even if it stays emptyNNNNNNOOOONNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOONNNNNOOOONNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOONOOOOOOOOOOOOOOOOOOOOO Safe-Inferred (9 OghcMonomorphic version of  Validity' specialised for  s.OghcEverything is fineOghc%A problem, and some indication of whyOghcEnabled warningsOghcFatal warningsOghcTreat warnings as errorsOghcReverse error reporting orderOghcMax reported error countOghcError printing contextOghc Computes the right N for the input N& out of the 'DiagOpts. This function has to be called when a diagnostic is constructed, i.e. with a 'DiagOpts "snapshot" taken as close as possible to where a particular diagnostic message is built, otherwise the computed N9 might not be correct, due to the mutable nature of the DynFlags in GHC.OghcMake a N for a given N, consulting the 'DiagOpts.Oghc Varation of O which can be used when we are sure the input N is N! and there is no diagnostic code.OghcWrap a N in a N,, recording its location. If you know your N is an error, consider using O), which does not require looking at the OOghcWrap a N in a N, recording its location. Precondition: the diagnostic is, in fact, an error. That is, (diagnosticReason msg == ErrorWithoutFlag.Oghc= 2 or -ddump-timings).See Note [withTiming] for more.ghc Worker for O and O.OghcLike O but with  SevOutput rather then SevInfoOghc+Trace a command (when verbosity level >= 3)OghcRecord in the eventlog when the given tool command starts and finishes, prepending the given : with "systool:", to easily be able to collect and process all the systool events.For those events to show up in the eventlog, you need to run GHC with -v2 or -ddump-timings.OghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghc!The body of the phase to be timedOghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghc!The body of the phase to be timedghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghcWhether to print the timingsghc!The body of the phase to be timedOOOOOOONNNNNNNNNNNNNNNNNNNNNNNN NNNNNNNNOOOOOOOOOOOOOOOONNNOOOOOOONNNNNNOOOOOOOOOOOOOOOOOOOOOOOONNNNNNNNNNNNNNNNNNNNNNNN NNNNNNNNOOOOOOOOOOOOOOOONNNOOOOOOONNNNNNOOOOOOOOOOOOOOOOO Safe-Inferred #tOghcUsed when a temp file is created. This determines which component Set of PathsToClean will get the temp fileOghcA file with lifetime TFL_CurrentModule will be cleaned up at the end of upweep_modOghcA file with lifetime TFL_GhcSession will be cleaned up at the end of runGhc(T)Oghc do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342.PghcDirectory name template. See  openTempFile.ghc#Callback that can use the directoryPghc)Temp directory to create the directory inghcDirectory name template. See  openTempFile.ghc#Callback that can use the directoryOOOOOOOOOOOOOOOOOOPPPPPPPOOOOOOOOOOOOOOOOOOPPPPPPP Safe-Inferred .$PghcCurrent profilePghcThe module being compiled. This field kept lazy for Cmm/Parser.y which preloads it with a panicPghc&Temp Dir for files used in compilationPghcContext for StgToCmm phasePghc+Whether we wish to output debug informationPghcThreshold at which Binary literals (e.g. strings) are either dumped to a file and a CmmFileEmbed literal is emitted (over threshold), or become a CmmString Literal (under or at threshold). CmmFileEmbed is only supported with the NCG, thus a Just means two things: We have a threshold, and will be using the NCG. Conversely, a Nothing implies we are not using NCG and disables CmmFileEmbed. See Note [Embedding large binary blobs] in GHC.CmmToAsm.Ppr, and  cgTopBinding in GHC.StgToCmm.Qghc0Max size, in bytes, of inline array allocations.QghcTicky profiling enabled (cf -ticky)QghcTrue indicates ticky prof traces allocs of each named thing in addition to allocs _by_ that thingQghcTrue indicates ticky uses name-specific counters for join-points (let-no-escape)QghcTrue indicates ticky uses name-specific counters for dynamic thunksQghcTrue indicates ticky will count number of avoided tag checks by tag inference.QghcLoopification enabled (cf -floopification)QghcInsert alignment check (cf -falignment-sanitisation)Qghc)perform code generation for code coverageQghc)Check if cost-centre profiling is enabledQghctrue means generate C Stub for IPE map, See Note [Mapping Info Tables to Source Positions]QghcInclude info tables with fallback source locations in the info table mapQghc, meaning generate code for linking against dynamic librariesQghc>decides whether to check array bounds in StgToCmm.Prim or notQghc!Verify tag inference predictions.QghcAllowed to emit larger than native size arithmetic (only LLVM and C backends)Qghc(Allowed to generate QuotRem instructionsQghcAllowed to generate QuotRemQghc2Allowed to generate AddWordC, SubWordC, Add2, etc.Qghc'Allowed to generate IntMul2 instructionQghc+Disable use of precomputed standard thunks.QghcError (if any) to raise when vector instructions are used, see #StgToCmm.Prim.checkVecCompatibilityQghc$check for Advanced Vector ExtensionsQghc&check for Advanced Vector Extensions 2Qghc,check for Advanced Vector 512-bit Extensions)PPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ)PPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ Safe-Inferred / 2 PghcOutput should be to a temporary file: we're going to run more compilation steps on this output later.PghcWe want a persistent file, i.e. a file in the current directory derived from the input filename, but with the appropriate extension. eg. in "ghc -c Foo.hs" the output goes into ./Foo.o.PghcThe output must go into the specific outputFile in DynFlags. We don't store the filename in the constructor as it changes when doing -dynamic-too.Pghc>No output should be created, like in Interpreter or NoBackend.PghcStop just after this phasePghc!basename of original input sourcePghc!basename of original input sourcePghc its extensionPghc%says where to put the pipeline outputPghcLift a f action into an m action.PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP Safe-Inferred :ghc A sectionghcName of the sectionghcContent of the sectionghc Description of the section tableghc'offset of the table describing sectionsghc%size of an entry in the section tableghcnumber of sectionsghc DynFlags -> IO [String]Pghc-No additional command-line options are neededPghcReturn command-line options that tell GHC about the LLVM version.PghcNames a function that tells the driver what should happen after assembly code is written. This might include running a C compiler, running LLVM, running an assembler, or various similar activities. The function named normally has this type:  TPipelineClass TPhase m => PipeEnv -> HscEnv -> Maybe ModLocation -> FilePath -> m (Maybe FilePath)&The functions so named are defined in GHC.Driver.Pipeline.Pghc0After code generation, nothing else need happen.PghcNames a function that generates code and writes the results to a file, of this type:  Logger -> DynFlags -> Module -- ^ module being compiled -> ModLocation -> FilePath -- ^ Where to write output -> Set UnitId -- ^ dependencies -> Stream IO RawCmmGroup a -- results from `StgToCmm` -> IO a&The functions so named are defined in GHC.Driver.CodeOutput.We expect one function per back end@or more precisely, one function for each back end that writes code to a file. (The interpreter does not write to files; its output lives only in memory.)PghcNames a function that discover from what toolchain the assembler is coming, of this type: 1Logger -> DynFlags -> Platform -> IO CompilerInfo&The functions so named are defined in GHC.Driver.Pipeline.Execute.Pghc)Interrogate the standard system assemblerPghc If using the JS backend; return  EmscriptenPghcIf running on Darwin, return Clang7; otherwise interrogate the standard system assembler.Pghc7Names a function that runs the assembler, of this type: 3Logger -> DynFlags -> Platform -> [Option] -> IO ()&The functions so named are defined in GHC.Driver.Pipeline.Execute.Pghc!Use the standard system assemblerPghcJS Backend compile to JS via Stg, and so does not use any assemblerPghc1If running on Darwin, use the assembler from the clang: toolchain. Otherwise use the standard system assembler.PghcThis enumeration type specifies how the back end wishes GHC's primitives to be implemented. (Module GHC.StgToCmm.Prim provides a generic implementation of every primitive, but some primitives, like  IntQuotRemOp, can be implemented more efficiently by certain back ends on certain platforms. For example, by using a machine instruction that simultaneously computes quotient and remainder.).For the meaning of each alternative, consult GHC.StgToCmm.Config. (In a perfect world, type P would be defined there, in the module that determines its meaning. But I could not figure out how to do it without mutual recursion across module boundaries.)PghcPrimitives supported by LLVMPghc1Primitives supported by the native code generatorPghc"Primitives supported by JS backendPghc%Primitives supported by all back endsPghcAvalue of type Backend represents one of GHC's back ends. The set of back ends cannot be extended except by modifying the definition of Backend in this module.The Backend type is abstract; thatis, its value constructors are not exported. It's crucial that they not be exported, because a value of type Backend carries only the back end's name', not its behavior or properties. If Backend were not abstract, then code elsewhere in the compiler could depend directly on the name, not on the semantics, which would make it challenging to create a new back end. Because Backend is abstract, all the obligations of a new back end are enumerated in this module, in the form of functions that take Backend as an argument.The issue of abstraction is discussed at great length in #20927 and !7442.Pghc7Is the platform supported by the Native Code Generator?ghc,Is the platform supported by the JS backend?PghcThe native code generator. Compiles Cmm code into textual assembler, then relies on an external assembler toolchain to produce machine code.4Only supports a few platforms (X86, PowerPC, SPARC).See  GHC.CmmToAsm.PghcThe LLVM backend.Compiles Cmm code into LLVM textual IR, then relies on LLVM toolchain to produce machine code.It relies on LLVM support for the calling convention used by the NCG backend to produce code objects ABI compatible with it (see "cc 10" or "ghccc" calling convention in  7https://llvm.org/docs/LangRef.html#calling-conventions).4Supports a few platforms (X86, AArch64, s390x, ARM).See  GHC.CmmToLlvmPghcThe JavaScript Backend See documentation in GHC.StgToJSPghc!Via-C ("unregisterised") backend.Compiles Cmm code into C code, then relies on a C compiler to produce machine code."It produces code objects that are not> ABI compatible with those produced by NCG and LLVM backends.Produced code is expected to be less efficient than the one produced by NCG and LLVM backends because STG registers are not pinned into real registers. On the other hand, it supports more target platforms (those having a valid C toolchain).See  GHC.CmmToCPghcThe ByteCode interpreter.#Produce ByteCode objects (BCO, see  GHC.ByteCode/) that can be interpreted. It is used by GHCi.?Currently some extensions are not supported (foreign primops).See GHC.StgToByteCodePghc(A dummy back end that generates no code.Use this back end to disable code generation. It is particularly useful when GHC is used as a library for other purpose than generating code (e.g. to generate documentation with Haddock) or when the user requested it (via `-fno-code`) for some reason.PghcAn informal description of the back end, for use in issuing warning messages only. If code depends on what's in the string, you deserve what happens to you.PghcThis flag tells the compiler driver whether the back end will write files: interface files and object files. It is typically true for "real" back ends that generate code into the filesystem. (That means, not the interpreter.)PghcWhen the back end does write files, this value tells the compiler in what manner of file the output should go: temporary, persistent, or specific.PghcThis flag tells the driver whether the back end can reuse code (bytecode or object code) that has been loaded dynamically. Likely true only of the interpreter.Pghc'It is is true of every back end except  -fno-code that it "generates code." Surprisingly, this property influences the driver in a ton of ways. Some examples:If the back end does not generate code, then the driver needs to turn on code generation for Template Haskell (because that code needs to be generated and run at compile time).If the back end does not generate code, then the driver does not need to deal with an output file.If the back end does/ generated code, then the driver supports  HscRecomp. If not, recompilation does not need a linkable (and is automatically up to date).PghcWhen set, this flag turns on interface writing for Backpack. It should probably be the same as P, but it is kept distinct for reasons described in Note [-fno-code mode].PghcWhen preparing code for this back end, the type checker should pay attention to SPECIALISE pragmas. If this flag is I, then the type checker ignores SPECIALISE pragmas (for imported things?).PghcThis back end wants the  mi_globals field of a ModIface to be populated (with the top-level bindings of the original source). True for the interpreter, and also true for "no backend", which is used by Haddock. (After typechecking a module, Haddock wants access to the module's  GlobalRdrEnv.)Pghc3The back end targets a technology that implements switch natively. (For example, LLVM or C.) Therefore it is not necessary for GHC to ccompile a Cmm Switch< form into a decision tree with jump tables at the leaves.Pghc#As noted in the documentation for P, certain primitives have multiple implementations, depending on the capabilities of the back end. This field signals to module GHC.StgToCmm.Prim1 what implementations to use with this back end.PghcWhen this value is O, the back end is compatible with vector instructions. When it is O/, it carries a message that is shown to users.PghcThis flag says whether the back end supports large binary blobs. See Note [Embedding large binary blobs] in GHC.CmmToAsm.Ppr.PghcThis flag tells the compiler driver that the back end does not support every target platform; it supports only platforms that claim NCG support. (It's set only for the native code generator.) Crufty. If the driver tries to use the native code generator without platform support, the driver fails over to the LLVM back end.PghcThis flag is set if the back end can generate code for proc points. If the flag is not set, then a Cmm pass needs to split proc points (that is, turn each proc point into a standalone procedure).PghcThis flag guides the driver in resolving issues about API support on the target platform. If the flag is set, then these things are true:"When the target platform supports only an unregisterised API, this backend can be replaced with compilation via C.When the target does not support an unregisterised API, this back end can replace compilation via C.PghcThis flag is true if the back end works *only* with the unregisterised ABI.Pghc8This flag is set if the back end generates C code in a .hc file. The flag lets the compiler driver know if the command-line flag -C is meaningful.PghcThis flag says whether SPT (static pointer table) entries will be inserted dynamically if needed. If this flag is I, then GHC.Iface.Tidy6 should emit C stubs that initialize the SPT entries.PghcIf this flag is set, then GHC.HsToCore.Ticks inserts  Breakpoint( ticks. Used only for the interpreter.PghcIf this flag is set, then the driver forces the optimization level to 0, issuing a warning message if the command line requested a higher optimization level.PghcI don't understand exactly how this works. But if this flag is set *and* another condition is met, then  ghc/Main.hs will alter the DynFlags so that all the  hostFullWays4 are asked for. It is set only for the interpreter.PghcThis flag is also special for the interpreter: if a message about a module needs to be shown, do we know anything special about where the module came from? The Boolean argument is a recomp flag.PghcThis flag says whether the back end supports Haskell Program Coverage (HPC). If not, the compiler driver will ignore the `-fhpc` option (and will issue a warning message if it is used).PghcThis flag says whether the back end supports foreign import of C functions. (Supports means "does not barf on," so  -fno-code supports foreign C imports.)PghcThis flag says whether the back end supports foreign export of Haskell functions to C.PghcThis (defunctionalized) function runs the assembler used on the code that is written by this back end. A program determined by a combination of back end, DynFlags, and % is run with the given Options.The function's type is 7 Logger -> DynFlags -> Platform -> [Option] -> IO ()  This field is usually defaulted.PghcThis (defunctionalized) function is used to retrieve an enumeration value that characterizes the C/assembler part of a toolchain. The function caches the info in a mutable variable that is part of the DynFlags.The function's type is 5 Logger -> DynFlags -> Platform -> IO CompilerInfo  This field is usually defaulted.PghcWhen using this back end, it may be necessary or advisable to pass some `-D` options to a C compiler. This (defunctionalized) function produces those options, if any. An IO action may be necessary in order to interrogate external tools about what version they are, for example.The function's type is % Logger -> DynFlags -> IO [String]  This field is usually defaulted.PghcThis (defunctionalized) function generates code and writes it to a file. The type of the function is  Logger -> DynFlags -> Module -- ^ module being compiled -> ModLocation -> FilePath -- ^ Where to write output -> Set UnitId -- ^ dependencies -> Stream IO RawCmmGroup a -- results from `StgToCmm` -> IO aPghcThis (defunctionalized) function tells the compiler driver what else has to be run after code output. The type of the function is  TPipelineClass TPhase m => PipeEnv -> HscEnv -> Maybe ModLocation -> FilePath -> m (Maybe FilePath)PghcSomewhere in the compiler driver, when compiling Haskell source (as opposed to a boot file or a sig file), it needs to know what to do with the code that the P writes to a file. This > value gives instructions like "run the C compiler", "run the assembler," or "run the LLVM Optimizer."PghcName of the back end, if any. Used to migrate legacy clients of the GHC API. Code within the GHC source tree should not refer to a back end's name.PghcA list of all back ends. They are ordered as we wish them to appear when they are enumerated in error messages.PghcWhen foreign C import or export is invalid, the carried value enumerates the valid back ends.PghcWhen foreign C import or export is invalid, the carried value enumerates the valid back ends.Pghc"The Show instance is for messages only. If code depends on what's in the string, you deserve what happens to you.PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP Safe-Inferred)* >ghcA FlatSwitchPlan is a list of SwitchPlans, with an integer in between every two entries, dividing the range. So if we have (abusing list syntax) [plan1,n,plan2], then we use plan1 if the expression is < n, and plan2 otherwise.PghcA SwitchPlan abstractly describes how a Switch statement ought to be implemented. See Note [createSwitchPlan]Pghc>A value of type SwitchTargets contains the alternatives for a  CmmSwitch value, and knows whether the value is signed, the possible range, an optional default value and a map from values to jump labels.ghcNumber of consecutive default values allowed in a jump table. If there are more of them, the jump tables are split.Currently 7, as it costs 7 words of additional code when a jump table is split (at least on x64, determined experimentally).ghcMinimum size of a jump table. If the number is smaller, the switch is implemented using conditionals. Currently 5, because an if-then-else tree of 4 values is nice and compact.ghcMinimum non-zero offset for a jump table. See Note [Jump Table Offset].PghcThe smart constructor mkSwitchTargets normalises the map a bit: * No entries outside the range * No entries equal to the default * No default if all elements have explicit valuesPghc7Changes all labels mentioned in the SwitchTargets valuePghcReturns the list of non-default branches of the SwitchTargets valuePghc3Return the default label of the SwitchTargets valuePghc+Return the range of the SwitchTargets valuePghc.Return whether this is used for a signed valuePghcswitchTargetsToTable creates a dense jump table, usable for code generation.Also returns an offset to add to the value; the list is 0-based on the result of that addition.The conversion from Integer to Int is a bit of a wart, as the actual scrutinee might be an unsigned word, but it just works, due to wrap-around arithmetic (as verified by the CmmSwitchTest test case).Pghc Just n * gibberish => NothingghcDiscards a leading equals signQghc%Parse a response file into arguments.Qghccmdline parser specghcargsghcresponse file handler1QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ1QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ Safe-Inferred Qghcddump-simpl-statsQghc%History size of the elaborate counterQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ Safe-Inferred Rghc>A choice of equality relation. This is separate from the type  because 3 does not define a (non-trivial) equality relation.RghcA predicate in the solver. The solver tries to prove Wanted predicates from Given ones.RghcA typeclass predicate.RghcA type equality predicate.RghcAn irreducible predicate.RghcA quantified predicate. sym kco )^ghc Create a ^ from a pair of a  and a 'Type.Pre-condition: the RHS type of the coercion matches the provided type (perhaps up to zonking).Use ^! when you only have the coercion.^ghc4Get the original, unreduced type corresponding to a ^.This is obtained by computing the LHS kind of the stored coercion, which may be slow.^ghcTurn a  into a ^- by inspecting the RHS type of the coercion. Prefer using ^ when you already know the RHS type of the coercion, to avoid computing it anew.^ghc1Downgrade the role of the coercion stored in the ^.^ghc1Downgrade the role of the coercion stored in the ^, from  to .^ghc0Compose a reduction with a coercion on the left.Pre-condition: the provided coercion's RHS type must match the LHS type of the coercion that is stored in the reduction.^ghcThe reflexive reduction.^ghc Create a ^ from a kind cast, in which the casted type is the rewritten type.Given ty :: k1, mco :: k1 ~ k2, produces the ^ ty ~res_co~> (ty |> mco) at the given .^ghc Create a ^ from a kind cast, in which the casted type is the rewritten type.Given ty :: k1, mco :: k1 ~ k2, produces the ^ ty ~res_co~> (ty |> mco) at the given .^ghc Create a ^ from a kind cast, in which the casted type is the original (non-rewritten) type.Given ty :: k1, mco :: k1 ~ k2, produces the ^ (ty |> mco) ~res_co~> ty at the given .^ghc Create a ^ from a kind cast, in which the casted type is the original (non-rewritten) type.Given ty :: k1, mco :: k1 ~ k2, produces the ^ (ty |> mco) ~res_co~> ty at the given .^ghc Apply a cast to the result of a ^.Given a ^ ty1 ~co1~> (ty2 :: k2) and a kind coercion kco with LHS kind k2, produce a new ^ ty1 ~co2~> ( ty2 |> kco ) of the given ; (which must match the role of the coercion stored in the ^ argument).^ghc Apply a cast to the result of a ^ , using an .Given a ^ ty1 ~co1~> (ty2 :: k2) and a kind coercion mco with LHS kind k2, produce a new ^ ty1 ~co2~> ( ty2 |> mco ) of the given ; (which must match the role of the coercion stored in the ^ argument).^ghcApply a cast to a ^1, casting both the original and the reduced type.Given cast_co and ^  ty ~co~> xi, this function returns the ^ ,(ty |> cast_co) ~return_co~> (xi |> cast_co) of the given ; (which must match the role of the coercion stored in the ^ argument).Pre-condition: the  passed in is the same as the LHS type of the coercion stored in the ^.^ghcApply casts on both sides of a ^ (of the given ).Use ^ when you want to cast both the original and reduced types in a ^ using the same coercion.Pre-condition: the  passed in is the same as the LHS type of the coercion stored in the ^.^ghc Apply one ^ to another. Combines @ and '.^ghcCreate a function ^. Combines mkFunCo and C.^ghc Create a ^& associated to a  type, from a kind ^ and a body ^. Combines @ and .^ghc Create a ^ of a quantified type from a ^ of the body. Combines L and C.^ghc Create a ^# from a coercion between coercions. Combines @ and '.^ghcCreate a reflexive ^ whose RHS is the given , with the specified .^ghcCreate ^. from individual lists of coercions and types.The lists should be of the same length, and the RHS type of each coercion should match the specified type in the other list.^ghc Combines L and F.^ghc TyConAppCo for ^ s: combines @ and '.^ghcReduce the arguments of a @ .^ghcObtain ^ from a list of ^s by unzipping.^ghcheterogeneous reductionghc kind coercion^ghc desired roleghc current role^ghc original typeghccoercion to cast withghc'rewritten type, with rewriting coercion^ghc original typeghc!coercion to cast with on the leftghc'rewritten type, with rewriting coercionghc"coercion to cast with on the right^ghcmultiplicity reductionghcargument reductionghcresult reduction^ghckind reductionghcbody reduction^ghc!role of the created coercion, "r"ghcco :: phi1 ~N phi2ghc g1 :: phi1ghc g2 :: phi2ghcres_co :: g1 ~r g2)^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^)^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Safe-Inferred  QghcA Q is a Q which allows us to distinguish between binding forms whose binders have different types. For example, if we are doing a K lookup on (x :: Int) -> ()), we should not pick up an entry in the K for (x :: Bool) -> (): we can disambiguate this by matching on the type (or kind, if this a binder in a type) of the binder.We also need to do the same for multiplicity! Which, since multiplicities are encoded simply as a , amounts to have a Trie for a pair of types. Tries of pairs are composition.Qghc DeBruijn a represents a modulo alpha-renaming. This is achieved by equipping the value with a Q, which tracks an on-the-fly deBruijn numbering. This allows us to define an % instance for  DeBruijn a., even if this was not (easily) possible for a. Note: we purposely don't export the constructor. Make a helper function if you find yourself needing it.QghcA Q doesn't do a kind-check. Thus, when lookup up (t |> g), you'll find entries inserted under (t), even if (g) is non-reflexive.Qghc TypeMap a is a map from  to a. If you are a client, this is the type you want. The keys in this map may have different kinds.ghc!An equality relation between two s (known below as t1 :: k2 and t2 :: k2)ghc t1 /= t2ghct1 ~ t2? and there are not casts in either, therefore we can conclude k1 ~ k2ghct1 ~ t2 yet one of the types contains a cast so they may differ in kindghc TypeMapX a is the base map from  DeBruijn Type to a, but without the K optimization. See Note [Computing equality on types] in GHC.Core.Type.Qghc TypeMapG a is a map from  DeBruijn Type to a. The extended key makes it suitable for recursive traversal, since it can track binders, but it is strictly internal to this module. If you are including a Q inside another K, this is the type you want. Note that this lookup does not do a kind-check. Thus, all keys in this map must have the same kind. Also note that this map respects the distinction between Type and  Constraint, despite the fact that they are equivalent type synonyms in Core.ghcSqueeze out any synonyms, and change TyConApps to nested AppTys. Why the last one? See Note [Equality on AppTys] in GHC.Core.TypeWe also keep (Eq a => a) as a FunTy, distinct from ((->) (Eq a) a).Rghc Extend a Q$ with a type in the given context. 8extendTypeMapWithScope m (mkDeBruijnContext [a,b,c]) t v is equivalent to #extendTypeMap m (forall a b c. t) v<, but allows reuse of the context over multiple insertions.RghcConstruct a deBruijn environment with the given variables in scope. e.g. mkDeBruijnEnv [a,b,c] constructs a context  forall a b c.RghcSynthesizes a  DeBruijn a from an a9, by assuming that there are no bound binders (an empty Q<). This is usually what you want if there isn't already a Q in scope.'KKKKKKKKQRRRRQQRRRRRRRQQQQRRRQRRQRRRRRR'KKKKKKKKQRRRRQQRRRRRRRQQQQRRRQRRQRRRRRR Safe-Inferred 9 8RghcA regular type variableRghc#Declare that this type variable is apart from the type provided. That is, the type variable will never be instantiated to that type. See also Note [Binding when looking up instances] in GHC.Core.InstEnv.RghcWhy are two types R? R takes precedence: This is used (only) in Note [Infinitary substitution in lookup] in GHC.Core.InstEnv As of Feb 2022, we never differentiate between MARTypeFamily and MARTypeVsConstraint; it's really only MARInfinite that's interesting here.Rghcmatching e.g. F Int ~? BoolRghcmatching e.g. a ~? Maybe aRghcmatching Type ~? Constraint or the arrow types See Note [Type and Constraint are not apart] in GHC.Builtin.Types.PrimRghcSee Note [Unification result]Rghc2Some unification functions are parameterised by a R, which says whether or not to allow a certain unification to take place. A R takes the  involved along with the " it will potentially be bound to.It is possible for the variable to actually be a coercion variable (Note [Matching coercion variables]), but only when one-way matching. In this case, the  will be a C.RghctcMatchTy t1 t2) produces a substitution (over fvs(t1)) s such that s(t1) equals t2. The returned substitution might bind coercion variables, if the variable is an argument to a GADT constructor.Precondition: typeKind ty1 H typeKind ty2We don't pass in a set of "template variables" to be bound by the match, because tcMatchTy (and similar functions) are always used on top-level types, so we can bind any of the free variables of the LHS. See also Note [tcMatchTy vs tcMatchTyKi]RghcLike R, but allows the kinds of the types to differ, and thus matches them as well. See also Note [tcMatchTy vs tcMatchTyKi]RghcThis is similar to R, but extends a substitution See also Note [tcMatchTy vs tcMatchTyKi]RghcLike R but over a list of types. See also Note [tcMatchTy vs tcMatchTyKi]RghcLike R but over a list of types. See also Note [tcMatchTy vs tcMatchTyKi]RghcLike R, but extending a substitution See also Note [tcMatchTy vs tcMatchTyKi]RghcLike R, but extending a substitution See also Note [tcMatchTy vs tcMatchTyKi]ghc=Same as tc_match_tys_x, but starts with an empty substitutionghc Worker for R and RRghcThis one is called from the expression matcher, which already has a MatchEnv in handRghcAllow binding only for any variable in the set. Variables may be bound to any type. Used when doing simple matching; e.g. can we find a substitution S = [a :-> t1, b :-> t2] such that S( Maybe (a, b->Int ) = Maybe (Bool, Char -> Int) Rghc-Allow the binding of any variable to any typeRghcGiven a list of pairs of types, are any two members of a pair surely apart, even after arbitrary type function evaluation and substitution?RghcSimple unification of two types; all type variables are bindable Precondition: the kinds are already equalRghcLike R, but also unifies the kindsRghcUnify two types, treating type family applications as possibly unifying with anything and looking through injective type family applications. Precondition: kinds are the sameRghcLike R but also unifies the kindsRghctcUnifyTysFG bind_tv tys1 tys2! attempts to find a substitution s% (whose domain elements all respond R to bind_tv ) such that s(tys1) and that of s(tys2) are equal, as witnessed by the returned Coercions. This version requires that the kinds of the types are the same, if you unify left-to-right.ghcThis function is actually the one to call the unifier -- a little too general for outside clients, though.ghc(Converts any SurelyApart to a MaybeApartRghcR is sort of inverse to @. In particular, if  liftCoMatch vars ty co == Just s, then liftCoSubst s ty == co , where == there means that the result of @ has the same type as the original co; but may be different under the hood. That is, it matches a type against a coercion of the same "shape", and returns a lifting substitution which could have been used to produce the given coercion from the given type. Note that this function is incomplete -- it might return Nothing when there does indeed exist a possible lifting context.This function is incomplete in that it doesn't respect the equality in H. That is, it's possible that this will succeed for t1 and fail for t2, even when t1 H t2. That's because it depends on there being a very similar structure between the type and the coercion. This incompleteness shouldn't be all that surprising, especially because it depends on the structure of the coercion, which is a silly thing to do.The lifting context produced doesn't have to be exacting in the roles of the mappings. This is because any use of the lifting context will also require a desired role. Thus, this algorithm prefers mapping to nominal coercions where it can do so.ghc does all the actual work for R. RghcSubstitution to extendghcTemplateghcTargetRghcTemplateghcTargetghcOne-shot; in principle the template variables could be free in the targetRghcTemplateghcTargetghcOne-shot substitutionRghcSubstitution to extendghcTemplateghcTargetghcOne-shot substitutionRghcSubstitution to extendghcTemplateghcTargetghcOne-shot substitutionghc match kinds?ghc match kinds?Rghctemplate variablesghctype substitution to extendghcTemplateghcTargetRghcTrue  =" do two-way unification; False  =: do one-way matching. See end of sec 5.2 from the paperRghcA regular one-shot (idempotent) substitution that unifies the erased types. See comments for RghcTrue  = unify; False  = matchghcTrue  = doing an injectivity checkghcTrue  = treat the kinds as wellghcsubstitution to extendghcambient helpful infoghcincoming substghcty, type to matchghc+co :: lty ~r rty, coercion to match againstghc :: kind(lsubst(ty)) ~N kind(lty)ghc :: kind(rsubst(ty)) ~N kind(rty)ghcJust env ==> liftCoSubst Nominal env ty == co, modulo roles. Also: Just env ==> lsubst(ty) == lty and rsubst(ty) == rty, where lsubst = lcSubstLeft(env) and rsubst = lcSubstRight(env)#RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR#RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRz Safe-Inferred7 7#ghcAn # is a tyvar/type pair representing an equality made in rejigging a GADT constructor#ghcData Constructor Representation See Note [Data constructor workers and wrappers]#ghcA data constructor : , ,#ghcReturns an Id which looks like the Haskell-source constructor by using the wrapper if it exists (see S') and failing over to the worker (see #)#ghcIs this data constructor in a "type data" declaration? See Note [Type data declarations] in GHC.Rename.Module.#ghcThe "full signature" of the # returns, in order:1) The result of S2) The result of #3) The non-dependent GADT equalities. Dependent GADT equalities are implied by coercion variables in return value (2).4) The other constraints of the data constructor type, excluding GADT equalities&5) The original argument types to the # (i.e. before any change of the representation of the type) with linearity annotations#6) The original result type of the ##ghcThe "stupid theta" of the # , such as  data Eq a in: data Eq a => T a = ...See Note [The stupid context].#ghcReturns just the instantiated value argument types of a #, (excluding dictionary args)#ghc-The labels for the fields of this particular ##ghc*Source-level arity of the data constructor#ghcs for the type variables of the constructor, in the order the user wrote them#ghcThe type variables of the constructor, in the order the user wrote them#ghcThe existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalities#ghcThe type constructor that we are building via this data constructor#ghcGet the Id of the # worker: a function that is the "actual" constructor and has no top level binding in the program. The type may be different from the obvious one written in the source program. Panics if there is no such  for this ##ghcThe  of the #+, giving it a unique, rooted identificationSghcHaskell Implementation BangBangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.Sghc(Lazy field, or one with an unlifted typeSghc$Strict but not unpacked field True  = we could have unpacked, but opted not to because of -O0. See Note [Detecting useless UNPACK pragmas]Sghc;Strict and unpacked field co :: arg-ty ~ product-ty HsBangSghcHaskell Source BangBangs on data constructor arguments as the user wrote them in the source code.(HsSrcBang _ SrcUnpack SrcLazy) and #(HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like !(HsSrcBang _ NoSrcUnpack SrcLazy)ghcTag, used for ordering #sSghcMake a non-dependent #SghcCompare strictness annotationsSghcBuild a new data constructorSghcThe tag used for ordering #sSghcThe original type constructor used in the definition of this data constructor. In case of a data family instance, that will be the family type constructor.SghcThe representation type of the data constructor, i.e. the sort type that will represent values of this type at runtimeSghc Should the # be presented infix?Sghc b -> T [a] rather than: 3T :: forall a c. forall b. (c~[a]) => a -> b -> T cThe type variables are quantified in the order that the user wrote them. See )Note [DataCon user type variable binders].NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.SghcFinds the instantiated types of the arguments required to construct a # representation NB: these INCLUDE any dictionary args but EXCLUDE the data-declaration context, which is discarded It's all post-flattening etc; this is a representation typeSghcGiven a data constructor dc with n( universally quantified type variables a_{1}, a_{2}, ..., a_{n}&, and given a list of argument types dc_args of length m where m <= n, then: dataConInstUnivs dc dc_args  Will return: ?[dc_arg_{1}, dc_arg_{2}, ..., dc_arg_{m}, a_{m+1}, ..., a_{n}] ;That is, return the list of universal type variables with a_{1}, a_{2}, ..., a_{m} instantiated with  dc_arg_{1},  dc_arg_{2}, ...,  dc_arg_{m}. It is possible for m to be less than n, in which case the remaining n - m elements will simply be universal type variables (with their kinds possibly instantiated). Examples:Given the data constructor D :: forall a b. Foo a b and dc_args  [Int, Bool], then dataConInstUnivs D dc_args will return  [Int, Bool].Given the data constructor D :: forall a b. Foo a b and dc_args [Int], then @dataConInstUnivs D dc_args will return [Int, b].Given the data constructor E :: forall k (a :: k). Bar k a and dc_args [Type], then @dataConInstUnivs D dc_args will return [Type, (a :: Type)].This is primarily used in GHC.Tc.Deriv.* in service of instantiating data constructors' field types. See 2Note [Instantiating field types in stock deriving] for a notable example of this.SghcReturns the argument types of the wrapper, excluding all dictionary arguments and without substituting for any type variablesSghcReturns constraints in the wrapper type, other than those in the dataConEqSpecSghcReturns the arg types of the worker, including *all* non-dependent evidence, after any flattening has been done and without substituting for any type variablesSghc The string package:module.name identifying a constructor, which is attached to its info table and used by the GHCi debugger and the heap profilerSghcVanilla #8s are those that are nice boring Haskell 98 constructorsSghc Is this the # of a newtype?SghcShould this DataCon be allowed in a type even without -XDataKinds? Currently, only Lifted & UnliftedSghcWere the type variables of the data con written in a different order than the regular order (universal tyvars followed by existential tyvars)?This is not a cheap test, so we minimize its use in GHC as much as possible. Currently, its only call site in the GHC codebase is in  mkDataConRep in MkId , and so S is only called at most once during a data constructor's lifetime.SghcExtract the type constructor, type argument, data constructor and it's representation4 argument types from a type if it is a product type.Precisely, we return Just" for any data type that is all of:$Concrete (i.e. constructors visible)Single-constructor... which has no existentialsWhether the type is a data type or a newtype.Sghc"Is the constructor declared infix?ghc#TyConRepName for the promoted TyConghc(Strictness/unpack annotations, from userghcField labels for the constructor, if it is a record, otherwise emptyghc Universals.ghc Existentials.ghc User-written &/s. These must be Inferred/Specified. See Note [TyVarBinders in DataCons]ghcGADT equalities ghc0Theta-type occurring before the arguments proper ghcOriginal argument types ghcOriginal result type ghcSee comments on A ghcRepresentation type constructorghcConstructor tagghc:The "stupid theta", context of the data declaration e.g. data Eq a => T a ...ghc Worker IdghcRepresentationSghcA datacon with no existentials or equality constraints However, it can have a dcTheta (notably it can be a class dictionary, with superclasses)ghcInstantiated at these typesSghcA product type, perhaps##SSSSSSSSSSSSSSSSS#SSSSSS!SS##SSS#SSSSS#S##S#SSSS#SSS#SSS#SS##SSSSSSSSSSS#SSS#SSSSSSSSSSS###SSSSSSSSSSSSSSSSS#SSSSSS!SS##SSS#SSSSS#S##S#SSSS#SSS#SSS#SS##SSSSSSSSSSS#SSS#SSSSSSSSSSS# Safe-Inferred/167 N ghcIs a TyCon a promoted data constructor or just a normal type constructor?SghcAmbiguous Field OccurrenceRepresents an *occurrence* of a field that is potentially ambiguous after the renamer, with the ambiguity resolved by the typechecker. We always store the + that the user originally wrote, and store the selector function after the renamer (for unambiguous occurrences) or the typechecker (for ambiguous occurrences).+See Note [HsRecField and HsRecUpdField] in  GHC.Hs.Pat". See Note [Located RdrNames] in  GHC.Hs.Expr.Sghc!Located Ambiguous Field OccurenceSghcField OccurrenceRepresents an *occurrence* of a field. This may or may not be a binding occurrence (e.g. this type is used in S and RecordPatSynField' which bind their fields, but also in  HsRecField5 for record construction and patterns, which do not).We store both the + the user originally wrote, and after the renamer we use the extension field to store the selector function.SghcLocated Field OccurrenceSghc/Arguments in an expression/type after splittingSghcDescribes the arguments to a data constructor. This is a common representation for several constructor-related concepts, including:The arguments in a Haskell98-style constructor declaration (see HsConDeclH98Details in  GHC.Hs.Decls).)The arguments in constructor patterns in case/function definitions (see HsConPatDetails in  GHC.Hs.Pat).The left-hand side arguments in a pattern synonym binding (see HsPatSynDetails in  GHC.Hs.Binds).One notable exception is the arguments in a GADT constructor, which uses a separate data type entirely (see HsConDeclGADTDetails in  GHC.Hs.Decls). This is because GADT constructors cannot be declared with infix syntax, unlike the concepts above (#18844).SghcConstructor Declaration FieldSghcSee Note [ConDeclField pass]Sghc : Sghc%Located Constructor Declaration FieldSghcHaskell Tuple SortSghcThis is used in the syntax. In constructor declaration. It must keep the arrow representation.Tghc2Denotes the type of arrows in the surface languageTghca -> b or a C bTghca %1 -> b or a %1 C b, or a E bTghca %m -> b or a %m C b (very much including `a %Many -> b`! This is how the programmer wrote it). It is stored as an T9 so as to preserve the syntax as written in the program.TghcHaskell Type LiteralTghc Haskell TypeTghc :  , ,= For details on above see Note [exact print annotations] in GHC.Parser.AnnotationTghc : NoneTghc : NoneTghc : ,Tghc :  '[' ,  ']'Tghc :   '(' or '(#' ,   ')' or '#)'Tghc :  '(#' ,  '#)'@Tghc : NoneTghc :  '(' ,  ')'Tghc  (?x :: ty) : Tghc : NoneTghc  (ty :: kind) :  '(' , , ')'Tghc :  '$(' ,  ')'Tghc : NoneTghc :  '{-# UNPACK' or '{-# NOUNPACK' ,  '#-}'  '!'Tghc :  '{' ,  '}'Tghc :  "'[" ,  ']'Tghc :  "'(" ,  ')'Tghc : NoneTghc : NoneTghcHaskell Type Variable Binder The flag annotates the binder. It is  in places where explicit specificity is allowed (e.g. x :: forall {a} b. ...) or () in other places.Tghc :  , , TghcThese names are used early on to store the names of implicit parameters. They completely disappear after type-checking.Tghc A type signature that obeys the forall&-or-nothing rule. In other words, an T that uses an T to represent its outermost type variable quantification. See #Note [Representing type signatures].Tghc'Located Haskell Signature Wildcard TypeTghcLocated Haskell Wildcard TypeTghcLocated Haskell Signature TypeTghcTypes that can appear in pattern signatures, as well as the signatures for term-level binders in RULES. See ,Note [Pattern signature binders and scoping].This is very similar to  HsSigWcType., but with slightly different semantics: see Note [HsType binders] . See also #Note [The wildcard story for types].TghcAfter renamer: HsPSRnTghcMain payload (the type itself)TghcHaskell Wildcard BindersTghc.Used for type-family instance equations, e.g., 'type instance forall a. F [a] = Tree a The notion of specificity is irrelevant in type family equations, so we use () for the T flag.TghcUsed for signatures, e.g., f :: forall a {b}. blah We use  for the T flag to allow distinguishing between specified and inferred type variables.Tghc6The outermost type variables in a type that obeys the forall-or-nothing rule. See Note [forall-or-nothing rule].TghcImplicit forall, e.g., f :: a -> b -> bTghcExplicit forall, e.g., f :: forall a b. a -> b -> bTghc)Located Haskell Quantified Type VariablesTghc$Located Haskell Type Variable BinderTghc The type variable binders in an T . See also 1Note [Variable Specificity and Forall Visibility] in GHC.Tc.Gen.HsType.Tghc A visible forall (e.g., forall a -> {...}). These do not have any notion of specificity, so we use () as a placeholder value.Tghc An invisible forall (e.g., forall a {b} c. {...}), where each binder has a .TghcLocated Haskell KindTghc Haskell KindTghcLocated Haskell TypeTghcHaskell ContextTghcLocated Haskell ContextTghc Bang TypeIn the parser, strictness and packedness annotations bind more tightly than docstrings. This means that when consuming a T (and looking for T8) we must be ready to peer behind a potential layer of T . See #15206 for motivation and  getBangType for an example.TghcLocated Bang TypeTghc Does this T' come with an explicit kind annotation?TghcAn empty list that can be used to indicate that there are no type arguments allowed in cases where HsConDetails is applied to Void.Sghc May have  :  when in a listTghc : Tghc May have  :  when in a listTghc :  For details on above see Note [exact print annotations] in GHC.Parser.AnnotationSSTTTTTTSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTSSSTTTTTTTTTTSSSSSTTSS SSSSSSSSSSSSTSSSSSSSSSSSTTTTSSTTTTTTSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTSSSTTTTTTTTTTSSSSSTTSS SSSSSSSSSSSSTSSSSSSSSSSSTTTTw Safe-Inferred/179:; " ghcPattern : TghcHaskell Field Binding : ,For details on above see Note [exact print annotations] in GHC.Parser.AnnotationTghc!Filled in by renamer when punningTghcNote [Punning]TghcHaskell Record Update FieldTghcHaskell Record FieldTghc#Located Haskell Record Update FieldTghcLocated Haskell Record FieldTghcLocated Haskell Record FieldTghcNewtype to be able to have a specific XRec instance for the Int in TTghcHaskell Record FieldsHsRecFields is used only for patterns and expressions (not data type declarations)Tghc#Haskell Constructor Pattern DetailsTghc9Type argument in a data constructor pattern, e.g. the @a in f (Just @a x) = ....UghcWildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> TypeUghcVariable PatternUghcLazy Pattern ^ -  : UghcAs pattern ^ -  : UghcBang pattern ^ -  : UghcSyntactic List :  '['&,  ']'UghcTuple sub-patterns :  '(' or '(#',  ')' or '#)'UghcAnonymous sum pattern :  '(#',  '#)'UghcConstructor PatternUghc : Ughc :  '$('  ')'UghcLiteral Pattern Used for *non-overloaded* literal patterns: Int#, Char#, Int, Char, String, etc.UghcNatural Pattern :  +Ughc n+k patternUghc : UghcParenthesised patternghc :  '('&,  ')'Ughc View PatternUghc&Splice Pattern (Includes quasi-quotes)UghcPattern with a type signature0 UUUUUUUUUUUUUUUUUUUU UTUTUTTTTTTTTTTTTTTTTTTUUU0 UUUUUUUUUUUUUUUUUUUU UTUTUTTTTTTTTTTTTTTTTTTUUU Safe-Inferred(/ :1Ughc!Haskell Pattern Synonym DirectionUghcRecord Pattern Synonym FieldUghc'Field label visible in rest of the fileUghc=Filled in by renamer, the name used internally by the patternUghcHaskell Pattern Synonym DetailsUghcFixity SignatureUghcLocated Fixity SignatureUghcSignatures and pragmasUghcAn ordinary type signature f :: Num a => a -> aAfter renaming, this list of Names contains the named wildcards brought into scope by this signature. For a signature _ -> _a -> Bool., the renamer will leave the unnamed wildcard _$ untouched, and the named wildcard _a is then replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific. :  , Ughc A pattern synonym type signature ,pattern Single :: () => (Show a) => a -> [a] :  , , ,UghcA signature for a class method False: ordinary class-method signature True: generic-default class method signature e.g. class C a where op :: a -> a -- Ordinary default op :: Eq a => a -> a -- Generic default No wildcards allowed here :  , UghcAn ordinary fixity declaration  infixl 8 *** :  , UghcAn inline pragma {#- INLINE f #-} :   '{-# INLINE' and '[' , , , , , UghcA specialisation pragma "{-# SPECIALISE f :: Int -> Int #-} : ,  '{-# SPECIALISE' and '[', , ,  ']' and '#-}', Ughc6A specialisation pragma for instance declarations only ${-# SPECIALISE instance Eq [Int] #-}(Class tys); should be a specialisation of the current instance declaration : , ,Ughc$A minimal complete definition pragma ${-# MINIMAL a | (b, c | (d | e)) #-} : , ,, Ughc+A "set cost centre" pragma for declarations {-# SCC funName #-}or &{-# SCC funName "cost_centre_name" #-}UghcA complete match pragma {-# COMPLETE C, D [:: T] #-}Used to inform the pattern match checker about additional complete matchings which, for example, arise from pattern synonym definitions.UghcLocated SignatureUghcImplicit parameter bindings. : Ughc"Located Implicit Parameter Binding May have  :  when in a listUghc#Haskell Implicit Parameter BindingsUghc : , ,, , '{',  '}',Pattern Synonym bindingUghcName of the pattern synonymUghcFormal parameter namesUghcRight-hand sideUghcDirectionalityUghc1Haskell Binding with separate Left and Right id'sUghcFunction-like Binding'FunBind is used for both functions f x = e) and variables  f = x -> e) and strict variables  !x = x + 1/Reason 1: Special case for type inference: see .Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds'But note that the form f :: a->a = ... parses as a pattern binding, just like (f :: a -> a) = ... 6Strict bindings have their strictness recorded in the  SrcStrictness of their  MatchContext. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.s), attached to each element of fun_matches,, ,,UghcPattern BindingThe pattern is never a simple variable; That case is done by FunBind. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.UghcVariable BindingDictionary binding and suchlike. All VarBinds are introduced by the type checkerUghcPatterns Synonym BindingUghc The payloadUghcLocated only for consistencyUghcLocated Haskell Binding with separate Left and Right identifier typesUghcLocated Haskell Bindings with separate Left and Right identifier typesUghcHaskell BindingUghcLocated Haskell BindingsUghcLocated Haskell BindingUghcHaskell Value bindings with separate Left and Right identifier types (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindingsUghcValue Bindings InBefore renaming RHS; idR is always RdrName Not dependency analysed Recursive by defaultUghcValue Bindings OutAfter renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones.UghcHaskell Value BindingsUghcHaskell Local Bindings with separate Left and Right identifier typesBindings in a 'let' expression or a 'where' clauseUghcHaskell Value BindingsUghc#Haskell Implicit Parameter BindingsUghcEmpty Local BindingsUghcLocated Haskell local bindingsUghcHaskell Local BindingsUghc :  , , ,   '{', '}'UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU Safe-Inferred(/1679:; lUghcRole Annotation DeclarationUghc :  , Ughc#Located Role Annotation DeclarationUghcAnnotation ProvenanceUghcAnnotation DeclarationUghc :  ,   UghcLocated Annotation DeclarationUghcWarning pragma DeclarationVghc"Located Warning pragma DeclarationVghcWarning pragma DeclarationsVghcLocated Warning DeclarationsVghc!Documentation comment DeclarationVghc)Located Documentation comment DeclarationVghc Rule BinderVghc : , ,VghcLocated Rule BinderVghcRule DeclarationVghc-After renamer, free-vars from the LHS and RHSVghcNote [Pragma source text] in GHC.Types.BasicVghcForall'd type varsVghcForall'd term vars, before typechecking; after typechecking this includes all forall'd varsVghc : , ,  ,  , , , ,VghcLocated Rule DeclarationVghcRule DeclarationsVghcLocated Rule DeclarationsVghcForeign DeclarationVghc :  , , , VghcLocated Foreign DeclarationVghcDefault DeclarationVghcs :  , ,VghcLocated Default DeclarationVghcWhich technique the user explicitly requested when deriving an instance.VghcGHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., %, 1, * when -XDeriveFunctor is enabled, etc.)Vghc -XDeriveAnyClassVghc -XGeneralizedNewtypeDerivingVghc  -XDerivingViaVghcA Located V.Vghc+Stand-alone 'deriving instance' declarationVghcThe instance type to derive. It uses an T9 because the context is allowed to be a single wildcard: !deriving instance _ => Eq (Foo a)4Which signifies that the context should be inferred.Vghc :  , ,  , ,  , ,Vghc3Located stand-alone 'deriving instance' declarationVghcInstance DeclarationVghcLocated Instance DeclarationVghcClass Instance Declaration -  :  ,  , ,, For details on above see Note [exact print annotations] in GHC.Parser.AnnotationVghc : &, ,Vghc"Located Class Instance DeclarationVghcFamily EquationOne equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]VghcOptional quantified type varsVghcFixity used in the declarationVghc : Vghc Data Family Instance DeclarationVghc :  , , ,  , , Vghc(Located Data Family Instance DeclarationVghc Type Family Instance DeclarationVghc :  , ,Vghc(Located Type Family Instance DeclarationVghc)Located type family default declarations.Vghc MkT a b MkT :: forall b a. Eq a => MkT a b data T b where MkT1 :: Int -> T Int data T = Int MkT, Int | MkT2 data T a where Int MkT Int :: T Int s : , ,, ,, ,, ,data Constructor DeclarationWghcThe outermost type variable binders, be they explicit or implicit. The   is used to anchor exact print annotations, AnnForall and AnnDot.WghcUser-written context (if any)WghcArguments; never infixWghc Result typeWghcA possible Haddock comment.WghcTrue  = explicit user-written forall e.g. data T a = forall b. MkT b (b->a) con_ex_tvs = {b} False => con_ex_tvs is emptyWghcExistentials onlyWghcArguments; can be infixWghc$Located data Constructor DeclarationWghc#Whether a data-type declaration is data or newtype, and its constructors.Wghc5When we only care whether a data-type declaration is `data` or  `newtype`", but not what constructors it hasWghc newtype Blah ...Wghc  data Blah ...Wghc!Located Standalone Kind SignatureWghc The types mentioned in a single deriving& clause. This can come in two forms, W or W, depending on whether the types are surrounded by enclosing parentheses or not. These parentheses are semantically different than T. For example,  deriving () means "derive zero classes" rather than "derive an instance of the 0-tuple".W use T because deriving clauses can mention type variables that aren't bound by the datatype, e.g. data T b = ... deriving (C [a])&should produce a derived instance for  C [a] (T b).WghcA deriving clause with a single type. Moreover, that type can only be a type constructor without any arguments. Example:  deriving EqWghcA deriving clause with a comma-separated list of types, surrounded by enclosing parentheses. Example: deriving (Eq, C a)Wghc A single deriving clause of a data declaration. : ,  , ,  , ,Wghc;The user-specified strategy (if any) to use when deriving W.WghcThe types to derive.WghcHaskell Deriving clauseWghcHaskell Data type DefinitionWghc:Declares a data type or newtype, giving its constructors  data/newtype T a =  constrs! data/newtype instance T [a] =  constrs WghcContextWghcOptional kind signature.(Just k) for a GADT-style data, or  data instance decl, with explicit kind sigAlways Nothing for H98-syntax declsWghcData constructorsFor data T a = T1 | T2 a the W s all have W. For data T a where { T1 :: T a } the  LConDecls all have W.Wghc Optional  'deriving' clauseWghcJ if we're in an hs-boot file and the user said "type family Foo x where .."WghcIf the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:.type family Foo a b c = r | r -> a c where ...,This will be represented as "InjectivityAnn r [a, c]"Wghc : , WghcLocated Injectivity AnnotationWghctype Family DeclarationWghc : , , , , , , , , , WghcLocated type Family DeclarationWghctype Family Result SignatureWghc :Wghc : ,, Wghc : ,, , Wghc$Located type Family Result SignatureWghcType or Class GroupWghcA type or class declaration.Wghc type/data family T :: *->* : , , ,, ,, ,, ,, Wghctype declaration : , ,Wghcdata declaration : , , , , ,Wghc :  , , , The tcdFDs will have ,   For details on above see Note [exact print annotations] in GHC.Parser.AnnotationWghcPost renamer, FVsWghcType constructorWghcType variables; for an associated type these include outer bindersWghcFixity used in the declarationWghcRHS of type declarationWghcPost renamer, CUSK flag, FVsWghcPost renamer, FVsWghc7Explicit or virtual braces See Note [Class LayoutInfo]Wghc Context...WghcFunctional depsWghcMethods' signaturesWghcDefault methodsWghcAssociated types;WghcAssociated type defaultsWghc Haddock docsWghc&Located Declaration of a Type or ClassWghcA splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.Wghc$spliceWghc bare spliceWghcSplice DeclarationWghcLocated Splice DeclarationWghc Haskell GroupA X is categorised into a W" before being fed to the renamer.XghcA Haskell DeclarationXghcType or Class DeclarationXghcInstance declarationXghcDeriving declarationXghcValue declarationXghcSignature declarationXghcStandalone kind signatureXghc 'default' declarationXghcForeign declarationXghcWarning declarationXghcAnnotation declarationXghcRule declarationXghc+Splice declaration (Includes quasi-quotes)Xghc"Documentation comment declarationXghcRole annotation declarationXghcTrue  = argument is a data/newtype declaration.Xghc!type or type instance declarationXghc type classXghctype/data family declarationXghctype family declarationXghcopen type family infoXghcclosed type family infoXghcdata family declarationXghcAre the constructors within a  type data declaration? See Note [Type data declarations] in GHC.Rename.Module.Vghc May have  :  when in a listWghc May have  : # when in a GADT constructor listWghc The optional deriving clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the -XDerivingStrategies language extension. The list of Ws corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.XghcWhen in a list this may have : XXXXXXXXXXXXXXXXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXWWWWWWWWWWWWVVVVVVVVVVVVWWWWVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVVVVWWWWWWWVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWVVVVVVVVVVXUVVVVVVVVVUUUUUUUUXUUUUWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXWWWWWWWWWWWWVVVVVVVVVVVVWWWWVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVVVVWWWWWWWVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWVVVVVVVVVVXUVVVVVVVVVUUUUUUUUXUUUUWWWWWWWWWWWWWWWWWWWXXXXXXXx Safe-Inferred /17 d ghcLocated Haskell Expression ghcSyntax ExpressionSyntaxExpr is represents the function used in interpreting rebindable syntax. In the parser, we have no information to supply; in the renamer, we have the name of the function (but see Note [Monad fail : Rebindable syntax, overloaded strings] for a wrinkle) and in the type-checker we have a more elaborate structure  SyntaxExprTc.In some contexts, rebindable syntax is not implemented, and so we have constructors to represent that possibility in both the renamer and typechecker instantiations.E.g. (>>=)4 is filled in before the renamer by the appropriate Name for (>>=), and then instantiated by the type checker with its type args etc ghcGuarded Right-Hand Sides8GRHSs are used both for pattern bindings and for Matches :  , , , , , ghcHaskell Splice ghcA Haskell expression.Xghc  ModuleName. do { ... }Xghc  ModuleName.'mdo { ... } ie recursive do-expressionXghc&A command-line Stmt in GHCi pat <- rhsXghcHaskell arrow match context.XghcA proc expressionXghc(A case alternative inside arrow notationXghc1A case or cases alternative inside arrow notationXghcAn arrow kappa abstractionXghcHaskell Statement Context.Xghc1Context for HsDo (do-notation and comprehensions)Xghc!Pattern guard for specified thingXghcA branch of a parallel stmtXghcA branch of a transform stmtXghc'do-notation in an arrow-command contextXghcHaskell Match ContextContext of a pattern match. This is more subtle than it would seem. See Note [FunBind vs PatBind].Xghc8A pattern matching on an argument of a function bindingXghcPatterns of a lambdaXghc)Patterns and guards in a case alternativeXghcPatterns and guards in case and casesXghc$Guards of a multi-way if alternativeXghc%A pattern match inside arrow notationXghc"A pattern binding eg [y] <- e = eXghcGuards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'XghcRecord update [used only in GHC.HsToCore.Expr to tell matchWrapper what sort of runtime error message to generate]Xghc=Pattern of a do-stmt, list comprehension, pattern guard, etcXghc!A Template Haskell pattern spliceXghc1A Template Haskell pattern quotation [p| (a,b) |]XghcA pattern synonym declarationXghcfunction binder of f See Note [mc_fun field of FunRhs] See #20415 for a long discussion about this field and why it uses NoGhcTc.Xghc fixing of fXghcwas f' banged? See Note [FunBind vs PatBind]XghcArithmetic Sequence InformationXghc1Haskell (Untyped) Quote = Expr + Pat + Type + VarXghcApplicative ArgumentXghc!The fail operator, after renamingThe fail operator is needed if this is a BindStmt where the pattern can fail. E.g.: (Just a) <- stmt The fail operator will be invoked if the pattern match fails. It is also used for guards in MonadComprehensions. The fail operator is Nothing if the pattern match can't failXghcTrue  = was a BodyStmt, False  =1 was a BindStmt. See Note [Applicative BodyStmt]Xghc,context of the do expression, used in pprArgXghcThe fail operatorThis is used for `.. <-` "bind statements" in do notation, including non-monadic "binds" in applicative.The fail operator is 'Just expr' if it potentially fail monadically. if the pattern match cannot fail, or shouldn't fail monadically (regular incomplete pattern exception), it is J.See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of expression in the K case, and why it is so.See Note [Failing pattern matches in Stmts] for which contexts for 'BindStmt3's should use the monadic fail and which shouldn't.XghcParenthesised Statement BlockXghc>Exact print annotations when in qualifier lists or guards -  :  , , , , , ,XghcX2 represents an applicative expression built with <$> and <*>. It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages..For full details, see Note [ApplicativeDo] in GHC.Rename.ExprYghc :   '{', '}',Yghc : YghcGhci StatementYghcGhci Located StatementYghcGuard StatementYghcGuard Located StatementYghcExpression StatementYghcExpression Located StatementYghcCommand StatementYghcCommand Located StatementYghcdo block StatementYghc3Located Statement with separate Left and Right id'sYghcLocated do block StatementYghcGuarded Right Hand Side.YghcLocated Guarded Right-Hand SideYghc Guarded RHSsYghcThe where clauseYghc Located Match May have  :  when in a listYghcHaskell Record BindingsYghcHaskell Top-level CommandYghcTop-level command, introducing a new arrow. This may occur inside a proc (where the stack is empty) or as an argument of a command-forming operator.!Located Haskell Top-level CommandYghcHaskell arrow application type.YghcFirst order arrow application ->=) operator. Post typechecking, also has multiplicity of the argument and the result type of the function passed to bind; that is, (P, S) in (>>=) :: Q -> (R % P -> S) -> T See Note [The type of bind in Stmts]Yghc.Parenthesised expr; see Note [Parens in HsSyn] YYYYY YYYY XXX ZZZZZZZZZZZYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZYYYXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYXYXYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZ ZZZZZZZZZZZYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY YYYYYYYYYYYYZ YYYYYYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYXYXYXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZXXXXXXXXXXXXXXXXXZZZZZZZ Safe-Inferred / ZghcHaskell ModuleAll we actually declare here is the top-level structure for a module.Zghcs,,,  for explicit braces and semi around hsmodImports,hsmodDecls if this style is used.ZghcHsModule extension pointZghcNothing: "module X where" is omitted (in which case the next field is Nothing too)Zghc Export listNothing+: export list omitted, so export everythingJust [] : export nothing Just [...]: as you would expect...s : % ,Zghc1Type, class, value, and interface signature decls UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUWWWVVVVWWWVVVVVWWWWWVVVVVVVVVVXXXXXXXXXXXXXXXXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWVVVVVVVVVVVVWWWWVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWVVVVVVVVVVUVVVVVVVVVUUUUUUUUUUUUWWWWWWWWWWWXXXXXXWWWXXXXXXXXXXXXXXXXXXXYYYYYYYY YYYZYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZYYY YYYY YYYYY XXX YYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXXXXXXYYYXXYXYXYYYYYYYYYYYYYYYYYYYYYYYZZZYYYYYZZZZYYYYYXXXXXXYYXXXXXYYYYYYYYYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZ 000000000000/////000000000000000000//00GGGGGHHHHHHHHHHGGGGGGGGGH UUUUUUUUUUUUUUUUUUUU UTTUTTTTTTTTTTTTTTTTTTUUUUTSSSSTTTTSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTSSSTTTTTTTTTSSSSSTSSSSSSSSSSSSSSSSSSSSSSS TTTTTTTT   ZZZZZZZZ ZZZZZZZZ Safe-Inferred l[ghcGets rid of the stuff that prevents us from understanding the runtime representation of a type. Including: 1. Casts 2. Newtypes 3. Foralls 4. Synonyms But not type/data families, because we don't have the envs to hand.[ghcGive the demands on the arguments of a Core constructor application (Con dc args) at runtime. Assumes the constructor is not levity polymorphic. For example unboxed tuples won't work.[ghc True if the type has zero width.[ghcGiven the arguments of a sum type constructor application, return the unboxed sum rep type.E.g.+(# Int# | Maybe Int | (# Int#, Float# #) #)We call `ubxSumRepType [ [IntRep], [LiftedRep], [IntRep, FloatRep] ]`, which returns [WordSlot, PtrSlot, WordSlot, FloatSlot]INVARIANT: Result slots are sorted (via Ord SlotTy), except that at the head of the list we have the slot for the tag.ghcReturns the bigger type if one fits into the other. (commutative)Note that lifted and unlifted pointers are *not* in a fits-in relation for the reasons described in Note [Don't merge lifted and unlifted slots] in GHC.Stg.Unarise.[ghc,Discovers the primitive representation of a . Returns a list of @: it's a list because of the possibility of no runtime representation (void) or multiple (unboxed tuple/sum) See also Note [Getting from RuntimeRep to PrimRep][ghc,Discovers the primitive representation of a . Returns a list of @: it's a list because of the possibility of no runtime representation (void) or multiple (unboxed tuple/sum) See also Note [Getting from RuntimeRep to PrimRep] Returns Nothing if rep can't be determined. Eg. levity polymorphic types.[ghcLike [*, but assumes that there is precisely one @ output; an empty list of PrimReps becomes a VoidRep. This assumption holds after unarise, see Note [Post-unarisation invariants]. Before unarise it may or may not hold. See also Note [RuntimeRep and PrimRep] and Note [VoidRep][ghc%Find the runtime representation of a . Defined here to avoid module loops. Returns a list of the register shapes necessary. See also Note [Getting from RuntimeRep to PrimRep][ghcLike [3, but assumed that there is precisely zero or one @ output See also Note [Getting from RuntimeRep to PrimRep] and Note [VoidRep]ghcTake a kind (of shape TYPE rr) and produce the @s of values of types of this kind. See also Note [Getting from RuntimeRep to PrimRep][ghcTake a kind (of shape `TYPE rr` or `CONSTRAINT rr`) and produce the @s of values of types of this kind. See also Note [Getting from RuntimeRep to PrimRep] Returns Nothing if rep can't be determined. Eg. levity polymorphic types.[ghc7Take a type of kind RuntimeRep and extract the list of @ that it encodes. See also Note [Getting from RuntimeRep to PrimRep]. The  [PrimRep]% is the final runtime representation after unarisation.(The result does not contain any VoidRep.[ghc7Take a type of kind RuntimeRep and extract the list of @ that it encodes. See also Note [Getting from RuntimeRep to PrimRep]. The  [PrimRep]% is the final runtime representation after+ unarisation and does not contain VoidRep.Returns Nothing: if rep can't be determined. Eg. levity polymorphic types.[ghc Convert a @ to a  of kind RuntimeRep[ghcConvert a PrimRep back to a Type. Used only in the unariser to give types to fresh Ids. Really, only the type's representation matters. See also Note [RuntimeRep and PrimRep]3[[[[[[[[[@@@@@@@@@@@@@@@@@@[[[[[[[[[[[[[[[[[[[[[[[[3[[[[[[[[[@@@@@@@@@@@@@@@@@@[[[[[[[[[[[[[[[[[[[[[[[[ Safe-Inferred ( jZghcA demand transformer> is a monotone function from an incoming evaluation context (Z) to a Z, describing how the denoted thing (i.e. expression, function) uses its arguments and free variables, and whether it diverges.See Note [Understanding DmdType and DmdSig] and Note [What are demand signatures?].ZghcThe depth of the wrapped Z encodes the arity at which it is safe to unleash. Better construct this through [.. See Note [Understanding DmdType and DmdSig]ZghcCharacterises how an expressionEvaluates its free variables (Z) including divergence infoEvaluates its arguments (Z)Zghc=Demands on free variables. See Note [Demand type Divergence]ZghcDemand on argumentsZghc9Captures the result of an evaluation of an expression, byListing how the free variables of that expression have been evaluted (Z)7Saying whether or not evaluation would surely diverge (Z)See Note [Demand env Equality].ZghcZ characterises whether something surely diverges. Models a subset lattice of the following exhaustive set of divergence results: nnontermination (e.g. loops)ithrows imprecise exceptionpthrows precise exceTtioncconverges (reduces to WHNF).The different lattice elements correspond to different subsets, indicated by juxtaposition of indicators (e.g. nc definitely doesn't throw an exception, and may or may not reduce to WHNF).  Dunno (nipc) | ExnOrDiv (nip) | Diverges (ni) %As you can see, we don't distinguish n and i. See Note [Precise exceptions and strictness analysis] for why p is so special compared to i.Zghc5Definitely throws an imprecise exception or diverges.ZghcDefinitely throws a *precise* exception, an imprecise exception or diverges. Never converges, hence [! See scenario 1 in Note [Precise exceptions and strictness analysis].Zghc7Might diverge, throw any kind of exception or converge.ZghcA sub-demand describes an evaluation context (in the sense of an operational semantics), e.g. how deep the denoted thing is going to be evaluated. See Z for examples.See Note [SubDemand denotes at least one evaluation] for a more detailed description of what a sub-demand means.See Note [Demand notation] for the extensively used short-hand notation. See also Note [Why Boxity in SubDemand and not in Demand?].ZghcPolymorphic demand, the denoted thing is evaluated arbitrarily deep, with the specified cardinality at every level. The  applies only to the outer evaluation context as well as all inner evaluation context. See Note [Boxity in Poly] for why we want it to carry . Expands to  via  and to Z via Z.Poly b n is semantically equivalent to  Prod b [n :* Poly b n, ...] or Call n (Poly Boxed n)@.  and Z do these rewrites.In Note [Demand notation]: L === P(L,L,...) and  L === C(L), B === P(B,B,...) and  B === C(B), !A === !P(A,A,...) and  !A === C(A)(, and so on.We'll only see Z with Z (B), Z (A), Z (L) and sometimes Z (S) through Z, never Z (M) or Z$ (1) (grep the source code). Hence Z, which is closed under lub and plus.,Why doesn't this constructor simply carry a Z instead of its fields? See Note [Call SubDemand vs. evaluation Demand].ghc Call n sd% describes the evaluation context of n function applications (with one argument), where the result of each call is evaluated according to sd. sd describes program traces in which the denoted thing was called at all, see Note [SubDemand denotes at least one evaluation]. That Note also explains why it doesn't make sense for n( to be absent, hence we forbid it with Z3. Absent call demands can still be expressed with Z. Used only for values of function type. Use the smart constructor  whenever possible!Zghc Prod b ds describes the evaluation context of a case scrutinisation on an expression of product type, where the product components are evaluated according to ds. The  b6 says whether or not the box of the product was used.ZghcA demand describes.How many times a variable is evaluated, via a Z inality, and0How deep its value was evaluated in turn, via a Z.(Examples (using Note [Demand notation]): puts demand 1A on its first argument: It evaluates the argument strictly (1), but not any deeper (A). puts demand 1P(1L,A) on its argument: It evaluates the argument pair strictly and the first component strictly, but no nested info beyond that (L*). Its second argument is not used at all. puts demand 1C(1,L)" on its first argument: It calls (C>) the argument function with one argument, exactly once (1=). No info on how the result of that call is evaluated (L).v puts demand MC(M,L) on its second argument: It evaluates the argument function at most once ((M)aybe) and calls it once when it is evaluated. fst p + fst p puts demand SP(SL,A) on p: It's 1P(1L,A)# multiplied by two, so we get S4 (used at least once, possibly multiple times).#This data type is quite similar to Scaled Z, but it's scaled by Z, which is an interval on  Multiplicity, the upper bound of which could be used to infer uniqueness types. Also we treat Z and Z specially, as the concept of a Z doesn't apply when there isn't any evaluation at all. If you don't care, simply use Z.Zghc6A bottoming demand, produced by a diverging function (Z), hence there is no Z% that describes how it was evaluated.Zghc-An absent demand: Evaluated exactly 0 times (Z), hence there is no Z% that describes how it was evaluated.ghc.Don't use this internal data constructor; use Z# instead. Since BotDmd deals with Z and AbsDmd deals with Z*, the cardinality component is CardNonAbsZghc A subtype of Z* for which the upper bound is never 1 (no Z or Z!). The only four inhabitants are Z, Z, Z, Z!. Membership can be tested with . See Z for use sites and explanation.Zghc A subtype of Z* for which the upper bound is never 0 (no Z or Z!). The only four inhabitants are Z, Z, Z, Z!. Membership can be tested with . See  and  for use sites and explanation.ZghcDescribes an interval of evaluation cardinalities. See Note [Evaluation cardinalities] See Note [Bit vector representation for Card]Zghcc :* sd" is a demand that says "evaluated c times, and any trace in which it is evaluated will evaluate at least as deep as sd".Matching on this pattern synonym is a complete match. If the matched demand was Z, it will match as C_00 :* seqSubDmd. If the matched demand was Z, it will match as C_10 :* botSubDmd.. The builder of this pattern synonym simply discards the Z if the Z was absent and returns Z or Z< instead. It will assert that the discarded sub-demand was  and , respectively.Call sites should consider whether they really want to look at the Z" of an absent demand and match on Z and/or Z otherwise. Really, any other Z? would be allowed and might work better, depending on context.ZghcEvery possible cardinality; the top element, {0,1,n}. Pretty-printed as L.ZghcStrict and used (possibly) many times, {1,n}. Pretty-printed as S.Zghc.Used at most once, {0,1}. Pretty-printed as M.Zghc/Strict and used once, {1}. Pretty-printed as 1.Zghc Bottom, {}. Pretty-printed as A.Zghc!Absent, {0}. Pretty-printed as A.ZghcTrue  = lower bound is 1.ZghcTrue  = upper bound is 0.ZghcTrue  = upper bound is 1.ghc Is this a Z?ghc Is this a Z?ZghcIntersect with [0,1].ghc"Intersect with [1,n]. The same as Z Z.ZghcDenotes D on Z.ghcDenotes D on Z.ZghcDenotes q on lower and upper bounds of Z.ZghcDenotes r on lower and upper bounds of Z.ghc3Only meant to be used in the pattern synonym below!ghc(The uniform field demand when viewing a Z as a Z , as in Z.ZghcA smart constructor for Z6, applying rewrite rules along the semantic equality ,Prod b [n :* Poly Boxed n, ...] === Poly b n, simplifying to Z Zs when possible. Examples: Rewrites P(L,L) (e.g., arguments Boxed, [L,L]) to L Rewrites  !P(L!L,L!L) (e.g., arguments Unboxed,  [L!L,L!L]) to !LDoes not rewrite P(1L), P(L!L), !P(L) or P(L,A)Zghc viewProd n sd interprets sd as a Z of arity n , expanding Z demands as necessary.ghcA smart constructor for 6, applying rewrite rules along the semantic equality #Call C_0N (Poly C_0N) === Poly C_0N, simplifying to Z Zs when possible.ghc viewCall sd interprets sd as a  , expanding Z subdemands as necessary.ghcSets  to  for non- sub-demands and recurses into Z.ZghcSets  to  for the Z, recursing into Zs. Don't recurse into lazy arguments; see GHC.Core.Opt.DmdAnal Note [No lazy, Unboxed demands in demand signature]ZghcDenotes D on Z.ZghcDenotes q on Z.Zghc;Used to suppress pretty-printing of an uninformative demandZghc8Contrast with isStrictUsedDmd. See Note [Strict demands]Zghc7Not absent and used strictly. See Note [Strict demands]ZghcIs the value used at most once?ZghcWe try to avoid tracking weak free variable demands in strictness signatures for analysis performance reasons. See Note [Lazy and unleashable free variables] in GHC.Core.Opt.DmdAnal.ZghcFirst argument of 'GHC.Exts.maskAsyncExceptions#': 1C(1,L). Called exactly once.ZghcFirst argument of 'GHC.Exts.atomically#': SC(S,L)-. Called at least once, possibly many times.ZghcFirst argument of catch#: MC(M,L). Evaluates its arg lazily, but then applies it exactly once to one argument.ZghcSecond argument of catch#:  MC(M,C(1,L)). Calls its arg lazily, but then applies it exactly once to an additional argument.ZghcMake a Z evaluated at-most-once.ZghcMake a Z' evaluated at-least-once (e.g. strict).ZghcIf the argument is a used non-newtype dictionary, give it strict demand. Also split the product type & demand and recur in order to similarly strictify the argument's contained used non-newtype superclass dictionaries. We use the demand as our recursive measure to guarantee termination.ZghcMake a Z lazy.Zghc Wraps the Z with a one-shot call demand: d -> C(1,d).ZghcmkCalledOnceDmds n d returns C(1,C1...C(1,d)) where there are n C1's.ZghcPeels one call level from the sub-demand, and also returns how many times we entered the lambda body.[ghc Extract the Z of a Z. PRECONDITION: The SubDemand must be used in a context where the expression denoted by the Demand is under evaluation.[ghc"See Note [Computing one-shot info][ghc"See Note [Computing one-shot info][ghc*saturatedByOneShots n C(M,C(M,...)) = True  = There are at least n nested C(M,..) calls. See Note [Demand on the worker] in GHC.Core.Opt.WorkWrapghc:See Note [Asymmetry of plusDmdType], which concludes that < needs to be symmetric. Strictly speaking, we should have (plusDivergence Dunno Diverges = ExnOrDiv. But that regresses in too many places (every infinite loop, basically) to be worth it and is only relevant in higher-order scenarios (e.g. Divergence of f (throwIO blah)). So  currently is  glbDivergence , really.ghcIn a non-strict scenario, we might not force the Divergence, in which case we might converge, hence Dunno.[ghc True if the Z indicates that evaluation will not return. See Note [Dead ends].[ghc Build a potentially terminating Z< from a finite map that says what has been evaluated so far[ghcZ is a monoid via [ and [; this is its msum[ghc%Compute the least upper bound of two Z*s elicited /by the same incoming demand/![ghcThe demand type of doing nothing (lazy, absent, no Divergence information). Note that it is 'not' the top of the lattice (which would be "may use everything"), so it is (no longer) called topDmdType.ghcThe demand type of an unspecified expression that is guaranteed to throw a (precise or imprecise) exception or diverge.ghcThis makes sure we can use the demand type with n arguments after eta expansion, where n must not be lower than the demand types depth. It appends the argument list with the correct .ghc)A conservative approximation for a given Z in case of an arity decrease. Currently, it's just nopDmdType.[ghcWhen e is evaluated after executing an IO action that may throw a precise exception, we act as if there is an additional control flow path that is taken if e throws a precise exception. The demand type of this control flow path * is lazy and absent (Z9) and boxed in all free variables and arguments * has [ Z> result See Note [Precise exceptions and strictness analysis]#So we can simply take a variant of [,  . Why not [? Because then the result of e can never be [4! That means failure to drop dead-ends, see #18086.[ghcTurns a Z computed for the particular ! into a Z unleashable at that arity. See Note [Understanding DmdType and DmdSig].[ghcTrue if the signature diverges or throws an exception in a saturated call. See Note [Dead ends].[ghcTrue if the signature diverges or throws an imprecise exception in a saturated call. NB: In constrast to [ this returns False for [. See Note [Dead ends] and Note [Precise vs imprecise exceptions].[ghc9True when the signature indicates all arguments are boxed[ghcReturns true if an application to n value args would diverge or throw an exception.If a function having [ is applied to a less number of arguments than its syntactic arity, we cannot say for sure that it is going to diverge. Hence this function conservatively returns False in that case. See Note [Dead ends].ghcTransfers the boxity of the left arg to the demand structure of the right arg. This only makes sense if applied to new and old demands of the same value.[ghc Add extra (Z7) arguments to a strictness signature. In contrast to [, this prepends8 additional argument demands. This is used by FloatOut.[ghcWe are expanding (x y. e) to (x y z. e z) or reducing from the latter to the former (when the Simplifier identifies a new join points, for example). In contrast to [, this appends extra arg demands if necessary. This works by looking at the Z (which was produced under a call demand for the old arity) and trying to transfer as many facts as we can to the call demand of new arity. An arity increase (resulting in a stronger incoming demand) can retain much of the info, while an arity decrease (a weakening of the incoming demand) must fall back to a conservative default.[ghc Extrapolate a demand signature (Z ) into a Z.Given a function's Z and a Z for the evaluation context, return how the function evaluates its free variables and arguments.[ghc A special Z for data constructors that feeds product demands into the constructor arguments.[ghc A special Z for dictionary selectors that feeds the demand on the result into the indicated dictionary component (if saturated). See Note [Demand transformer for a dictionary selector].[ghc1Remove the demand environment from the signature.[ghc#Remove all `C_01 :*` info (but not CM sub-demands) from the demand[ghc#Remove all `C_01 :*` info (but not CM. sub-demands) from the strictness signature[ghcDrop all boxity[ghcSee Note [Demand notation] Current syntax was discussed in #19016.[ghcSee Note [Demand notation][ghcSee Note [Demand notation][ghc)We have to respect Poly rewrites through  and Z.[ghcSee Note [Demand env Equality].[ghcdepending on saturationZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[ZZZZZZZZZZZZZZ[[[[[ZZZZZ[[[[[ZZZZ[[[[[[ZZZZ[[[[[[[[[[[[ZZ[[[[[[[[[[[[[[[[Z[[[ZZZZ[[[[[[[[[[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[ZZZZZZZZZZZZZZ[[[[[ZZZZZ[[[[[ZZZZ[[[[[[ZZZZ[[[[[[[[[[[[ZZ[[[[[[[[[[[[[[[[Z[[[ZZZZ[[[[[[[[[[ Safe-Inferred (  [ghcThe arity of the wrapped [ is the arity at which it is safe to unleash. See Note [Understanding DmdType and DmdSig] in GHC.Types.Demand[ghcThe result of \.[ghcThe abstract domain A_t+ from the original 'CPR for Haskell' paper.[ghcNumber of value arguments the denoted expression eats before returning the [[ghc[) eventually unleashed when applied to [ argumentsghc The number of field Cprs equals S&. If all of them are top, better use %, as ensured by the pattern synonym \.ghcFlatConCpr tag is an efficient encoding for  tag [TopCpr..]5. Purely for compiler perf. Can be constructed with \.\ghc Unpacks a \-shaped [ and returns the field [s wrapped in a [. Otherwise, it returns [ with the appropriate [ to assume for each field. The use of [( allows O(1) space for the common, non-\ case.\ghcTurns a [ computed for the particular ! into a [ unleashable at that arity. See Note [Understanding DmdType and DmdSig] in GHC.Types.Demand\ghcAdd extra value args to CprSig\ghcBNF: cpr ::= '' -- TopCpr | n -- FlatConCpr n | n '(' cpr1 ',' cpr2 ',' ... ')' -- ConCpr n [cpr1,cpr2,...] | 'b' -- BotCpr*Examples: * `f x = f x` has result CPR b" * `1(1,)` is a valid (nested) [! denotation for `(I# 42#, f 42)`.\ghcBNF: cpr_ty ::= cpr -- short form if arty == 0 | '\' arty '.' cpr -- if arty > 0Examples: * `f x y z = f x y z` has denotation `3.b` * `g !x = (x+1, x+2)` has denotation `1.1(1,1)`.\ghcOnly print the CPR result[\\\\\[[[[\\\\\\\[[[\[[[\\\\\\[\\\\\\[[[[\\\\\\\[[[\[[[\\\\\\ Safe-Inferred -_ghcStandardFormInfo tells whether this thunk has one of a small number of standard forms_ghcInformation about an identifier, from the code generator's point of view. Every identifier is bound to a LambdaFormInfo in the environment, which gives the code generator enough info to be able to tail call or return that identifier._ghc9Maps names in the current module to their LambdaFormInfos_ghcCodegen-generated Id infos, to be passed to downstream via interfaces.This stuff is for optimization purposes only, they're not compulsory.When CafInfo of an imported Id is not known it's safe to treat it as CAFFY.When LambdaFormInfo of an imported Id is not known it's safe to treat it as `LFUnknown True` (which just says "it could be anything" and we do slow entry).See also Note [Conveying CAF-info and LFInfo between modules] above._ghcExported Non-CAFFY closures in the current module. Everything else is either not exported of CAFFY._ghc;LambdaFormInfos of exported closures in the current module._ghc,The C stub which is used for IPE information______________________________________ Safe-Inferred ^ghcA constructor-like thing^ghcIs this a 'vanilla' constructor-like thing (no existentials, no provided constraints)?^ghcNumber of arguments^ghc"Names of fields used for selectors^ghcReturns just the instantiated value argument types of a ^, (excluding dictionary args)^ghc& s for the type variables of the ^. For pattern synonyms, this will always consist of the universally quantified variables followed by the existentially quantified type variables. For data constructors, the situation is slightly more complicated@see )Note [DataCon user type variable binders] in GHC.Core.DataCon.^ghc0Existentially quantified type/coercion variables^ghcThe "stupid theta" of the ^ , such as  data Eq a in: data Eq a => T a = ...It is empty for ^* as they do not allow such contexts. See Note [The stupid context] in GHC.Core.DataCon.^ghc^ returns True except for uni-directional pattern synonyms, which have no builder^ghc7Returns the strictness information for each constructor^ghc%Returns the type of the whole pattern^ghcThe "full signature" of the ^ returns, in order:,1) The universally quantified type variables72) The existentially quantified type/coercion variables3) The equality specification;4) The provided theta (the constraints provided by a match)<5) The required theta (the constraints required for a match)6) The original argument types (i.e. before any change of the representation of the type)7) The original result type^ghc5Extract the type for any given labelled field of the ^^ghc-The ConLikes that have *all* the given fields^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Safe-Inferred ^ghcA list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures. See also Note [Implementation of COMPLETE pragmas].^ghc The set of ^ values^ghc6The optional, concrete result TyCon the set applies to^^^^^^^^^^^^^^5 Safe-Inferred '7 Z%ghcExpressions where binders are sghcThe common case for the type of binders and variables when we are manipulating the Core language within GHCghcThis is the data type that represents GHCs core intermediate language. Currently GHC uses System FC  https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions/ for this purpose, which is closely related to the simpler and better known System F  %http://en.wikipedia.org/wiki/System_F.We get from Haskell source to this Core language in a number of stages: The source code is parsed into an abstract syntax tree, which is represented by the data type  with the names being This syntax tree is renamed, which attaches a 1 to every  (yielding a ) to disambiguate identifiers which are lexically identical. For example, this program: 3 f x = let f x = x + 1 in f (x - 2) Would be renamed by having Unique,s attached so it looked something like this:  f_1 x_2 = let f_3 x_4 = x_4 + 1 in f_3 (x_2 - 2) But see Note [Shadowing] below. The resulting syntax tree undergoes type checking (which also deals with instantiating type class arguments) to yield a  type that has 6 as it's names.Finally the syntax tree is  desugared from the expressive  type into this  type, which has far fewer constructors and hence is easier to perform optimization, analysis and code generation on.The type parameter b3 is for the type of binders in the expression tree.0The language consists of the following elements:5Variables See Note [Variable occurrences in Core]Primitive literals.Applications: note that the argument may be a 7. See Note [Representation polymorphism invariants]Lambda abstraction See Note [Representation polymorphism invariants]Recursive and non recursive lets. Operationally this corresponds to allocating a thunk for the things bound and then executing the sub-expression.See Note [Core letrec invariant] See Note [Core let-can-float invariant] See Note [Representation polymorphism invariants] See Note [Core type and coercion invariant]Case expression. Operationally this corresponds to evaluating the scrutinee (expression examined) to weak head normal form and then examining at most one level of resulting constructor (i.e. you cannot do nested pattern matching directly with this).The binder gets bound to the value of the scrutinee, and the * must be that of all the case alternatives0IMPORTANT: see Note [Case expression invariants]Cast an expression to a particular type. This is used to implement newtypes (a newtype. constructor or destructor just becomes a ] in Core) and GADTs.Ticks. These are used to represent all the source annotation we support: profiling SCCs, HPC ticks, and GHCi breakpoints.;A type: this should only show up at the top level of an Arg A coercion\ghcA clone of the \0 type but allowing annotation at every tree node\ghcA clone of the ]0 type but allowing annotation at every tree node\ghcA clone of the 0 type but allowing annotation at every tree node\ghc;Annotated core: allows annotation at every node in the tree\ghc Binders are tagged with a t\ghc$Case alternatives where binders are s\ghc!Binding groups where binders are s\ghc'Argument expressions where binders are s\ghc\& says when unfolding should take place\ghcProperties of a \ that could be computed on-demand from its template. See Note [UnfoldingCache]\ghc Records the  unfolding of an identifier, which is approximately the form the identifier would have if we substituted its definition in for the identifier. This type should be treated as abstract everywhere except in GHC.Core.Unfold\ghc+We have no information about the unfolding.\ghc:We have no information about the unfolding, because this  came from an hi-boot1 file. See Note [Inlining and hs-boot files] in GHC.CoreToIface for what this is used for.\ghc%It ain't one of these constructors.  OtherCon xs also indicates that something has been evaluated and hence there's no point in re-evaluating it.  OtherCon [] is used even for non-data-type values to indicated evaluated-ness. Notably: 1data C = C !(Int -> Int) case x of { C f -> ... }Here, f gets an  OtherCon [] unfolding.\ghc;An unfolding with redundant cached information. Parameters:uf_tmpl: Template used to perform unfolding; NB: Occurrence info is guaranteed correct: see Note [OccInfo in unfoldings and rules]'uf_is_top: Is this a top level binding? uf_is_value:  exprIsHNF* template (cached); it is ok to discard a  on this variableuf_is_work_free: Does this waste only a little work if we expand it inside an inlining? Basically this is a cached version of exprIsWorkFree!uf_guidance: Tells us about the size of the unfolding template\ghcThe ( in the \ is a superset of variables that are currently in scope. See Note [The InScopeSet invariant].\ghcA \ is:"Local" if the function it is a rule for is defined in the same module as the rule itself."Orphan" if nothing on the LHS is defined in the same module as the rule itself\ghcBuilt-in rules are used for constant folding and suchlike. They have no free variables. A built-in rule is always visible (there is no such thing as an orphan built-in rule.)\ghc1Name of the rule, for communication with the user\ghcWhen the rule is active\ghc Name of the 6 at the head of this rule\ghc7Name at the head of each argument to the left hand side\ghcVariables quantified over\ghcLeft hand side arguments\ghcRight hand side of the rule Occurrence info is guaranteed correct See Note [OccInfo in unfoldings and rules]\ghcTrue  = this rule is auto-generated (notably by Specialise or SpecConstr) False  = generated at the user's behest See Note [Trimming auto-rules] in GHC.Iface.Tidy% for the sole purpose of this field.\ghc  the rule was defined in, used to test if we should see an orphan rule.\ghc%Whether or not the rule is an orphan.\ghcTrue iff the fn at the head of the rule is defined in the same module as the rule and is not an implicit  (like a record selector, class operation, or data constructor). This is different from \, where a rule can avoid being an orphan if *any* Name in LHS of the rule was defined in the same module as the rule.\ghcNumber of arguments that \1 consumes, if it fires, including type arguments\ghcThis function does the rewrite. It given too many arguments, it simply discards them; the returned  is just the rewrite of \ applied to the first \ args\ghcIs this instance an orphan? If it is not an orphan, contains an  ? witnessing the instance's non-orphanhood. See Note [Orphans]\ghcBinding, used for top level bindings in a module and local bindings in a let.]ghc3A case alternative constructor (i.e. pattern match)]ghc A literal: case e of { 1 -> ... } Invariant: always an *unlifted* literal See Note [Literal alternatives]]ghcTrivial alternative: case e of { _ -> ... }]ghcA case split alternative. Consists of the constructor leading to the alternative, the variables bound from the constructor, and the expression to be executed given that binding. The default alternative is (DEFAULT, [], rhs)]ghcType synonym for expressions that occur in function argument positions. Only ] should contain a  at top level, general  should not]ghcReturns true if \ is orphan.]ghcReturns true if \ is not an orphan.]ghcThe number of arguments the \4 must be applied to before the rule can match on it]ghcThe  of the 6' at the head of the rule left hand side]ghcSet the  of the 6' at the head of the rule left hand side]ghcThere is no known \]ghc body) == (x -> f body)]ghcAttempt to remove the last N arguments of a function call. Strip off any ticks or coercions encountered along the way and any at the end.]ghcLike  collectArgs, but also collects looks through floatable ticks if it means that we can find more arguments.]ghc$Will this variable exist at runtime?]ghc/Will this argument expression exist at runtime?]ghcReturns True for value arguments, false for type args NB: coercions are value arguments (zero width, to be sure, like State#, but still value args).]ghcReturns True iff the expression is a  or  expression at its top level]ghcReturns True iff the expression is a  expression at its top level]ghcReturns True iff the expression is a ; expression at its top level. Note this does NOT include s.]ghc8The number of binders that bind values rather than types]ghcThe number of argument expressions that are values rather than types at their top level]ghcTakes a nested application expression and returns the function being applied and the arguments to which it is applied]ghcAs ] but for \ rather than ]ghcAs ] but for \ rather than ]]]]]]]]]]]]\\\]]]]]\\\\\\\\\\]&\\\\\\\&\&&&\\\\\\\&\&&\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]']]]]]]]]]]]]]]]]]]]]]]]]]]]]]\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ ]]]]]]]]]]]]]]]]]]]]]]]]]]]"\\\\\\\\\\\\\\\\\]]]]]]]]\\\]]]\\\\\\\\\\\\\\\\!\\\\:]]]]]]]]]]]]]]]]]]]]]\\\]]]]]\\\\\\\\\\]&\\\\\\\&\&&&\\\\\\\&\&&\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]']]]]]]]]]]]]]]]]]]]]]]]]]]]]]\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ ]]]]]]]]]]]]]]]]]]]]]]]]]]]"\\\\\\\\\\\\\\\\\]]]]]]]]\\\]]]\\\\\\\\\\\\\\\\!\\\\:]]]]]]]]]]4]4]4]4]4, Safe-Inferred {C4ghcIdentifier DetailsThe  of an Id7 give stable, and necessary, information about the Id.ghcIdentifier InformationAn  gives optional information about an Id. If present it never lies, but it may not be present, in which case there is always a conservative assumption which can be made.Two Id:s may have different info even though they have the same Unique (and are hence the same Id); for example, one might lack the properties attached to the other. Most of the ; gives information about the value, or definition, of the Id4, independent of its usage. Exceptions to this are _, _, ` and `.!Performance note: when we update , we have to reallocate this entire record, so it is a good idea not to let this data structure get too big.ghc Check if an  says `.ghcJust a synonym for `. Written separately so it can be exported in the hs-boot file.ghcBasic . that carries no useful information whatsoever_ghcTick box for Hpc-style coverage_ghc%Constant applicative form InformationRecords whether an Id+ makes Constant Applicative Form references_ghcIndicates that the Id is for either: A function or static constructor that refers to one or more CAFs, orA real live CAF_ghc9A function or static constructor that refers to no CAFs._ghcRule Information$Records the specializations of this Id, that we know about in the form of rewrite \s that target them_ghcInline Pragma InformationTells when the inlining is active. When it is active the thing may be inlined, depending on how big it is.If there was an INLINE pragma, then as a separate matter, the RHS will have been made to look small with a Core inline Note The default _ is  , so the info serves entirely as a way to inhibit inlining until we want it_ghcArity InformationAn _ of n, tells us that partial application of this Id to up to n-1* value arguments does essentially no work.7That is not necessarily the same as saying that it has n6 leading lambdas, because coerces may get in the way.The arity might increase later in the compilation process, if an extra lambda floats up to the binding site. Invariant: the ! of an Id must never exceed the number of value arguments that appear in the type of the Id'. See Note [Arity and function types].ghcEncodes arities, OneShotInfo, CafInfo. From least-significant to most-significant bits:Bit 0 (1): OneShotInfoBit 1 (1): CafInfoBit 2 (1): unusedBits 3-32(30): Call Arity infoBits 33-62(30): Arity info_ghcSpecialisations of the Ids function which exist. See Note [Specialisations and RULES in IdInfo]_ghcThe Id s unfolding_ghc"Any inline pragma attached to the Id_ghcHow the Id occurs in the program_ghcA strictness signature. Describes how a function uses its arguments See Note [idArity varies independently of dmdTypeDepth] in GHC.Core.Opt.DmdAnal_ghcInformation on whether the function will ultimately return a freshly allocated constructor._ghcID demand informationghcBitfield packs CafInfo, OneShotInfo, arity info, and call arity info in one 64-bit word. Packing these fields reduces size of  from 12 words to 7 words and reduces residency by almost 4% in some programs. See #17497 and associated MR.See documentation of the getters for what these packed fields mean._ghc=See Note [The LFInfo of Imported Ids] in GHC.StgToCmm.Closure`ghcRecursive Selector Parent`ghcThe Id for a record selector`ghcThe Id is for a data constructor worker`ghcThe Id is for a data constructor wrapper`ghcThe Id9 is a superclass selector, or class operation of a class`ghcThe Id# is for a primitive operator True  = is representation-polymorphic, and hence has no binding This lev-poly flag is used only in GHC.Types.Id.hasNoBinding`ghcThe Id is for a foreign call. Type will be simple: no type families, newtypes, etc`ghcThe Id4 is for a HPC tick box (both traditional and binary)`ghc$A dictionary function. Bool = True  = the class has only one method, so may be implemented with a newtype, so it might be bad to be strict on this dictionary`ghc&A coercion variable This only covers  un-lifted coercions, of type (t1 ~# t2) or (t1 ~R# t2), not their lifted variants`ghcAn Id< for a join point taking n arguments Note [Join points] in GHC.Core+ Can also work as a WorkerLikeId if given !s. See Note [CBV Function Ids] The [CbvMark] is always empty (and ignored) until after Tidy.`ghcAn Id for a worker like function, which might expect some arguments to be passed both evaluated and tagged. Worker like functions are create by W/W and SpecConstr and we can expect that they aren't used unapplied. See Note [CBV Function Ids] See Note [Tag Inference] The [CbvMark] is always empty (and ignored) until after Tidy for ids from the current module.`ghc+Info about a lambda-bound variable, if the Id is one`ghcId arity, as computed by GHC.Core.Opt.Arity%. Specifies how many arguments this Id9 has to be applied to before it does any meaningful work.`ghcId CAF info`ghcHow this is called. This is the number of arguments to which a binding can be eta-expanded without losing any sharing. n  =% all calls have at least n arguments`ghcEssentially returns the _ field, but does not expose the unfolding of a strong loop breaker.This is the right thing to call if you plan to decide whether an unfolding will inline.`ghc True of a non-loop-breaker Id that has a stable; unfolding that is (a) always inlined; that is, with an \ guidance, or (b) a DFunUnfolding which never needs to be inlined`ghcMore informative  we can use when we know the Id has no CAF references`ghc$It is always safe to assume that an Id has an arity of 0`ghc1Assume that no specializations exist: always safe`ghcRetrieve the locally-defined free variables of both the left and right hand sides of the specialization rules`ghcChange the name of the function the rule is keyed on all of the \sghcAssumes that the Id$ has CAF references: definitely safe`ghcThis is used to remove information on lambda binders that we have setup as part of a lambda group, assuming they will be applied all at once, but turn out to be part of an unsaturated lambda as in e.g: (\x1. \x2. e) arg1`ghcRemove all demand info on the `ghc.Remove usage (but not strictness) info on the `ghcRemove usage environment info from the strictness signature on the `ghc'Zap info that depends on free variablesghcZaps any core unfolding, but  preserves/ evaluated-ness, i.e. an unfolding of OtherCon``````````````!````_________`!!!`!!``````````_`````````````_` !!!` !!__```````___````_``___``````````````!`````!!!`!!``````````_``````_`_`_``_```__` !!!_` !!__`````_``___````__``____ `1`1`1`1`1`1`1`1`1`16 Safe-Inferred 3#`ghcLike `, but skips non-Ids. Useful for scaling a mixed list of ids and tyvars.`ghcNot only does this set the  ;, it also evaluates the type to try and reduce space usage`ghc'For an explanation of global vs. local s, see GHC.Types.Var.Var#globalvslocal`ghcMake a global % without any extra information at all`ghcMake a global - with no global information but some generic `ghc'For an explanation of global vs. local s, see GHC.Types.Var#globalvslocal`ghcMake a local CoVar`ghcLike `6, but checks the type to see if it should make a covar`ghcCreate a local  that is marked as exported. This prevents things attached to it from being removed as dead code. See Note [Exported LocalIds]`ghcCreate a system local . These are local s (see Var#globalvslocal3) that are created by the compiler out of thin air`ghcLike `+, but checks to see if we have a covar type`ghcCreate a user local . These are local s (see GHC.Types.Var#globalvslocal8) with a name and location that the user might recognize`ghcLike `', but checks if we have a coercion type`ghcWorkers get local names. CoreTidy$ will externalise these if necessary`ghc Create a template local: a family of system local s in bijection with Ints, typically used in unfoldings`ghc-Create a template local for a series of types`ghcCreate a template local for a series of type, but start from a specified template local`ghcIf the , is that for a record selector, extract the `. Panic otherwise.`ghcAn Id for which we might require all callers to pass strict arguments properly tagged + evaluated.See Note [CBV Function Ids]`ghcDoesn't return strictness marks`ghc*Get from either the worker or the wrapper  to the #'. Currently used only in the desugarer. INVARIANT: idDataCon (dataConWrapId d) = d : remember, #, can return either the wrapper or the worker`ghcReturns True of an  which may not have a binding, even though it is defined in this module.`ghc` tells whether an s info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.aghcThis function counts all arguments post-unarisation, which includes arguments with no runtime representation -- see Note [Unarisation and arity]aghcReturns true if an application to n args diverges or throws an exception See Note [Dead ends] in GHC.Types.Demand.aghc Accesses the Id's _.aghca says whether either (a) the  has a strict demand placed on it or (b) definitely has a "strict type", such that it can always be evaluated strictly (i.e an unlifted type) We need to check (b) as well as (a), because when the demand for the given i hasn't been computed yet but i9 has a strict type, we still want `isStrictId id` to be L. Returns False if the type is levity polymorphic; False is always safe.aghc Returns the s unfolding, but does not expose the unfolding of a strong loop breaker. See `.?If you really want the unfolding of a strong loopbreaker, call a.aghcReturns an unfolding only if (a) not a strong loop breaker and (b) always activeaghcReturns an unfolding only if (a) not a strong loop breaker and (b) active in according to is_activeaghcExpose the unfolding if there is one, including for loop breakersaghc5If all marks are NotMarkedStrict we just set nothing.aghc2Remove any cbv marks on arguments from a given Id.aghc-Turn this id into a WorkerLikeId if possible.aghc:Similar to trimUnfolding, but also removes evaldness info.'&&&&````````````````````````''`````''''``'`````aaaaaaaaaa````a'''`````````````````a`a``&```aaaaaaaaaaaaaaaaaaaaaaa\aaaaaaaaaaaaaaaaaaaaaaaaaaaa'&&&&````````````````````````''`````''''``'`````aaaaaaaaaa````a'''`````````````````a`a``&```aaaaaaaaaaaaaaaaaaaaaaa\aaaaaaaaaaaaaaaaaaaaaaaaaaaaa1a1a1a1a1a1a1a1a1a1a1a1a1a1a18 Safe-Inferred ghcA global typecheckable-thing, essentially anything that has a name. Not to be confused with a  TcTyThing, which is also a typecheckable thing but in the *local* context. See GHC.Tc.Utils.Env for how to retrieve a  given a .aghcClass that abstracts out the common ability of the monads in GHC to lookup a  in the monadic environment by . Provides a number of related convenience functions for accessing particular kinds of aghcDetermine the  s brought into scope by another  other than itself. For example, Id's don't have any implicit TyThings as they just bring themselves into scope, but classes bring their dictionary datatype, type constructor and some selector functions into scope, just for a start!aghcReturns True if there should be no interface-file declaration for this thing on its own: either it is built-in, or it is part of some other declaration, or it is generated implicitly by some other declaration.aghctyThingParent_maybe x returns (Just p) when pprTyThingInContext should print a declaration for p (albeit with some "..." in it) when asked to show x It returns the *immediate* parent. So a datacon returns its tycon but the tycon could be the associated type of a class, so it in turn might have a parent.aghcThe Names that a TyThing should bring into scope. Used to build the GlobalRdrEnv for the InteractiveContext.aghcGet the  from a 4 if it is a type constructor thing. Panics otherwiseaghcGet the ? from a 2 if it is a coercion axiom thing. Panics otherwiseaghcGet the # from a 4 if it is a data constructor thing. Panics otherwiseaghcGet the ^ from a 5 if it is a data constructor thing. Panics otherwiseaghcGet the  from a < if it is a id *or* data constructor thing. Panics otherwiseaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Safe-Inferred P ƦghcA renaming substitution from s to s. Like (4, but not maintaining pairs of substitutions. Like , but with the domain being s instead of entire CoreExpr.Ȧghc  emptySubst = ɦ (ɦghcConstructs a new Ʀ% assuming the variables in the given ( are in scope.ʦghcSubstitutes an " for another one according to the Ʀ+ given in a way that avoids shadowing the (', returning the result and an updated Ʀ1 that should be used by subsequent substitutions.˦ghc 4substBndrs = runState . traverse (state . substBndr)̦ghcSubstitutes an occurrence of an identifier for its counterpart recorded in the Ʀ.ͦghcSubstitutes an occurrence of an identifier for its counterpart recorded in the Ʀ. Does not generate a debug warning if the identifier to to substitute wasn't in scope.ΦghcAdd the  to the in-scope set and remove any existing substitutions for it.ϦghcAdd a substitution for an  to the Ʀ: you must ensure that the in-scope set is such that TyCoSubst Note [The substitution invariant] holds after extending the substitution like this. ŦƦǦȦɦʦ˦̦ͦΦϦ ƦǦŦȦɦʦ˦̦ͦΦϦ Safe-Inferred cghcEssentially a GlobalRdrEnv, but with additional cached values to allow efficient re-calculation when the imports change. Fields are strict to avoid space leaks (see T4029) All operations are in GHC.Runtime.Context. See Note [icReaderEnv recalculation]cghcThe final environmentcghc:Just the things defined at the prompt (excluding imports!)cghc stepping modecghcfilename (for errors)cghcline number (for errors))ccccccccccccccccccccccccccccccccccccccccc)ccccccccccccccccccccccccccccccccccccccccc Safe-Inferred cghcA measure of the size of the expressions, strictly greater than 0 Counts *leaves*, not internal nodes. Types and coercions are not counted. ccbcccccccc ccbcccccccc Safe-Inferred lghcEvaluate all the fields of the - that are generally demanded by the compilerllllllllllllll Safe-Inferred  Xghc?A function to produce an annotation for a given right-hand-sideghc-Annotate with the size of the right-hand-sideghc No annotationghc4Pretty print the argument in a function application.ghc3generate an annotation to place before the bindingghcbindings to showghcthe pretty resultcccccccccccccccccccccccccccccccc Safe-Inferred%/ ~ghc~ p ol returns L if an overloaded literal ol, needs to be parenthesized under precedence p.~ghc~ p l returns L if a literal l- needs to be parenthesized under precedence p.See Note [Printing of literals in Core] in GHC.Types.Literal for the reasoning.~ghc0Convert a literal from one index type to another~ghcpmPprHsLit pretty prints literals and is used when pretty printing pattern match warnings. All are printed the same (i.e., without hashes if they are primitive and not wrapped in constructors if they are boxed). This happens mainly for too reasons: * We do not want to expose their internal representation * The warnings become too messy(GGGGGHHHHHHHHHHGGGGGGGGGH~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Safe-Inferred  ghc CoreMapX a is the base map from DeBruijn CoreExpr to a, but without the K optimization.ghc CoreMapG a is a map from DeBruijn CoreExpr to a. The extended key makes it suitable for recursive traversal, since it can track binders, but it is strictly internal to this module. If you are including a ^ inside another K, this is the type you want.^ghc CoreMap a is a map from  to a3. If you are a client, this is the type you want.^^^^^^^KKKKKKKKKRRRRKKK^^^^^^^KKKKKKKKKRRRRKKK{ Safe-Inferred" @#ghc'Type constructor for n-ary unboxed sum.#ghc=Data constructor for i-th alternative of a n-ary unboxed sum.#ghcSpecialization of  for tuples#ghc "type LiftedRep = 'BoxedRep 'Lifted#ghc &type UnliftedRep = 'BoxedRep 'Unlifted#ghcBuild the type of a small tuple that holds the specified type of thing Flattens 1-tuples. See Note [One-tuples].aghcMake a fake, recovery  from an existing one. Used when recovering from errors in type declarationsbghcBuilt-in syntax isn't "in scope" so these OccNames map to wired-in Names with BuiltInSyntax. However, this should only be necessary while resolving names produced by Template Haskell splices since we take care to encode built-in syntax names specially in interface files. See Note [Symbol table representation of names].Moreover, there is no need to include names of things that the user can't write (e.g. type representation bindings like $tc(,,,)).bghcIf the given name is that of a constraint tuple, return its arity.ghcCached type constructors, data constructors, and superclass selectors for constraint tuples. The outer array is indexed by the arity of the constraint tuple and the inner array is indexed by the superclass position.ghcGiven the TupleRep/SumRep tycon and list of RuntimeReps of the unboxed tuple;sum arguments, produces the return kind of an unboxed tuplesum type constructor. unboxedTupleSumKind [IntRep, LiftedRep] --> TYPE (TupleRep/SumRep [IntRep, LiftedRep])ghc/OccName for n-ary unboxed sum type constructor.ghcOccName for i-th alternative of n-ary unboxed sum data constructor.ghcCached type and data constructors for sums. The outer array is indexed by the arity of the sum and the inner array is indexed by the alternative.bghcSpecialization of  for sumsghcCreate type constructor and data constructors for n-ary unboxed sum.ghc@type ZeroBitRep = 'Tuple '[]bghc Given a type ty, if ty is not of kind Type, return a data constructor that will box it, and the type of the boxed thing, which does4 now have kind Type. See Note [Boxing constructors]ghc+See Note [Boxing constructors] wrinkle (W1)bghc,Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are flattened. See Note [One-tuples]bghc,Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are *not* flattened. See Note [One-tuples] and Note [Don't flatten tuples from HsSyn] in  GHC.Core.MakebghcMake a *promoted* list.ghcExtract the elements of a promoted list. Panics if the type is not a promoted listbghc>Replaces constraint tuple names with corresponding boxed ones.ghcdeclared infix?ghc datacon nameghc univ tyvarsghc ex tycovarsghcuser-written tycovarsghcargsbghcof the elements of the listghcelementsghcThe promoted listaaabbbbaabbabbabbbbbbbbbbbbbaaaaaaabba#baabbbabbbabbababbbabbbb$ba5ba7bbabbbbbababbabbbbbb#b#####bbb#bbbbbbbb#bbbb#bbb##bb#aa#ab##b$Bb##DDDDDD####b####bbb#abbbabba#abb##########b###b###############################bbb##bb######b#bbbbbbbb#bbbbbbaaabbbbaabbabbabbbbbbbbbbbbbaaaaaaabba#baabbbabbbabbababbbabbbb$ba5ba7bbabbbbbababbabbbbbb#b#####bbb#bbbbbbbb#bbbb#bbb##bb#aa#ab##b$Bb##DDDDDD####b####bbb#abbbabba#abb##########b###b###############################bbb##bb######b#bbbbbbbb#bbbbbb Safe-Inferred bghcPer-module cache of original  s given sbghcThe NameCache makes sure that there is just one Unique assigned for each original name; i.e. (module-name, occ-name) pair and provides something of a lookup mechanism for those names.bghc-Update the name cache with the given functionbghc-Update the name cache with the given functionAdditionally, it ensures that the given Module and OccName are evaluated. If not, chaos can ensue: we read the name-cache then pull on mod (say) which does some stuff that modifies the name cache This did happen, with tycon_mod in GHC.IfaceToCore.tcIfaceAlt (DataAlt..) bbbbbbbbbbbb bbbbbbbbbbbb Safe-Inferred 9:; nghc Header information only, not rhsnghc,Show only some sub-components. Specifically, []Print all sub-components.(n:ns)Print sub-component n with  ShowSub = ns!; elide other sub-components to ...6 May 14: the list is max 1 element long at the momentnghcEverything including GHC-internal information (used in --show-iface)oghcIface type for LambdaFormInfo. Fields not relevant for imported Ids are omitted in this type.oghcThis corresponds to HsSrcBangoghcThis corresponds to an HsImplBang; that is, the final implementation decision about the data constructor argoghcName of associated axiom and branches for pretty printing purposes, or J for an empty closed family without an axiom See Note [Pretty printing via Iface syntax] in GHC.Types.TyThing.PprpghcA binding top-level , in an interface file (e.g. the name of an p).pghcPretty Print an IfaceExprThe first argument should be a function that adds parens in context that need an atomic value (e.g. function args)&&&&&&&&HH HHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHH HHH HHH HHHHHHHHHHHHHHHHHHHHHHHHHIIHIIHIIIIIIIIIIIIIIIIIIIIIHIIIIIIHHIIIIIIIpppppppppppppppppppppppppppppppppppppppoooooooooooooooooooooooooooooooooooooooooooonnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooonnnooooooooooooooooooooooooooooooooooonnnpppppppppppnnnnnnnnnnpppppppppppppppppppppppppppppppppppppppppoooooooooooooooooooooooooooooooooooooooooooonnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooonnnooooooooooooooooooooooooooooooooooonnnpppppppppppnnnnnnnnnnpp39  Safe-Inferred qghc serialised tidied core bindings.qghc%The module which the bindings are forqghc&The location where the sources reside.qqqqqqqqqq Safe-Inferred(/7 RsghcThe extension field for T2, which is only used in the renamer onwards. See ,Note [Pattern signature binders and scoping].sghcWildcard namessghcImplicitly bound variable namessghcReturn the attached flagsghcSet the attached flagsghcDo all type variables in this T come with kind annotations?sghcConvert an arrow into its corresponding multiplicity. In essence this erases the information of whether the programmer wrote an explicit multiplicity or a shorthand.sghc7Get the kind signature of a type, ignoring parentheses:hsTyKindSig `Maybe ` = Nothing hsTyKindSig `Maybe :: Type -> Type ` = Just `Type -> Type` hsTyKindSig `Maybe :: ((Type -> Type))` = Just `Type -> Type`This is used to extract the result kind of type synonyms with a CUSK:2type S = (F :: res_kind) ^^^^^^^^sghcRetrieve the name of the "head" of a nested type application. This is somewhat like GHC.Tc.Gen.HsType.splitHsAppTys, but a little more thorough. The purpose of this function is to examine instance heads, so it doesn't handle *all* cases (like lists, tuples, (~), etc.).sghc Compute the  associated with an S.sghcs id fixity args! pretty-prints an application of id to args , using the fixity to tell whether id. should be printed prefix or infix. Examples: pprHsArgsApp T Prefix [HsTypeArg Bool, HsValArg Int] = T @Bool Int pprHsArgsApp T Prefix [HsTypeArg Bool, HsArgPar, HsValArg Int] = (T @Bool) Int pprHsArgsApp (++) Infix [HsValArg Char, HsValArg Double] = Char ++ Double pprHsArgsApp (++) Infix [HsValArg Char, HsValArg Double, HsVarArg Ordering] = (Char ++ Double) Ordering ghc.Pretty-print a prefix identifier to a list of Ss.ghcPretty-print an S in isolation.sghcDecompose a pattern synonym type signature into its constituent parts.Note that this function looks through parentheses, so it will work on types such as  (forall a.  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.sghc$Decompose a sigma type (of the form forall  tvs. context => body) into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g.,  forall a., with a dot).This function is used to split apart certain types, such as instance declaration types, which disallow visible forall)s. For instance, if GHC split apart the forall in "instance forall a -> Show (Blah a)6, then that declaration would mistakenly be accepted!Note that this function looks through parentheses, so it will work on types such as  (forall a.  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.sghc;Decompose a GADT type into its constituent parts. Returns (outer_bndrs, mb_ctxt, body), where: outer_bndrs are T if the type has explicit, outermost type variable binders. Otherwise, they are T.mb_ctxt is Just5 the context, if it is provided. Otherwise, it is Nothing.body, is the body of the type after the optional foralls and context.?This function is careful not to look through parentheses. See Note [GADT abstract syntax] (Wrinkle: No nested foralls or contexts)  GHC.Hs.Decls for why this is important.sghcDecompose a type of the form forall  tvs. body into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g.,  forall a., with a dot).This function is used to split apart certain types, such as instance declaration types, which disallow visible forall)s. For instance, if GHC split apart the forall in "instance forall a -> Show (Blah a)6, then that declaration would mistakenly be accepted!Note that this function looks through parentheses, so it will work on types such as  (forall a.  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them. Unlike s, this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").sghcDecompose a type of the form forall  tvs. body into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g.,  forall a., with a dot).This function is used to split apart certain types, such as instance declaration types, which disallow visible forall)s. For instance, if GHC split apart the forall in "instance forall a -> Show (Blah a)6, then that declaration would mistakenly be accepted!Unlike s, this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").sghcDecompose a type of the form context => body into its constituent parts.Note that this function looks through parentheses, so it will work on types such as  (context =>  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.ghcDecompose a type of the form context => body into its constituent parts.Unlike s, this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").sghc3Decompose a type class instance type (of the form forall  tvs. context => instance_head-) into its constituent parts. Note that the [Name] s returned correspond to either:The implicitly bound type variables (if the type lacks an outermost forall), orThe explicitly bound type variables (if the type has an outermost forall).?This function is careful not to look through parentheses. See 6Note [No nested foralls or contexts in instance types] for why this is important.sghc3Decompose a type class instance type (of the form forall  tvs. context => instance_head ) into the  instance_head.sghc3Decompose a type class instance type (of the form forall  tvs. context => instance_head ) into the  instance_head and retrieve the underlying class type constructor (if it exists).sghcPrints the explicit forall in a type family equation if one is written. If there is no explicit forall, nothing is printed.sghcPrints the outermost forall in a type signature if one is written. If there is no outermost forall, nothing is printed.sghc3Prints a forall; When passed an empty list, prints forall ./ forall -> only when  -dppr-debug is enabled.sghcs p t returns L if the type t% needs parentheses under precedence p.sghcs p ty checks if s p ty is true, and if so, surrounds ty with an T . Otherwise, it simply returns ty.sghcs p ctxt checks if ctxt is a single constraint c such that s p c is true, and if so, surrounds c with an T to form a parenthesized ctxt . Otherwise, it simply returns ctxt unchanged.sghcThis instance is meant for debug-printing purposes. If you wish to pretty-print an application of Ss, use s instead.sghc Location of forall and -> for HsForAllVis Location of forall and k for HsForAllInvisSSTTTTTTsSSSssssTTTTTTTTTTTTTTTTTTTTTTTTTTTTTsTTTTTTTTTTTsTTTTTTTTTTTTTTTTTTTTTTTTTTTTTssssTTTTTTTTTSSSTTsTTTTTTTTSSSSssSssTTSSSSSSssSSSSSSSSsSSSSTSSSSSSsSSSSSsssssssssTssssssssssTsTssssssssssssssssssssssssssssTsssssssssssSSTTTTTTsSSSssssTTTTTTTTTTTTTTTTTTTTTTTTTTTTTsTTTTTTTTTTTsTTTTTTTTTTTTTTTTTTTTTTTTTTTTTssssTTTTTTTTTSSSTTsTTTTTTTTSSSSssSssTTSSSSSSssSSSSSSSSsSSSSTSSSSSSsSSSSSsssssssssTssssssssssTsTssssssssssssssssssssssssssssTsssssssssss Safe-Inferred &cghcEvery node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type.cghcEvery node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type. NB: see Note [The FVAnn invariant]cghcEvery node in a binding group annotated with its (non-global) free variables, both Ids and TyVars, and type.cghcFind all locally-defined free Ids or type variables in an expression returning a non-deterministic set.cghcFind all locally-defined free Ids or type variables in an expression returning a composable FV computation. See Note [FV naming conventions] in  GHC.Utils.FV for why export it.cghcFind all locally-defined free Ids or type variables in an expression returning a deterministic set.cghcFind all locally-defined free Ids or type variables in an expression returning a deterministically ordered list.cghc2Find all locally-defined free Ids in an expressioncghcFind all locally-defined free Ids in an expression returning a deterministic set.cghcFind all locally-defined free Ids in an expression returning a deterministically ordered list.cghcFind all locally-defined free Ids in several expressions returning a deterministic set.cghcFind all locally-defined free Ids in several expressions returning a deterministically ordered list.cghcFind all locally-defined free Ids or type variables in several expressions returning a non-deterministic set.ghcFind all locally-defined free Ids or type variables in several expressions returning a composable FV computation. See Note [FV naming conventions] in  GHC.Utils.FV for why export it.cghcFind all locally-defined free Ids or type variables in several expressions returning a deterministically ordered list.cghc4Find all locally defined free Ids in a binding groupcghc=Finds free variables in an expression selected by a predicatecghcFinds free variables in an expression selected by a predicate returning a deterministically ordered list.ghcFinds free variables in an expression selected by a predicate returning a deterministic set.cghcFinds free variables in several expressions selected by a predicatecghcFinds free variables in several expressions selected by a predicate returning a deterministically ordered list.ghcFinds free variables in several expressions selected by a predicate returning a deterministic set.ghcFinds the free external names of an expression, notably including the names of type constructors (which of course do not show up in c).cghcFinds the free external# names of several expressions: see  for detailscghcc collects the names of the concrete types and type constructors that make up the LHS of a type family instance, including the family name itself.For instance, given `type family Foo a b`: `type instance Foo (F (G (H a))) b = ...` would yield [Foo,F,G,H]Used (via orphNamesOfFamInst) in the implementation of ":info" in GHCi. and when determining orphan-hood for a FamInst or moduleghcThose locally-defined variables free in the left and/or right hand sides of the rule, depending on the first argument. Returns an ( computation.ghcThose locally-defined variables free in the left and/or right hand sides from several rules, depending on the first argument. Returns an ( computation.cghcThose variables free in the right hand side of a rule returned as a non-deterministic setcghcThose locally-defined free s in the right hand side of several rules returned as a non-deterministic setcghcThis finds all locally-defined free Ids on the left hand side of a rule and returns them as a non-deterministic setcghcThis finds all locally-defined free Ids on the left hand side of a rule and returns them as a deterministically ordered listcghcThose variables free in the both the left right hand sides of a rule returned as a non-deterministic setcghcThose variables free in the both the left right hand sides of rules returned as a deterministic setcghcThose variables free in both the left right hand sides of several rulescghcMake a _ containing a number of \!s, suitable for putting into an cghcInverse function to dcghc$Extract the vars reported in a FVAnndghc Annotate a  with its (non-global) free type and value variables at every tree node.cghc Says which s are interestingcghc Says which s are interestingghc Says which s are interestingghc Says which s are interesting3cccccccccccc(ccccccccccccccccccccccccccccccccccdccc3cccccccccccc(ccccccccccccccccccccccccccccccccccdccc Safe-Inferred )*9  ghc1a monad for the normalisation functions, reading d, a @, and a .dghc;Result of testing two type family equations for injectiviy.dghcEither RHSs are distinct or unification of RHSs leads to unification of LHSsdghcRHSs unify but LHSs don't unify under that substitution. Relevant for closed type families where equation after unification might be overlapped (in which case it is OK if they don't unify). Constructor stores axioms after unification.dghc Create a d from  indices. INVARIANTS: * The fs_tvs are distinct in each FamInst of a range value of the map (so we can safely unify them)dghc/Makes no particular effort to detect conflicts.dghcCheck whether two type family axioms don't violate injectivity annotation.dghcCreate a coercion constructor (axiom) suitable for the given newtype . The % should be that of a new coercion ?, the  s the arguments expected by the newtype8 and the type the appropriate right hand side of the newtype/, with the free variables a subset of those s.dghcCheck whether an open type family equation can be added to already existing instance environment without causing conflicts with supplied injectivity annotations. Returns list of conflicting axioms (type instance declarations).dghcDo an apartness check, as described in the "Closed Type Families" paper (POPL '14). This should be used when determining if an equation (?) of a closed type family can be used to reduce a certain target type family application.dghcGet rid of *outermost* (or toplevel) * type function redex * data family redex * newtypes returning an appropriate Representational coercion. Specifically, if topNormaliseType_maybe env ty = Just (co, ty') then (a) co :: ty ~R ty' (b) ty' is not a newtype, and is not a type-family or data-family redexHowever, ty' can be something like (Maybe (F ty)), where (F ty) is a redex.Always operates homogeneously: the returned type has the same kind as the original type, and the returned coercion is always homogeneous.dghcTry to simplify a type-family application, by *one* step If topReduceTyFamApp_maybe env r F tys = Just (HetReduction (Reduction co rhs) res_co) then co :: F tys ~R# rhs res_co :: typeKind(F tys) ~ typeKind(rhs) Type families and data families; always Representational roledghc flattened target arguments. Make sure they're flattened! See Note [Flattening type-family applications when matching instances] in GHC.Core.Unify.ghcthe candidate equation we wish to use Precondition: this matches the targetghcTrue  = equation can fire=ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd=ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd Safe-Inferred dghc A map from s to s, constructed by typechecking local declarations or interface filesdddddddddddddddddddddddddddddddddd- Safe-Inferred @jghcTrue of dyadic operators that can fail only if the second arg is zero!This function probably belongs in an automagically generated file.. but it's such a special case I thought I'd leave it here for now.jghc Returns the * of the wrapper associated with the given . See Note [Primop wrappers].jghcIndicate if a primop is really inline: that is, it isn't out-of-line and it isn't SeqOp/DataToTagOp which are two primops that evaluate their argument hence induce threadstack heap changes.ifdddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjddddjjjjjjjjjjjjjjjjjjjjjdddddifdddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjddddjjjjjjjjjjjjjjjjjjjjjddddd Safe-Inferred'/17 jghcSTG pretty-printing optionsjghcEnable cost-centreskghc,Used as a data type index for the stgSyn ASTkghc)Use internally by the lambda lifting passkghcTag inference information on binders. See Note [Tag inference passes] in GHC.Stg.InferTagskghcTag inference information put on relevant StgApp nodes See Note [Tag inference passes] in GHC.Stg.InferTagskghcWhen `-fdistinct-constructor-tables` is turned on then each usage of a constructor is given an unique number and an info table is generated for each different constructor.kghcLike , but with an   instance that returns  .kghcA top-level binding.kghcDoes this constructor application refer to anything in a different *Windows* DLL? If so, we can't allocate it staticallykghc Type of an StgArg8Very half baked because we have lost the type arguments.kghcGiven an alt type and whether the program is unarised, return whether the case binder is in scope.Case binders of unboxed tuple or unboxed sum type always dead after the unariser has run. See Note [Post-unarisation invariants].kghcUsed when constructing a term with an unused extension point that should not appear in pretty-printed output at all.kghc3STG pretty-printing options used for panic messageskghc3STG pretty-printing options used for short messagesghc,Code gen needs to track non-global free varskghc Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred < <ghcA thread is in one of 4 statesghcThe thread is runningghcThe thread is blockedghcThe thread is doneghcThe thread has diedghcA Closure is one of six typesghcThe closure is a THUNKghcThe closure is a Functionghc$The closure is a Partial ApplicationghcThe closure is a ConstructorghcThe closure is a BlackholeghcThe closure is a stack frameghcA Primop result is either an inlining of some JS payload, or a primitive call to a JS function defined in Shim files in base.ghc-primop is inline, result is assigned directlyghcprimop is async call, primop returns the next function to run. result returned to stack top in registersghcTyped expressionghcTypes of FFI valuesghc%one toplevel block in the object fileghc"toplevel symbols (stored in index)ghc,closure information of all closures in blockghcstatic closure dataghcthe codeghc raw JS codeghc4data used to generate one ObjUnit in our object fileghcserializable unit infoghc'exported names from haskell identifiersghc other exportsghc identifiers this unit depends onghc2pseudo-id identifiers this unit depends on (fixme)ghc7symbols not from a haskell id that this unit depends onghcalways link this unitghc#A foreign reference to some JS codeghcA Static literal valueŧghc?is function pointer, label (also used for string / binary init)ƧghcStatic Arguments. Static Arguments are things that are statically allocated, i.e., they exist at program startup. These are static heap objects or literals or things that have been floated to the top level binding by ghc.ǧghcreference to a heap objectȧghcliteralɧghcunfloated constructorѧghcheap object for functionҧghcheap object for CAF (field is Nothing when thunk is initialized in an alternative way, like string thunks through h$str)ӧghc+unboxed constructor (Bool, Int, Double etc)ԧghcregular datacon appէghc%list initializer (with optional tail)اghc global object٧ghcstatic initializationڧghcoptional CCS nameۧghcA Stack Slot is either known or unknown. We avoid maybe here for more strictness.ާghcThe global Identifier Cacheghc The identifier cache indexed on  local to a moduleghcSome other symbolghc-Keys to differentiate Ident's in the ID CacheghcThe type of identifiers. These determine the suffix of generated functions in JS Land. For example, the entry function for the K constructor is a  which compiles to:  function h$baseZCGHCziMaybeziJust_con_e() { return h$rs() };  which just returns whatever the stack point is pointing to. Whereas the entry function to K is an % and does the work. It compiles to:  function h$baseZCGHCziMaybeziJust_e() { var h$$baseZCGHCziMaybezieta_8KXnScrCjF5 = h$r2; h$r1 = h$c1(h$baseZCGHCziMaybeziJust_con_e, h$$baseZCGHCziMaybezieta_8KXnScrCjF5); return h$rs(); };  Which loads some payload from register 2, and applies the Constructor Entry function for the Just to the payload, returns the result in register 1 and returns whatever is on top of the stackghc.A plain identifier for values, no suffix addedghc$An entry function, suffix = "_e" in ghc3A Constructor entry function, suffix = "_con_e" in ghcFree variable typesghc3pointer = reference to heap object (closure object)ghc no fieldsghcA Double: one fieldghc$An Int (32bit because JS): one fieldghcA Long: two fields one for the upper 32bits, one for the lower (NB: JS is little endian)ghc4a pointer not to the heap: two fields, array + indexghcsome RTS object from GHCJS (for example TVar#, MVar#, MutVar#, Weak#)ghcsome JS object, user supplied, be careful around these, can be anythingghc boxed arrayghc)Static references that must be kept aliveghc The type of ghcThe closure is a THUNKghcThe closure is a Constructorghc$The closure is a Partial ApplicationghcThe closure is a black holeghcThe closure is a stack frameghcfunction arityghc number of registers for the argsghcClosure Information, , layoutghc=layout stored in object itself, first position from the startghc?fixed size, but content unknown (for example stack apply frame)ghcwhole layout knownghc0closure size in array positions, including entryghc The set of sized Types to layoutghcClosure information,  , registersghc/A value witnessing a state of unknown registersghc)unused registers before actual args startghcargsghc6Information relevenat to code generation for closures.ghcobject being infodghc,size of the payload (in number of JS values)ghcfriendly name for printingghcheap/stack layout of the objectghc2type of the object, with extra info where requiredghc static references of this objectghc-The Configuration record for the StgToJS passghcProfiling enabledghc#Enable runtime assertions settingsghcThe JS code generator state relevant for the current binding groupghc/extra toplevel statements for the binding groupghc4closure metadata (info tables) for the binding groupghc&static (CAF) data in our binding groupghc%stack info for the current expressionghccurrent stack depthghcextra dependencies for the linkable unit that contains this groupghcThe JS code generator stateghccodegen settings, read-onlyghccurrent moduleghc"unique number for the id generatorghc*hash consing for identifiers from a Uniqueghcunfloated argumentsghc#state for the current binding groupghcglobal (per module) statements (gets included when anything else from the module is used)ghc2A State monad over IO holding the generator state.ghcConvert  to an IntghcConvert  to a Stringghc3Convert the status of a thread in JS land to an Intghc5convert the status of a thread in JS land to a stringghcstatic refs: array = references, null = nothing to report note: only works after all top-level objects have been createdŧħç§ƧɧȧǧʧϧΧ̧ͧ˧Чէԧӧҧѧ֧ڧ٧اקۧݧܧާߧާߧۧݧܧ֧ڧ٧اקЧէԧӧҧѧʧϧΧ̧ͧ˧Ƨɧȧǧŧħç§"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred " EghcSyntactic sugar, i.e., a Haskell function which generates useful JS code. Given a JExpr, ex, inject a trace statement on ex in the compiled JS programghcSyntactic sugar. Given a JExpr, ex4 which is assumed to be a predicate, and a message m, assert that 'not ex' is True, if not throw an exception in JS land with message m.ghcname of the closure cghcType name of the closure cghcPerform the computation f', on the range of registers bounded by start and end.ghcassign frame size to thisghcstack frame header functionghc#size of the frame, including header"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Sylvain Henry Jeffrey Young Luite Stegeman Josh Meredith experimental Serialization/deserialization of binary .o files for the JavaScript backend The .o files contain dependency information and generated code. All strings are mapped to a central string table, which helps reduce file size and gives us efficient hash consing on read Binary intermediate JavaScript object files: serialized [Text] -> ([ClosureInfo], JStat) blocks file layout: - magic "GHCJSOBJ" - compiler version tag - module name - offsets of string table - dependencies - offset of the index - unit infos - index - string table Safe-Inferred " S(ghcSymbols exported by a unitghc%Offset of the unit in the object fileghcSerialized unit indexes and their exported symbols (the first unit is module-global)ghcExported Functionsghc"The module containing the functionghc The functionghc%dependencies on blocks in this objectghcdependencies on exported symbols in other objects , blockForeignExported :: [ExpFun] , blockForeignImported :: [ForeignRef]ghcWhere are the dependenciesghcIn an object file at pathghcIn a Ar file at pathghc In memoryghc dependencies for a single moduleghcmoduleghcblocks that always need to be linked when this object is loaded (e.g. everything that contains initializer code or foreign exports)ghc#exported Haskell functions -> blockghcinfo about each blockghcAn object fileghcname of the moduleghc/BinHandle that can be used to read the ObjUnitsghcOffset of the payload (units)ghc Dependenciesghc9The Index, serialed unit indices and their linkable unitsghcwe use the convention that the first unit (0) is a module-global unit that's always included when something from the module is loaded. everything in a module implicitly depends on the global block. the global unit itself can't have dependenciesghcWrite an ObjUnit, except for the top level symbols which are stored in the indexghcRead an ObjUnit and associate it to the given symbols (that must have been read from the index)ghc?A tag that determines the kind of payload in the .o file. See StgToJS.Linker.Arhive.magic for another kind of magicghc4Given a handle to a Binary payload, add the module, mod_name, its dependencies, deps(, and its linkable units to the payload.ghc&Test if the object file is a JS objectghc Check magicghcParse object magicghcParse object headerghcParse object body. Must be called after a sucessful getObjectHeaderghc Parse objectghcRead object from file9The object is still in memory after this (see objHandle).ghc5Reads only the part necessary to get the dependenciesghcGet units in the object file, using the given filtering functionghcRead units in the object file, using the given filtering functionghcHelper to convert Int to Int32ghcHelper to convert Int32 to Intghcmoduleghc dependenciesghc linkable units and their symbols''"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred " WtܩghcAn object file that's either already in memory (with name) or on diskݩghcload from this fileީghc'already loaded: description and payloadߩghcA  LinkableUnit is a pair of a module and the index of the block in the object fileghcwe generate a runnable all.js only if we link a complete application, no incremental linking and no skipped partsghcreturn a fresh GhcjsEnv٩ک۩ܩݩީߩ٩ک۩ܩݩީߩ Safe-Inferred" YlghcGet closure entry functionghcGet closure metadataghcGet closure cost-centerghcGet closure extra field 1ghcGet closure extra field 2ghc heap objectghcreference to entry, if you have one already (saves a c.f lookup twice)ghc8arity tag (tag >> 8 = registers, tag & 0xff = arguments)"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred `ghc-Context into which an expression is evaluatedghcTop-level binding Idghc-Target variables for the evaluated expressionghcIds that we know to be evaluated (e.g. case binders when the expression to evaluate is in an alternative)ghcSource locationghc,LNE bindings with their expected stack size.The Int is the size of the stack when the LNE binding was defined. We need to shrink the stack back to this size when we enter one of the associated binder rhs: it expects its free variables at certain offsets in the stack.ghcContents of current LNE frame&Variables and their index on the stackghcCache the length of ghcInitialize an expression context in the context of the given top-level binding Idghc Set targetghcSet top-level binding Idghc$Add an Id to the known-evaluated setghcSet source locationghcUpdate let-no-escape frameghc.Remove information about the current LNE frameghc>Predicate: do we know for sure that the given Id is evaluated?ghc-Does the given Id correspond to a LNE bindingghc;Does the given Id correspond to a LNE live var on the stackghcReturn the LNE stack size associated to the given Id. Return Nothing when the Id doesn't correspond to a LNE binding.ghc&Shrink the LNE stack to the given size Safe-Inferred" b9ghcAssign first expr only (if it exists), performing coercions between some PrimReps (e.g. StablePtr# and Addr#).ghc&Assign p2 to p1 with optional coercion Safe-Inferred cZghccollect Ids that this binding refers to (does not include the bindees themselves) first argument is Id -> StgExpr map for unfloated argumentsghc3returns True if the expression is definitely inline Safe-Inferred" eghc9emit a global (for the current module) toplevel statementghc ([Alt b], Maybe (Expr b))ƫghc3Strip ticks of a given type from an STG expression.ǫghcStrip ticks of a given type from an STG expression returning only the expression. «ëīƫǫū «ëīƫǫū Safe-Inferred hȫȫ Safe-Inferred 9 jQghchave we run the unariser yet?ghcTop-level bindings can't inherit the cost centre stack from their (static) allocation site.ghcextra vars in scope from GHCighcmodule being compiledghchave we run Unarise yet?ghcwho produced the STG? Safe-Inferred)*/1 kughcSimple convert env to a env of the 'InferTaggedBinders pass with no other changes.ghcLook up a sig in the given envghcLook up a sig in the env or derive it from information in the arg itself.(((((((((( Safe-Inferred tghcLocalFVs: set of variable that are: (a) bound locally (by a lambda, non-top-level let, or case); that is, it appears in the  field of 1 (b) appear free in the expression It is a  deterministic set because it is used to annotate closures with their free variables, and we want closure layout to be deterministic.4Invariant: the LocalFVs returned is a subset of the  field of EnvghcTopFVs: set of variables that are: (a) bound at the top level of this module, and (b) appear free in the expression It is a non-deterministic set because we use it only to perform dependency analysis on the top-level bindings.ghcSet of locally-bound, not-top-level binders in scope. That is, variables bound by a let (but not let-no-escape), a lambda (in a StgRhsClsoure), a case binder, or a case alternative. These are the variables that must be captured in a function closure, if they are free in the RHS. Example f = x. let g = y. x+1 let h = z. g z + 1 in h x In the body of h we have locals = {x, g, z}. Note that f is top level and does not appear in locals.˫ghcDependency sort a STG program, and annotate it with free variables The returned bindings: * Are in dependency order * Each StgRhsClosure is correctly annotated (in its extension field) with the free variables needed in the closure * Each StgCase is correctly annotated (in its extension field) with the variables that must be saved across the case̫ghc!Dependency analysis on STG terms.Dependencies of a binding are just free variables in the binding. This includes imported ids and ids in the current module. For recursive groups we just return one set of free variables which is just the union of dependencies of all bindings in the group.Implementation: pass bound variables (NestedIds) to recursive calls, get free variables (TopFVs) back. We ignore imported TopFVs as they do not change the ordering but it improves performance (see nameIsExternalFrom call in vars_fvs).˫̫˫̫ Safe-Inferred |ghc.The CSE environment. See Note [CseEnv Example]ghcThe main component of the environment is the trie that maps data constructor applications (with their & arguments) to an in-scope name that can be used instead. This name is always either a let-bound variable or a case binder.ghcThis substitution is applied to the code as we traverse it. Entries have one of two reasons:The input might have shadowing (see Note [Shadowing]), so we have to rename some binders as we traverse the tree.If we remove `let x = Con z` because `let y = Con z` is in scope, we note this here as x C y.ghcIf we come across a case expression case x as b of @ with a trivial binder, we add b C x to this. This map is *only* used when looking something up in the ce_conAppMap. See Note [Trivial case scrutinee]ghcThe third component is an in-scope set, to rename away any shadowing bindersghcNote [CseEnv Example] ~~~~~~~~~~~~~~~~~~~~~ The following tables shows how the CseEnvironment changes as code is traversed, as well as the changes to that code.InExpr OutExpr conAppMap subst in_scope JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ -- empty {} {} case @ as a of {Con x y -> case @ as a of {Con x y -> -- Con x y C a {} {a,x,y} let b = Con x y (removed) -- Con x y C a bCa {a,x,y,b} let c = Bar a let c = Bar a -- Con x y C a, Bar a C c bCa {a,x,y,b,c} let c = some expression let c' = some expression -- Con x y C a, Bar a C c bCa, cCc', {a,x,y,b,c,c'} let d = Bar b (removed) -- Con x y C a, Bar a C c bCa, cCc', dCc {a,x,y,b,c,c',d} (a, b, c d) (a, a, c' c)ghc;This function short-cuts let-bindings that are now obsolete Safe-Inferred <*jghcRecover the type of a well-typed Core expression. Fails when applied to the actual ]7 expression as it cannot really be said to have a typejghc4Returns the type of the alternatives right hand sidejghcReturns the type of the first alternative, which should be the same as for all alternativesjghcMakes a (->) type or an implicit forall type, depending on whether it is given a type variable or a term variable. This is used, for example, when producing the type of a lambda. Always uses Inferred binders.jghcj% for multiple type or value argumentsjghcDetermines the type resulting from applying an expression with given typejghcWrap the given expression in the coercion safely, dropping identity coercions and coalescing nested coercionsjghcWraps the given expression in the source annotation, dropping the annotation if possible.jghc b }&depending on whether we have to use a case or let" binding for the expression (see j). It's used by the desugarer to avoid building bindings that give Core Lint a heart attack, although actually the simplifier deals with them perfectly well. See also jghcTests whether we have to use a case rather than let7 binding for this expression as per the invariants of : see  GHC.Core#let_can_float_invariantjghcThis guy constructs the value that the scrutinee must have given that you are in one particular branch of a casejghc$Extract the default case alternativejghcFind the case alternative corresponding to a particular constructor: panics if no such constructor existsjghcMerge alternatives preserving order; alternatives in the first argument shadow ones in the secondjghcGiven: )case (C a b x y) of C b x y -> ...We want to drop the leading type argument of the scrutinee leaving the arguments to match against the patternjghc$Refine the default alternative to a ], if there is a unique way to do so. See Note [Refine DEFAULT case alternatives]jghcj' returns True of an expression that is:Safe to evaluate even if normal order eval might not evaluate the expression at all, orSafe not- to evaluate even if normal order would do soIt is usually called on arguments of unlifted type, but not always In particular, Simplify.rebuildCase calls it on lifted types when a 'case' is a plain . See the example in Note [exprOkForSpeculation: case expressions] belowPrecisely, it returns True iff: a) The expression guarantees to terminate, b) soon, c) without causing a write side effect (e.g. writing a mutable variable) d) without throwing a Haskell exception e) without risking an unchecked runtime exception (array out of bounds, divide by zero)For exprOkForSideEffects( the list is the same, but omitting (e).Note that exprIsHNF implies exprOkForSpeculation exprOkForSpeculation implies exprOkForSideEffects3See Note [PrimOp can_fail and has_side_effects] in GHC.Builtin.PrimOps and Note [Transformations affected by can_fail and has_side_effects];As an example of the considerations in this test, consider: -let x = case y# +# 1# of { r# -> I# r# } in Ebeing translated to: 3case y# +# 1# of { r# -> let x = I# r# in E }We can only do this if the y + 1 is ok for speculation: it has no side effects, and can't diverge or raise an exception.jghcj' returns True of an expression that is:Safe to evaluate even if normal order eval might not evaluate the expression at all, orSafe not- to evaluate even if normal order would do soIt is usually called on arguments of unlifted type, but not always In particular, Simplify.rebuildCase calls it on lifted types when a 'case' is a plain . See the example in Note [exprOkForSpeculation: case expressions] belowPrecisely, it returns True iff: a) The expression guarantees to terminate, b) soon, c) without causing a write side effect (e.g. writing a mutable variable) d) without throwing a Haskell exception e) without risking an unchecked runtime exception (array out of bounds, divide by zero)For exprOkForSideEffects( the list is the same, but omitting (e).Note that exprIsHNF implies exprOkForSpeculation exprOkForSpeculation implies exprOkForSideEffects3See Note [PrimOp can_fail and has_side_effects] in GHC.Builtin.PrimOps and Note [Transformations affected by can_fail and has_side_effects];As an example of the considerations in this test, consider: -let x = case y# +# 1# of { r# -> I# r# } in Ebeing translated to: 3case y# +# 1# of { r# -> let x = I# r# in E }We can only do this if the y + 1 is ok for speculation: it has no side effects, and can't diverge or raise an exception.jghcA special version of j used during Note [Speculative evaluation]. When the predicate arg fun_ok returns False for b, then b! is never considered ok-for-spec.jghcShould we look past this tick when eta-expanding the given function?See Note [Ticks and mandatory eta expansion] Takes the function we are applying as argument.jghc:exprIsHNF returns true for expressions that are certainly already evaluated to head normal form. This is used to decide whether it's ok to change: case x of _ -> einto: e-and to decide whether it's safe to discard a . So, it does not treat variables as evaluated, unless they say they are. However, it does treat partial applications and constructor applications as values, even if their arguments are non-trivial, provided the argument type is lifted. For example, both of these are values: &(:) (f x) (map f xs) map (...redex...)because & on such things completes immediately.3For unlifted argument types, we have to be careful: C (f x :: Int#)Suppose f x diverges; then C (f x) is not a value. We check for this using needsCaseBinding belowjghc Similar to j but includes CONLIKE functions as well as data constructors. Conlike arguments are considered interesting by the inliner.ghcReturns true for values or value-like expressions. These are lambdas, constructors / CONLIKE functions (as determined by the function argument) or PAPs.jghcCan we bind this  at the top level?jghcCheck if the expression is zero or more Ticks wrapped around a literal string.jghcExtract a literal string from an expression that is zero or more Ticks wrapped around a literal string. Returns Nothing if the expression has a different shape. Used to "look through" Ticks in places that need to handle literal strings.jghcA cheap equality test which bales out fast! If it returns True the arguments are definitely equal, otherwise, they may or may not be equal.jghc9Cheap expression equality test, can ignore ticks by type.jghc-Finds differences between core bindings, see diffExpr.The main problem here is that while we expect the binds to have the same order in both lists, this is not guaranteed. To do this properly we'd either have to do some sort of unification or check all possible mappings, which would be seriously expensive. So instead we simply match single bindings as far as we can. This leaves us just with mutually recursive and/or mismatching bindings, which we then speculatively match by ordering them. It's by no means perfect, but gets the job done well enough.%Only used in GHC.Core.Lint.lintAnnotsghcFinds differences between core expressions, modulo alpha and renaming. Setting top means that the IdInfo6 of bindings will be checked for differences as well.ghcFind differences in IdInfo. We will especially check whether the unfoldings match, if present (see  diffUnfold).ghcFind differences in unfoldings. Note that we will not check for differences of IdInfo in unfoldings, as this is generally redundant, and can lead to an exponential blow-up in complexity.ghc)Add location information to diff messagesjghcTrue if the type has no non-bottom elements, e.g. when it is an empty datatype, or a GADT with non-satisfiable type parameters, e.g. Int :~: Bool. See Note [Bottoming expressions]See Note [No alternatives lint check] for another use of this function.jghcIf 1normSplitTyConApp_maybe _ ty = Just (tc, tys, co) then ty |> co = tc tys. It's '#, but looks through coercions via d. Hence the "norm" prefix.jghc-collectMakeStaticArgs (makeStatic t srcLoc e) yields Just (makeStatic, t, srcLoc, e).Returns Nothing for every other expression.jghcDoes this binding bind a join point (or a recursive group of join points)?jghcDo we expect there to be any benefit if we make this var strict in order for it to get treated as as cbv argument? See Note [Which Ids should be strictified] See Note [CBV Function Ids] for more background.jghcCase alternative constructorghc!Things bound by the pattern matchghc*The type arguments to the case alternativejghcType constructor of scrutinee's type (used to prune possibilities)ghcAnd its type argumentsghc imposs_cons: constructors known to be impossible due to the form of the scrutineeghc Alternativesjghc$Uniques for constructing new bindersghc.Multiplicity annotation of the case expressionghc$Type constructor of scrutinee's typeghc"Type arguments of scrutinee's typeghc3Constructors that cannot match the DEFAULT (if any)ghcL', if a default alt was replaced with a ]jjjjjjjjjjjjjjjjjjjjjjjjjjjGjjjjjjjjjjjjjjjjjjjjjjjjj]jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjGjjjjjjjjjjjjjjjjjjjjjjjjj]jjjjjjjjjjjjjjjjjjjj Safe-Inferred  ghc-The analysis monad consists of the following  components:: Reader-like context. Contains a substitution, info about how how lifted identifiers are to be expanded into applications and configuration options. .: Writer output for the resulting STG program.No pure state componentBut wrapping around 2 for generating fresh lifted binders. (The uniqAway approach could give the same name to two different lifted binders, so this is necessary.)ghcWe need to detect when we are lifting something out of the RHS of a recursive binding (c.f. GHC.Stg.Lift.Monad#floats), in which case that binding needs to be added to the same top-level recursive group. This requires we detect a certain nesting structure, which is encoded by  and . Although  will only ever care if the current binding to be lifted (through ) will occur inside such a binding group or not, e.g. doesn't care about the nesting level as long as its greater than 0.ghc)Environment threaded around in a scoped, Reader-like fashion.ghc Read-only.ghc(We need to track the renamings of local &s to their lifted &, because shadowing might make a closure's free variables unavailable at its call sites. Consider: * let f y = x + y in let x = 4 in f x  Here, f9 can't be lifted to top-level, because its free variable x# isn't available at its call site.ghcLifted s don't occur as free variables in any closure anymore, because they are bound at the top-level. Every occurrence must supply the formerly free variables of the lifted , so they in turn become free variables of the call sites. This environment tracks this expansion from lifted s to their free variables.&s to &s. Invariant: /s not present in this map won't be substituted.ghc uncurry  .  = idghcFlattens an expression in [] into an STG program, see GHC.Stg.Lift.Monad#floats4. Important pre-conditions: The nesting of opening StartBindinGroups and closing EndBindinGroups is balanced. Also, it is crucial that every binding group has at least one recursive binding inside. Otherwise there's no point in announcing the binding group in the first place and an ASSERT will trigger.ghcOmitting this makes for strange closure allocation schemes that crash the GC.ghcWrites a plain k to the output.ghc&Starts a recursive binding group. See GHC.Stg.Lift.Monad#floats and .ghc$Ends a recursive binding group. See GHC.Stg.Lift.Monad#floats and .ghcLifts a binding to top-level. Depending on whether it's declared inside a recursive RHS (see GHC.Stg.Lift.Monad#floats and ), this might be added to an existing recursive top-level binding group.ghcTakes a binder and a continuation which is called with the substituted binder. The continuation will be evaluated in a  context in which that binder is deemed in scope. Think of it as a  computation: After the continuation finishes, the new binding won't be in scope anymore.ghcSee .ghc Similarly to , this function takes a set of variables to abstract over, the binder to lift (and generate a fresh, substituted name for) and a continuation in which that fresh, lifted binder is in scope.It takes care of all the details involved with copying and adjusting the binder and fresh name generation.ghcSee .ghcSubstitutes a binder  occurrence), which was brought in scope earlier by  / .ghc:Whether the given binding was decided to be lambda lifted.ghcReturns an empty list for a binding that was not lifted and the list of all local variables the binding abstracts over (so, exactly the additional arguments at adjusted call sites) otherwise.ghc Creates an expander function for the current set of lifted binders. This expander function will replace any & by their corresponding & and, in addition, will expand any lifted binders by the former free variables it abstracts over. Safe-Inferred ghcFor a binding we: * Look at the args * Mark any argument as call-by-value if: - It's argument to a worker and demanded strictly - Unless it's an unlifted type already * Update the id See Note [CBV Function Ids] See Note [Attaching CBV Marks to ids]~~~~~~~~ Safe-Inferred lghcAdd a substitution for an  to the E: you must ensure that the in-scope set is such that TyCoSubst Note [The substitution invariant] holds after extending the substitution like thislghcAdds multiple  substitutions to the E : see also llghcAdd a substitution appropriate to the thing being substituted (whether an expression, type, or coercion). See also l, F, FlghcAdd a substitution as appropriate to each of the terms being substituted (whether expressions, types, or coercions). See also l.lghcFind the substitution for an  in the E The Id should not be a CoVarlghcSimultaneously substitute for a bunch of variables No left-right shadowing ie the substitution for (x y. e) a1 a2 so neither x nor y scope over a1 a2lghc.substExpr applies a substitution to an entire 1. Remember, you may only apply the substitution once/: See Note [Substitutions apply only once] in GHC.Core.TyCo.SubstDo *not* attempt to short-cut in the case of an empty substitution! See Note [Extending the IdSubstEnv]lghc"Apply a substitution to an entire \$, additionally returning an updated E2 that should be used by subsequent substitutions.lghc"Apply a substitution to an entire \$, additionally returning an updated E2 that should be used by subsequent substitutions.lghcDe-shadowing the program is sometimes a useful pre-pass. It can be done simply by running over the bindings with an empty substitution, because substitution returns a result that has no-shadowing guaranteed.(Actually, within a single type* there might still be shadowing, because substTy is a no-op for the empty substitution, but that's probably OK.) Aug 09This function is not used in GHC at the moment, but seems so short and simple that I'm going to leave it herelghcSubstitutes a " for another one according to the E- given, returning the result and an updated E3 that should be used by subsequent substitutions.  is preserved by this process, although it is substituted into appropriately.lghcApplies l to a number of s, accumulating a new E left-to-rightlghc,Substitute in a mutually recursive group of slghcVery similar to l , but it always allocates a new  for each variable in its output. It substitutes the IdInfo though. Discards non-Stable unfoldingslghcApplies l to a number of s, accumulating a final substitution from left to right Discards non-Stable unfoldingslghc$Clone a mutually recursive group of slghcSubstitute into some ! with regard to the supplied new .. Discards unfoldings, unless they are StablelghcSubstitutes for the *s within an unfolding NB: substUnfolding discards any unfolding without without a Stable source. This is usually what we want, but it may be a bit unexpectedlghcSubstitutes for the *s within an unfolding NB: substUnfolding discards any unfolding without without a Stable source. This is usually what we want, but it may be a bit unexpectedlghcSubstitutes for the  s within the _ given the new function ghc"Substitution to use for the IdInfoghc Substitution and Id to transformghc-Transformed pair NB: unfolding may be zapped9EEEE(lllFFlllllllllllllEEElEllFFllllFFFEEEFFllElllFFlllll9EEEE(lllFFlllllllllllllEEElEllFFllllFFFEEEFFllElllFFlllll Safe-Inferred  Safe-Inferred lghcState Monad used inside exitifyghc8Traverses the AST, simply to find all joinrecs and call exitify8 on them. The really interesting function is exitifyRecghcGiven a recursive group of a joinrec, identifies @exit paths@ and binds them as join-points outside the joinrec. Safe-Inferred ghcGiven a binding of in_id to in_rhs , and a fresh name to refer to in_id (out_id>, created from addBinder or addRecBinders), first try to CSE in_rhs>, and then add the resulting (possibly CSE'd) binding to the , so that we attempt to CSE any expressions which are equal to out_rhs. We use a different env for cse on the rhs and for extendCSEnvWithBinding for reasons explain in See Note [Separate envs for let rhs and body]ghcGiven a binder `let x = e`, this function determines whether we should add `e -> x` to the cs_mapghc Runs CSE on a single expression.This entry point is not used in the compiler itself, but is provided as a convenient entry point for users of the GHC API.ghcextendCSEnv env e triv_expr will replace any occurrence of e with  triv_expr going forward.ghcAdd clones to the substitution to deal with shadowing. See Note [Shadowing] for more details. You should call this whenever you go under a binder. Safe-Inferred lghc;The analysis lattice of arity analysis. It is isomorphic to  data ArityType' = AEnd Divergence | ALam OneShotInfo ArityType' 1Which is easier to display the Hasse diagram for:  ALam OneShotLam at | AEnd topDiv | ALam NoOneShotInfo at | AEnd exnDiv | AEnd botDiv  where the at fields of ALam6 are inductively subject to the same order. That is, ALam os at1 < ALam os at2 iff  at1 < at2.Why the strange Top element? See Note [Combining case branches: optimistic one-shot-ness]We rely on this lattice structure for fixed-point iteration in l. For the semantics of l, see Note [ArityType].ghc`AT oss div` is an abstraction of the expression, which describes its lambdas, and how much work appears where. See Note [ArityType] for more informationIf  is dead-ending ([), then application to `length os` arguments will surely diverge, similar to the situation with Z.lghcmanifestArity sees how many leading value lambdas there are, after looking through castslghc6(typeArity ty) says how many arrows GHC can expose in ty, after looking through newtypes. More generally, (typeOneShots ty) returns ty's [OneShotInfo], based only on the type itself, using typeOneShot on the argument type to access the "state hack".ghcLike a, but taking the Horrible State Hack in to account See Note [The state-transformer hack] in GHC.Core.Opt.Aritylghc/Returns whether the lambda associated with the  is certainly applied at most once This one is the "business end", called externally. It works on type variables as well as Ids, returning True Its main purpose is to encapsulate the Horrible State Hack See Note [The state-transformer hack] in GHC.Core.Opt.Aritylghc+The number of value args for the arity typeghcAssuming this ArityType is all we know, find the arity of the function, and trim the argument info (and Divergence) to match that arity. See Note [SafeArityType]ghcTrim an arity type so that it has at most the given arity. Any excess !s are truncated to [, even if they end in ABot. See Note [Arity trimming]lghcThe Arity returned is the number of value args the expression can be applied to without doing much workghcLeast upper bound in the l lattice. See the haddocks on l for the lattice.Used for branches of a case.ghcThe ArityEnv used by l.ghc8Whether the analysis should be pedantic about bottoms. l always is.ghc A version of j that considers results from arity analysis and optionally the expression's type. Under l, no expressions are cheap.ghc A version of j that considers results from arity analysis. See Note [Arity analysis] for what's in the signature environment and why it's important.lghc(An approximate, even faster, version of l Roughly exprArity e = arityTypeArity (cheapArityType e) But it's a bit less clever about bottomsWe do not guarantee that exprArity e <= typeArity e You may need to do arity trimming after calling exprArity See Note [Arity trimming] Reason: if we do arity trimming here we have take exprType and that can be expensive if there is a large castlghc etaExpand n e1 returns an expression with the same meaning as e, but with arity n.Given: e' = etaExpand n eWe should have that: ty = exprType e = exprType e'ghcmkEtaWW n _ fvs ty will compute the , necessary for eta-expanding an expression e :: ty to take n value arguments, where fvs are the free variables of e.Note that this function is entirely unconcerned about cost centres and other semantically-irrelevant source annotations, so call sites must take care to preserve that info. See Note [Eta expansion and SCCs].lghc`tryEtaReduce [x,y,z] e sd` returns `Just e'` if `x y z -> e` is evaluated according to sd1 and can soundly and gainfully be eta-reduced to e'. See Note [Eta reduction soundness] and Note [Eta reduction makes sense] when that is the case.ghcCan we eta-reduce the given function See Note [Eta reduction soundness], criteria (B), (J), (W) and (L).lghcIf 'pushCoValArg co = Just (co_arg, co_res), then (\x.body) |> co = (\y. let { x = y |> co_arg } in body) |> co_res)or, equivalently 3(fun |> co) arg = (fun (arg |> co_arg)) |> co_resIf the LHS is well-typed, then so is the RHS. In particular, the argument  arg |> co_arg is guaranteed to have a fixed  RuntimeRep, in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.lghcSplit an expression into the given number of binders and a body, eta-expanding if necessary. Counts value *and* type binders.lghc(This is the BNF of the generated output:  @ We format AT [o1,..,on] topDiv as o1..on.T and AT [o1,..,on] botDiv as o1..on.E", respectively. More concretely, AT [NOI,OS,OS] topDiv is formatted as ?11.T6. If the one-shot info is empty, we omit the leading .@.ghc;Info about one lambda in an ArityType See Note [ArityType]ghc&How many value arguments to eta-expandghc5The pretty-printed original expression, for warnings.ghc=A super-set of the free vars of the expression to eta-expand.ghcThe variables in  are fresh wrt. to the incoming (. The outgoing ( extends the incoming ( with the fresh variables in .#lllllllllllllllllllllllllllllllllll#lllllllllllllllllllllllllllllllllll22 Safe-Inferred( lghc (#22336) See Note [Boxing constructors] in GHC.Builtin.TypesmghcLifts a "small" constructor into a "big" constructor by recursive decompositionmghcSplit a list into lists that are small enough to have a corresponding tuple arity. The sub-lists of the result all have length <=  But there may be more than  sub-listsmghcm is like m but one-tuples are NOT flattened (see Note [Flattening one-tuples])Builds a selector which scrutinises the given expression and extracts the one name from the list given. If you want the no-shadowing rule to apply, the caller is responsible for making sure that none of these names are in scope.If there is just one 7 in the tuple, then the selector is just the identity.0If necessary, we pattern match on a "big" tuple.A tuple selector is not linear in its argument. Consequently, the case expression built by m must consume its scrutinee Many? times. And all the argument variables must have multiplicity Many.mghcBuilds a selector which scrutinises the given expression and extracts the one name from the list given. If you want the no-shadowing rule to apply, the caller is responsible for making sure that none of these names are in scope.If there is just one 7 in the tuple, then the selector is just the identity.0If necessary, we pattern match on a "big" tuple.A tuple selector is not linear in its argument. Consequently, the case expression built by m must consume its scrutinee Many? times. And all the argument variables must have multiplicity Many.ghc is like  but one-tuples are NOT flattened (see Note [Flattening one-tuples]) is like m, but for tuples that are guaranteed never to be "big". Also does not unwrap boxed types. mkSmallTupleSelector [x] x v e = [| e |] mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]ghc is like m, but for tuples that are guaranteed never to be "big". Also does not unwrap boxed types. mkSmallTupleSelector [x] x v e = [| e |] mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]mghcA generalization of m?, allowing the body of the case to be an arbitrary expression.;To avoid shadowing, we use uniques to invent new variables./If necessary we pattern match on a "big" tuple.ghcAs m, but for a tuple that is small enough to be guaranteed not to need nesting.mghc/Applies the floats from right to left. That is wrapFloats [b1, b2, @, bn] u = let b1 in let b2 in @ in let bn in umghc Makes a list [] for lists of the specified typemghc Makes a list (:) for lists of the specified typemghcMake a list containing the given expressions, where the list has the given typemghcMake a fully applied  expressionmghcMake a build6 expression applied to a locally-bound worker functionmghc&Makes a Nothing for the specified typemghc/Makes a Just from a value of the specified typeghc!Exception with type "forall a. a"Any exceptions added via this function needs to be added to the RTS's initBuiltinGcRoots() function.ghcAn  for an Id, such as , that throws an (imprecise) exception after being supplied one value arg for every argument Z9 in the list. The demands end up in the demand signature. 8Sets the demand signature to unleash the given arg dmds [Sets the arity info so that it matches the length of arg demands/Sets a bottoming CPR sig with the correct arityIt's important that all 3 agree on the arity, which is what this defn ensures. lghcfunctionghc argumentslghcfunctionghcargumentmghc scrutineeghcres_tyghcaltsmghcguardghcthenghcelsemghc5"Small" constructor function, of maximum input arity ghc/Possible "big" list of things to construct fromghc:Constructed thing made possible by recursive decompositionmghcThe $s to pattern match the tuple againstghcThe  to selectghc,A variable of the same type as the scrutineeghc ScrutineeghcSelector expressionmghcThe $s to pattern match the tuple againstghcThe  to selectghc,A variable of the same type as the scrutineeghc ScrutineeghcSelector expressionmghc-For inventing names of intermediate variablesghcThe tuple identifiers to pattern match on; Bring these into scope in the bodyghcBody of the caseghc ScrutineeghcThe tuple argsghcBody of the caseghc,A variable of the same type as the scrutineeghc ScrutineemghcElement type of the listghcFold result typeghcCons! function expression for the foldghcNil expression for the foldghc#List expression being folded acressmghc!Type of list elements to be builtghc+Function that, given information about the s of the binders for the build worker function, returns the body of that workerllllllmmmljlmmmmmmmmmmmmmmllllmlllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmllllllmmmljlmmmmmmmmmmmmmmllllmlllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmml4l4 Safe-Inferred  ghc7True if it's a bad idea to float bindings into this RHS. Safe-Inferred >ghcUnfolding optionsghc0The size of a candidate expression for unfoldingghc Size foundghc2Arguments cased herein, and discount for each suchghc?Size to subtract if result is scrutinised by a case expressionkghc2Threshold above which unfoldings are not *created*kghc2Threshold above which unfoldings are not *inlined*kghc,Discount for lambdas that are used (applied)kghcDiscount for dictionarieskghc!Force inlining in many more caseskghcDon't consider depth up to xkghcPenalize depth with 1/xlghc9Only report inlining decisions for names with this prefixghc)Finds a nominal size of a string literal.ghcThe size of a function callghc"The size of a jump to a join pointghcReport the inlining of an identifier's RHS to the user, if requested.ghcnumber of value argsghc"number of value args that are voidghcnumber of value argsghc"number of value args that are void%\\kkkkkkkkllkkkkllllkkkkkkkl%\\kkkkkkkkllkkkkllllkkkkkkkl Safe-Inferred 9 `sghcFlag in string formtghcFlag in internal formtghcExtra action to run when the flag is found Typically, emit a warning or errortghc%In which ghc mode the flag has effecttghc&Don't try to build dynamic objects tootghc*Will still try to generate dynamic objectstghc5Currently generating dynamic objects (in the backend)tghc+Flags for manipulating packages visibility.tghc-package,  -package-idtghc  -hide-packagetghc%Flags for manipulating package trust.tghc -trusttghc  -distrusttghc6Flags for manipulating the set of non-broken packages.tghc -ignore-packagetghcRepresents the renaming that may be associated with an exposed package, e.g. the rns part of -package "foo (rns)".Here are some example parsings of the package flags (where a string literal is punned to be a  : -package foo is ModRenaming True []-package foo () is ModRenaming False []-package foo (A) is ModRenaming False [(A, A)]-package foo (A as B) is ModRenaming False [(A, B)]-package foo with (A as B) is ModRenaming True [(A, B)]tghc%Bring all exposed modules into scope?tghc Bring module m into scope under name n.tghcWe accept flags which make packages visible, but how they select the package varies; this data type reflects what selection criterion is used.tghc-package, by  PackageNametghc -package-id, by  tghc-What to do in the link step, if there is one.tghcDon't link at alltghcLink object code into a binarytghcUse the in-memory dynamic linker (works for both bytecode and object code).tghcLink objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)tghcLink objects into a static libtghc(Link objects into a merged "GHCi object"tghcThe t tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the GHC.Unit.Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.tghc--make , GHCi, etc.tghc  ghc -c Foo.hstghcghc -M, see GHC.Unit.Finder for why we need thistghc"Contains not only a collection of s but also a plethora of information relating to the compilation of a single file or GHC sessiontghcThe backend to use (if any).7Whenever you change the backend, also make sure to set t to something sensible. NoBackend can be used to avoid generating any output, however, note that:If a program uses Template Haskell the typechecker may need to run code from an imported module. To facilitate this, code generation is enabled for modules imported by modules that use template haskell, using the default backend for the platform. See Note [-fno-code mode].tghcLLVM optimisation leveltghc,Verbosity level: see Note [Verbosity levels]tghc%How much debug information to producetghcNumber of simplifier phasestghcMax simplifier iterationstghcAdditional demand analysistghcThe number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.tghcEnable RTS timing statistics?tghcThe heap size to set.tghcMaximum number of bindings from the type envt to show in type error messagestghcMaximum number of hole fits to show in typed hole error messagestghcMaximum number of refinement hole fits to show in typed hole error messagestghcMaximum level of refinement for refinement hole fits in typed hole error messagestghcMaximum number of unmatched patterns to show in non-exhaustiveness warningstghcSoft limit on the number of models the pattern match checker checks a pattern against. A safe guard against exponential blow-up.tghcMultiplier for simplifier tickstghcWhether DmdAnal should optimistically put an Unboxed demand on returned products with at most this number of fieldstghcThreshold for SpecConstrtghc2Max number of specialisations for any one functiontghcMax number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.tghcBinary literals (e.g. strings) whose size is above this threshold will be dumped in a binary file by the assembler code generator. 0 and Nothing disables this feature. See .tghcThreshold for LiberateCasetghc%Arg count for lambda floating See tghcMaximum number of arguments after lambda lifting a recursive function.tghcMaximum number of arguments after lambda lifting a non-recursive function.tghcLambda lift even when this turns a known call into an unknown call.tghc4Align Cmm functions at this boundary or use default.tghcSimplification history sizetghcTypechecker maximum stack depthtghcNumber of iterations in the constraints solver Typically only 1 is neededtghcTarget home unit-idtghcId of the unit to instantiatetghcModule instantiationstghc8What the package is called, use with multiple home unitstghc&Target way flags from the command lineughcIndicate if we are now generating dynamic output because of -dynamic-too. This predicate is used to query the appropriate fields (outputFile/dynOutputFile, ways, etc.)ughc1This defaults to 'non-module'. It can be set by  or 'ghc.GHCi.UI.runStmt'% based on where its output is going.ughc Override the u set by  or 'ghc.GHCi.UI.runStmt' . Set by -ddump-file-prefixughcPath to store the .mix filesughcthe -fplugin flags given on the command line, in *reverse* order that they're specified on the command line.ughcthe -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.ughc-External plugins loaded from shared librariesughcThe  -package-db flags given on the command line, In *reverse* order that they're specified on the command line. This is intended to be applied with the list of "initial" package databases derived from GHC_PACKAGE_PATH; see  getUnitDbRefs.ughcThe -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.ughcThe -package and  -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.ughcThe -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.ughcThe -trust and  -distrust flags. In *reverse* order that they're specified on the command line.ughcFilepath to the package environment file (if overriding default)ughcSafe Haskell modeughcUnfolding control See Note [Discounts and thresholds] in GHC.Core.Unfoldughc8GHCi scripts specified by -ghci-script, in reverse orderughc-what kind of {-# SCC #-} to add automaticallyughc(Machine dependent flags (-m stuff)ughc8Run-time linker information (what options we need, etc.)ughcRun-time C compiler informationughcRun-time assembler informationughc0Max size, in bytes, of inline array allocations.ughcOnly inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.ughcOnly inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.ughc/Reverse the order of error messages in GHC/GHCiughc*Limit the maximum number of errors to showughc9Unique supply configuration for testing build determinismughc/Temporary: CFG Edge weights for fast iterationsughcUsed to differentiate the scope an include needs to apply to. We have to split the include paths to avoid accidentally forcing recursive includes since -I overrides the system search paths. See #14312.ughc!See Note [Implicit include paths]ughcAppend to the list of includes a path that shall be included using `-I` when the C compiler is called. These paths override system search paths.ughcAppend to the list of includes a path that shall be included using `-iquote` when the C compiler is called. These paths only apply when quoted includes are used. e.g. #include "foo.h"ughcThese includes are not considered while fingerprinting the flags for iface | See Note [Implicit include paths]ughcConcatenate and flatten the list of global and quoted includes returning just a flat list of paths.ughc "unbuild" a > from a t. This shouldn't be needed in the vast majority of code. But GHCi questionably uses this to produce a default t1 from which to compute a flags diff for printing.vghcThe directory for this version of ghc in the user's app directory The appdir used to be in ~/.ghc but to respect the XDG specification we want to move it under $XDG_DATA_HOME/ However, old tooling (like cabal) might still write package environments to the old directory, so we prefer that if a subdirectory of ~/.ghc with the correct target and GHC version suffix exists. i.e. if ~.ghc$UNIQUE_SUBDIR exists we use that otherwise we use $XDG_DATA_HOME/$UNIQUE_SUBDIRUNIQUE_SUBDIR is typically a combination of the target platform and GHC versionvghcAre we building with -fPIE or -fPIC enabled?vghcUsed by  to partially initialize a new t valuevghc The normal t. Note that they are not suitable for use in this form and must be fully initialized by  first.vghcThe language extensions implied by the various language variants. When updating this be sure to update the flag documentation in docs users_guideexts.vghcTest whether a  is setvghcSet a vghcUnset a vghcTest whether a  is set Note that u (i.e., dynamic objects built with `-dynamic-too`) always implicitly enables Opt_PIC, Opt_ExternalDynamicRefs, and disables Opt_SplitSections.vghcSet a vghcUnset a vghcTest whether a  is setvghcSet a vghcUnset a vghcTest whether a  is set as fatalvghcMark a  as fatal (do not set the flag)vghcMark a  as not fatalvghcTest whether a  is setvghcSet a vghcUnset a vghcSet or unset a 7, unless it has been explicitly set or unset before.ghc(Set the Haskell language standard to usevghcIs the -fpackage-trust mode onvghc9Is Safe Haskell on in some way (including inference mode)vghc(Is the Safe Haskell safe language in usevghc.Is the Safe Haskell safe inference mode activevghc(Test if Safe Imports are on in some formghcSet a 'Safe Haskell' flagvghcAre all direct imports required to be safe for this Safe Haskell mode? Direct imports are when the code explicitly imports a modulevghcAre all implicit imports required to be safe for this Safe Haskell mode? Implicit imports are things in the prelude. e.g System.IO when print is used.ghcCombine two Safe Haskell modes correctly. Used for dealing with multiple flags. This makes Safe Haskell very much a monoid but for now I prefer this as I don't want to export this functionality from the module but do want to export the type constructors.vghcA list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag offvghcA list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag offvghc3Retrieve the options corresponding to a particular opt_* field in the correct ordervghcGets the verbosity flag for the current verbosity level. This is fed to other tools, so GHC-specific verbosity flags like  -ddump-most are not includedghc Sets the t to be appropriate to the optimisation level and signals if any changes took placevghc Sets the t, to be appropriate to the optimisation levelvghcParse dynamic flags from a list of command line arguments. Returns the parsed t=, the left-over arguments, and a list of warnings. Throws a  if errors occurred during parsing (such as unknown flags or missing arguments).vghcLike v but does not allow the package flags (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db). Used to parse flags set in a modules pragma.vghcA helper to parse a set of flags from a list of command-line arguments, handling response files.vghcParses the dynamically set flags for GHC. This is the most general form of the dynamic flag parser that the other methods simply wrap. It allows saying which flags are valid flags and indicating if we are parsing arguments from the command line or from a file pragma.ghcCheck (and potentially disable) any extensions that aren't allowed in safe mode.The bool is to indicate if we are parsing command line flags (false means file pragma). This allows us to generate better warnings.vghcAll dynamic flags option strings without the deprecated ones. These are the user facing strings for enabling and disabling options.ghc4All flags with possibility to filter deprecated onesghcThis is where we handle unrecognised warning flags. We only issue a warning if -Wunrecognised-warning-flags is set. See #11429 for context.vghcMake a list of flags for shell completion. Filter all available flags into two groups, for interactive GHC vs all other.ghcDefine a new flag.ghc!Define a new flag with an effect.ghcDefine a warning flag.ghc%Define a warning flag with an effect.ghc,Define a new deprecated flag with an effect.ghcDefine a new deprecated flag.ghc!Define a deprecated warning flag.ghc8Define a deprecated warning name substituted by another.ghcDefine a new deprecated flag with an effect where the deprecation message depends on the flag valueghcDefine a new deprecated flag where the deprecation message depends on the flag valueghcDefine a new deprecated flag where the deprecation message is shown depending on the flag valueghcDefine a new flag for GHCi.ghc*Define a new flag for GHCi with an effect.ghc.Define a new flag invisible to CLI completion.ghc=Define a new flag invisible to CLI completion with an effect.ghcHide a s from being displayed in --show-options.This is for example useful for flags that are obsolete, but should not (yet) be deprecated for compatibility reasons.vghc Find the s for a .vghcThese -W flags can all be reversed with  -Wno-ghcThese - flags can all be reversed with  -no-ghcThese -d flags can all be reversed with  -dno-vghcThese -f flags can all be reversed with  -fno-ghcThese -f flags have to do with the typed-hole error message or the valid hole fits in that message. See Note [Valid hole fits include ...] in the GHC.Tc.Errors.Hole/ module. These flags can all be reversed with  -fno-vghcThese -f flags can all be reversed with  -fno-ghcThese -X blah# flags cannot be reversed with -XNo blahghcThese -X blah# flags cannot be reversed with -XNo blah They are used to place hard requirements on what GHC Haskell language features can be used.vghcThese -X blah$ flags can all be reversed with -XNo blahghcThese are the default settings for the display and sorting of valid hole fits in typed-hole error messages. See Note [Valid hole fits include ...] in the GHC.Tc.Errors.Hole module.ghcThings you get with `-dlint`.vghcGet target profilevghc1Resolve any internal inconsistencies in a set of t. Returns the consistent t6 as well as a list of warnings to report to the user.vghc,Indicate if cost-centre profiling is enabledvghc1Indicate whether we need to generate source notesvghcShould we use `-XLinker -rpath` when linking or not? See Note [-fno-use-rpaths]vghc&Initialize the pretty-printing optionsvghcInitialize the pretty-printing options using the default user stylevghc/Pretty-print the difference between 2 DynFlags.For now only their general flags but it could be extended. Useful mostly for debugging.vghct to retrieve the options fromghc%Relevant record accessor: one of the opt_* accessorsghc#Correctly ordered extracted optionsvghcUpdated t-, left-over arguments, and list of warnings.vghcUpdated t-, left-over arguments, and list of warnings.vghcvalid flags to match againstghc current stateghcarguments to parseghc(leftovers, errors, warnings)vghcvalid flags to match againstghc(are the arguments from the command line?ghccurrent dynamic flagsghcarguments to parseghcTrue  = it should be turned onghcThe flag prefixghc!What to do when the flag is foundghc&Specification of this particular flagNNNNtttvvvvvvvvvvvvvvvvvvvvvvvvvvttttvvvvttttttttuutttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvssstttttttttttttttttvtttttttvttttttttttvttttttttttsssstttvvvvvvvvvvvvvvvvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>===========%%%%%%uuuuuuvvuuuuuuuuuuuuuuuuuuuuuuuuuuuvuvvvvvvvvvvvvvvvvvvvvtvvvvvttvvvvvvvvvvvvvvvvvv%vvvvvvvvvvsssssssssssssssvuuuuuuuuuvvvNNNNtttvvvvvvvvvvvvvvvvvvvvvvvvvvttttvvvvttttttttuutttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvssstttttttttttttttttvtttttttvttttttttttvttttttttttsssstttvvvvvvvvvvvvvvvvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>===========%%%%%%uuuuuuvvuuuuuuuuuuuuuuuuuuuuuuuuuuuvuvvvvvvvvvvvvvvvvvvvvtvvvvvttvvvvvvvvvvvvvvvvvv%vvvvvvvvvvsssssssssssssssvuuuuuuuuuvvv Safe-Inferred ' {ghcSubstitution on module variables, mapping module names to module identifiers.{ghc!The result of performing a lookup{ghc-Found the module uniquely, nothing else to do{ghc,Multiple modules with the same name in scope{ghcNo modules found, but there were some hidden ones with an exact name match. First is due to package hidden, second is due to module being hidden{ghcNo modules found, but there were some unusable ones with an exact name match{ghc6Nothing found, here are some suggested different namesghcFor each unit, a mapping from uid -> i indicates that this unit was brought into GHC by the ith  -package-db flag on the command line. We use this mapping to make sure we prefer units that were defined later on the command line, if there is an ambiguity.ghc'A reverse dependency index, mapping an   to the   s which have a dependency on it.{ghc"The reason why a unit is unusable.{ghcWe ignored it explicitly using -ignore-package.{ghcThis unit transitively depends on a unit that was never present in any of the provided databases.{ghcThis unit transitively depends on a unit involved in a cycle. Note that the list of   reports the direct dependencies of this unit that (transitively) depended on the cycle, and not the actual cycle itself (which we report separately at high verbosity.){ghc;This unit transitively depends on a unit which was ignored.{ghcThis unit transitively depends on a unit which was shadowed by an ABI-incompatible unit.{ghc Unit database{ghc A mapping of   to >>. This list is adjusted so that only valid units are here. >5 reflects what was stored *on disk*, except for the trusted flag, which is adjusted at runtime. (In particular, some units in this map may have the exposed flag be I.){ghcThe set of transitively reachable units according to the explicitly provided command line arguments. A fully instantiated VirtUnit may only be replaced by a RealUnit from this set. See Note [VirtUnit to RealUnit improvement]{ghc A mapping of > to  . If several units have the same package name (e.g. different instantiations), then we return one of them... This is used when users refer to packages in Backpack includes. And also to resolve package qualifiers with the PackageImports extension.{ghc7A mapping from database unit keys to wired in unit ids.{ghcA mapping from wired in unit ids to unit keys from the database.{ghcThe units we're going to link in eagerly. This list should be in reverse dependency order; that is, a unit is always mentioned before the units it depends on.{ghcUnits which we explicitly depend on (from a command line flag). We'll use this to generate version macros and the unused packages warning. The original flag which was used to bring the unit into scope is recorded for the -Wunused-packages warning.{ghcThis is a full map from   to all modules which may possibly be providing it. These providers may be hidden (but we'll still want to report them in error messages), or it may be an ambiguous import.{ghc A map, like {$, but controlling plugin visibility.{ghcA map saying, for each requirement, what interfaces must be merged together when we use them. For example, if our dependencies are p[A=] and q[A=,B=r[C=]:B]*, then the interfaces to merge for A are  p[A=]:A, q[A=,B=r[C=]:B]:A and  r[C=]:C.?There's an entry in this map for each hole in our home library.{ghc0Indicate if we can instantiate units on-the-fly.This should only be true when we are type-checking an indefinite unit. See Note [About units] in GHC.Unit.ghc Map from  & to a set of module providers (i.e. a   and its {).NB: the set is in fact a 'Map Module ModuleOrigin', probably to keep only one origin for a given  ghcUnit configurationghcPlatform arch and OSghc Ways to useghcAllow virtual units ^ Do we allow the use of virtual units instantiated on-the-fly (see Note [About units] in GHC.Unit). This should only be true when we are type-checking an indefinite unit (not producing any code).ghcName of the compiler (e.g. GHC, GHCJS). Used to fetch environment variables such as "GHC[JS]_PACKAGE_PATH".ghcPath to global DBghc%Main GHC dir: contains settings, etc.ghc$User DB name (e.g. "package.conf.d")ghc,Units to link automatically (e.g. base, rts)ghcDistrust all units by defaultghcHide all units by defaultghc!Hide all plugins units by defaultghcCache of databases to use, in the order they were specified on the command line (later databases shadow earlier ones). If Nothing, databases will be found using .ghcUnit databases flagsghc Exposed unitsghc Ignored unitsghc Trusted unitsghcPlugins exposed unitsghc< records the various aspects of visibility of a particular  .ghc-Any custom renamings that should bring extra  s into scope.ghc%The package name associated with the  4. This is used to implement legacy behavior where -package foo-0.1& implicitly hides any packages named fooghcThe signatures which are contributed to the requirements context from this unit ID.ghcWhether or not this unit was explicitly brought into scope, as opposed to implicitly via the exposed' fields in the package database (when -hide-all-packages is not passed.)ghc map from   to a .{ghcGiven a module name, there may be multiple ways it came into scope, possibly simultaneously. This data type tracks all the possible ways it could have come into scope. Warning: don't use the record functions, they're partial!{ghcModule is hidden, and thus never will be available for import. (But maybe the user didn't realize), so we'll still keep track of these modules.){ghc6Module is unavailable because the package is unusable.{ghc7Module is public, and could have come from some places.{ghc Just False) means that this module is in someone's exported-modules$ list, but that package is hidden;  Just True means that it is available; Nothing means neither applies.{ghcIs the module available from a reexport of an exposed package? There could be multiple.{ghc]:B maps to  p[A=q():A]:B with A=q():A; similarly,  maps to q():A.|ghcSubstitutes holes in a  , suitable for renaming when an include occurs; see Note [Representation of module/name variables].p[A=] maps to p[A=] with A=.|ghcLike |, but requires only ClosureUnitInfoMap so it can be used by GHC.Unit.State.|ghc(Like 'renameHoleUnit, but requires only ClosureUnitInfoMap so it can be used by GHC.Unit.State.|ghc Injects an  to   (see also |.|ghc9Print unit-ids with UnitInfo found in the given UnitState|ghc8Add package dependencies on the wired-in packages we useghc Home unit idghcHome unit instance ofghcHome unit instantiationsp>>>>>>>>>>>>>>>>>>>>>{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|{|{{|||{{{{{{{{{{{{{{{{{{{{{{{{|||{||||||{||||||{|{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|{|{{|||{{{{{{{{{{{{{{{{{{{{{{{{|||{||||||{||||||{| Safe-Inferred /&|ghc| summarises what was imported from where, irrespective of whether the imported things are actually used or not. It is used: when processing the export list,4when constructing usage info for the interface file,to identify the list of directly imported modules for initialisation purposes and for optimised overlap checking of family instances,/when figuring out what things are really unused|ghc'Domain is all directly-imported modules-See the documentation on ImportedModsVal in GHC.Unit.Module.Imported for the meaning of the fields.We need a full ModuleEnv rather than a ModuleNameEnv here, because we might be importing modules of the same name from different packages. (currently not the case, but might be in the future).|ghcHome-package modules directly imported by the module being compiled.|ghc5Packages directly needed by the module being compiled|ghcDo we require that our own package is trusted? This is to handle efficiently the case where a Safe module imports a Trustworthy module that resides in the same package as it. See Note [Trust Own Package] in GHC.Rename.Names|ghcThis records the packages the current module needs to trust for Safe Haskell compilation to succeed. A package is required to be trusted if we are dependent on a trustworthy module in that package. See Note [Tracking Trust Transitively] in GHC.Rename.Names|ghcDomain is all modules which have hs-boot files, and whether we should import the boot version of interface file. Only used in one-shot mode to populate eps_is_boot.|ghc Signature modules below this one|ghcOrphan modules below us in the import tree (and maybe including us for imported modules)|ghcFamily instance modules below us in the import tree (and maybe including us for imported modules)|ghcRecords modules for which changes may force recompilation of this module See wiki: https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidanceThis differs from Dependencies. A module X may be in the dep_mods of this module (via an import chain) but if we don't use anything from X it won't appear in our Usage|ghcModule from another package|ghcModule from the current package|ghcA file upon which the module depends, e.g. a CPP #include, or using TH's addDependentFile|ghc-A requirement which was merged into this one.|ghc#External package module depended on|ghc:Cached module ABI fingerprint (corresponds to mi_mod_hash)|ghc)Was this module imported as a safe import|ghcName of the module|ghc)UnitId of the HomeUnit the module is from|ghcEntities we depend on, sorted by occurrence name and fingerprinted. NB: usages are for parent names only, e.g. type constructors but not the associated data constructors.|ghcFingerprint for the export list of this module, if we directly imported it (and hence we depend on its export list)|ghcExternal file dependency. From a CPP #include or TH addDependentFile. Should be absolute.|ghc of the file contents.|ghcAn optional string which is used in recompilation messages if file in question has changed.|ghcThe *interface* hash of the module, not the ABI hash. This changes when anything about the interface (and hence the module) has changed.|ghcDependency information about ALL modules and packages below this one in the import hierarchy. This is the serialisable version of |.(Invariant: the dependencies of a module M never includes M.0Invariant: none of the lists contain duplicates.Invariant: lists are ordered canonically (e.g. using stableModuleCmp)1See Note [Transitive Information in Dependencies]|ghcAll home-package modules which are directly imported by this one. This may include modules from other units when using multiple home units|ghcAll packages directly imported by this module I.e. packages to which this module's direct imports belong. Does not include other home units when using multiple home units. Modules from these units will go in ||ghcAll units needed for plugins|ghc4Transitive closure of hsig files in the home package|ghcAll modules which have boot files below this one, and whether we should use the boot file or not. This information is only used to populate the eps_is_boot field. See Note [Structure of dep_boot_mods]|ghcTransitive closure of orphan modules (whether home or external pkg).(Possible optimization: don't include family instance orphans as they are anyway included in |. But then be careful about code which relies on dep_orphs having the complete list!) This does NOT include us, unlike |.|ghcTransitive closure of depended upon modules which contain family instances (whether home or external). This is used by checkFamInstConsistency%. This does NOT include us, unlike |9. See Note [The type family instance consistency story].|ghcExtract information from the rename and typecheck phases to produce a dependencies information for the module being compiled.0The fourth argument is a list of plugin modules.|ghcUpdate module dependencies containing orphans (used by Backpack)|ghcUpdate module dependencies containing family instances (used by Backpack)|ghcPretty-print unit dependencies*||||||||||||||||||||||||||||||||||||||||||*|||||||||||||||||||||||||||||||||||||||||| Safe-Inferred     p>>>>>>>>>>>>>>>>>>>>> {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|{{{{{{{{{{{{{{{|{|{{|||{|||||||||{|||||{|    Safe-Inferred [}ghc1Locations and information the finder cares about.Should be taken from DynFlags via initFinderOpts.}ghc9Where are we allowed to look for Modules and Source files}ghcWhen looking up a home module:L-: search interface files (e.g. in '-c' mode)I-: search source files (e.g. in '--make' mode)}ghcDon't check that an imported interface file actually exists if it can only be at one location. The interface will be reported as } even if the file doesn't exist, so this is only useful in specific cases (e.g. to generate dependencies with `ghc -M`)}ghcIf we encounter unknown modules, should we suggest modules that have a similar name.}ghc/The result of searching for an imported module.NB: FindResult manages both user source-import lookups (which can result in  ) as well as direct imports for interfaces (which always result in ).}ghcThe module was found}ghc The requested unit was not found}ghc"_Error_: both in multiple packages}ghc Not found}ghcPlaces where I looked}ghcJust p => module is in this unit's manifest, but couldn't find the .hi file}ghc7Module is in these units, but the *module* is hidden}ghc5Module is in these units, but the *unit* is hidden}ghc,Module is in these units, but it is unusable}ghcPossible mis-spelled modules}ghcThe } maps modules to the result of searching for that module. It records the results of searching for modules along the search path. On :load., we flush the entire contents of this cache.(}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}(}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-Inferred }ghc"A module name: search for the file}ghcA filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename.}ghcA compilation target.A target may be supplied with the actual text of the module. If so, use this instead of the file contents (this is for use in an IDE where the file hasn't been saved by the user yet).7These fields are strict because Targets are long lived.}ghcmodule or filename}ghcobject code allowed?}ghc%id of the unit this target is part of}ghcOptional in-memory buffer containing the source code GHC should use for this target instead of reading it from disk.Since GHC version 8.10 modules which require preprocessors such as Literate Haskell or CPP to run are also supported.If a corresponding source file does not exist on disk this will result in a  SourceError exception if targetId = TargetModule _! is used. However together with targetId = TargetFile _/ GHC will not complain about the file missing. }}}}}}}}}}}} }}}}}}}}}}}}4 Safe-Inferred < fghcIs this type variable a concrete type variable, i.e. it is a metavariable with w w?wghcThe Paterson size of a given type, in the sense of Note [Paterson conditions] in GHC.Tc.Validityafter expanding synonyms,2ignoring coercions (as they are not user written).wghc?The type mentions a type family, so the size could be anything.wghc(The type does not mention a type family.wghc#free tyvars, including repetitions;wghc)number of type constructors and variableswghcWhy was the LHS w# not strictly smaller than the RHS w?2See Note [Paterson conditions] in GHC.Tc.Validity.wghc#Either side contains a type family.wghcThe size of the LHS is not strictly less than the size of the RHS.wghcThese type variables appear more often in the LHS than in the RHS.wghc7Reason why a type cannot be marshalled through the FFI.wghc0Reason why a type in an FFI signature is invalidwghcWhat caused us to create a w? metavariable? See Note [ConcreteTv] in GHC.Tc.Utils.Concrete.wghcA w< used to enforce the representation-polymorphism invariants.See   for more information.wghcWhat restrictions are on this metavariable around unification? These are checked in GHC.Tc.Utils.Unify.startSolvingByUnification.wghcThis MetaTv is an ordinary unification variable A TauTv is always filled in with a tau-type, which never contains any ForAlls.wghcA variant of TauTv, except that it should not be unified with a type, only with a type variable See Note [TyVarTv] in GHC.Tc.Utils.TcMTypewghc6A unification variable used in the GHCi debugger. It is/ allowed to unify with a polytype, unlike TauTvwghcA unification variable that can only be unified with a concrete type, in the sense of Note [Concrete types] in GHC.Tc.Utils.Concrete. See Note [ConcreteTv] in GHC.Tc.Utils.Concrete. See also Note [The Concrete mechanism] in GHC.Tc.Utils.Concrete for an overview of how this works in context.wghcWhat to expect for an argument to a rebindable-syntax operator. Quite like , but allows for holes to be filled in by tcSyntaxOp. The callback called from tcSyntaxOp gets a list of types; the meaning of these types is determined by a left-to-right depth-first traversal of the w tree. So if you pass in >SynAny `SynFun` (SynList `SynFun` SynType Int) `SynFun` SynAny/you'll get three types back: one for the first w, the element) type of the list, and one for the last w". You don't get anything for the w, because you've said positively that it should be an Int, and so it shall be.You'll also get three multiplicities back: one for each function arrow. See also Note [Linear types] in Multiplicity.-This is defined here to avoid defining it in GHC.Tc.Gen.Expr boot file.wghcAny typewghc5A rho type, skolemised or instantiated as appropriatewghc6A list type. You get back the element type of the listwghc A function.wghc A known type.wghcLike w, but for an expected type.See w.wghcAn w which has a fixed RuntimeRep.For a w w , the stored w' must have a fixed RuntimeRep. For an w w, the w field must be of the form  Just frr_orig.wghcThis  is for debugging onlywghc5See Note [TcLevel of ExpType] in GHC.Tc.Utils.TcMTypewghcSee Note [FixedRuntimeRep context in ExpType] in GHC.Tc.Utils.TcMTypewghc-The type that fills in this hole should be a Type, that is, its kind should be TYPE rr for some rr :: RuntimeRep.Additionally, if the w field is  Just frr_orig then rr must be concrete, in the sense of Note [Concrete types] in GHC.Tc.Utils.Concrete.wghcAn expected type to check against during type-checking. See Note [ExpType] in GHC.Tc.Utils.TcMType&, where you'll also find manipulators.wghcA w is a w# which has a syntactically fixed A in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.In particular, this means that:[ does not panic,5 does not return J.0This property is important in functions such as matchExpectedFunTys, where we want to provide argument types which have a known runtime representation. See Note [Return arguments with a fixed RuntimeRep.wghcA type which has a syntactically fixed RuntimeRep as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.wghcMake an w suitable for checking.wghcLike w but accepts a regular TcTypewghcLike mkFunTys but for wwghcFinds outermost type-family applications occurring in a type, after expanding synonyms. In the list (F, tys) that is returned we guarantee that tys matches F's arity. For example, given type family F a :: * -> * (arity 1) calling tcTyFamInsts on (Maybe (F Int Bool) will return (F, [Int]), not (F, [Int,Bool])This is important for its use in deciding termination of type instances (see #11581). E.g. type instance G [Int] = ...(F Int )... we don't need to take into account when asking if the calls on the RHS are smaller than the LHSwghcLike w, except that the output records whether the type family and its arguments occur as an  invisible argument in some type application. This information is useful because it helps GHC know when to turn on -fprint-explicit-kinds during error reporting so that users can actually see the type family being mentioned.As an example, consider: class C a data T (a :: k) type family F a :: k instance C (T @(F Int) (F Bool)) -There are two occurrences of the type family F in that C instance, so w (C (T @(F Int) (F Bool))) will return: [ (L, F, [Int]) , (I, F, [Bool]) ] F Int is paired with L since it appears as an  invisible argument to C , whereas F Bool is paired with I since it appears an a visible argument to C. See also 'Note [Kind arguments in error messages] in  GHC.Tc.Errors.wghcIn an application of a  to some arguments, find the outermost occurrences of type family applications within the arguments. This function will not consider the 4 itself when checking for type family applications.See w for more details on how this works (as this function is called inside of w).wghcCheck that a type does not contain any type family applications.xghcIs this type variable a concrete type variable, i.e. it is a metavariable with w w? Returns the w( stored in the type variable if so, or J otherwise.xghc?Is this type concrete type variable, i.e. a metavariable with w w?xghcIs this type a concrete type variable? If so, return the associated  and w.xghcReturns the (kind, type) variables in a type that are as-yet-unknown: metavariables and RuntimeUnksxghc-Make a sigma ty where all type variables are &>. That is, they cannot be used with visible type application.xghcMake a sigma ty where all type variables are "specified". That is, they can be used with visible type applicationxghc$Splits a forall type into a list of &s and the inner type. Always succeeds, even if it returns an empty list.xghc;Splits a type into a PiTyVarBinder and a body, if possible.xghcLike x, but splits off only named binders, returning just the tyvars.xghcLike x, but only splits Cs with & type variable binders.xghcLike x, but only splits a C if argf_pred argf is L, where argf is the visibility of the ForAllTy's binder and  argf_pred is a predicate over visibilities provided as an argument to this function.xghcLike x, but only splits Cs with &= type variable binders. All split tyvars are annotated with ().xghcLike x, but only splits Cs with & type variable binders. All split tyvars are annotated with their .xghcLike x$, but splits off only named binders.xghc4Split a sigma type into its parts. This only splits  invisible type variable binders, as these are the only forms of binder that the typechecker will implicitly instantiate.xghcSplit a sigma type into its parts, going underneath as many arrows and foralls as possible. See Note [tcSplitNestedSigmaTys]xghcLike tcRepSplitTyConApp_maybe, but only returns the .xghcSplit off exactly the specified number argument types Returns (Left m) if there are m missing arrows in the type (Right (tys,res)) if the type looks like t1 -> ... -> tn -> resxghc?Strips off n *visible* arguments and returns the resulting typexghcLike x, but also says L for w typesghc&Check whether the type is of the form Any :: k, returning the kind k.xghc8Is the type inhabited by machine floating-point numbers?Used to check that we don't use floating-point literal patterns in Core.See #9238 and Note [Rules for floating-point comparisons] in GHC.Core.Opt.ConstantFold.xghc Is a type :?ghc&Check validity for a type of the form Any :: k.This function returns: Just IsValid for  Any :: Type and Any :: UnliftedType,Just (NotValid ..) for Any :: k if k is not a kind of boxed types,Nothing if the type is not Any.xghcFor every arg a tycon can take, the returned list says True if the argument is taken visibly, and False otherwise. Ends with an infinite tail of Trues to allow for oversaturation.xghcIf the tycon is applied to the types, is the next argument visible?xghc2Should this type be applied to a visible argument?xghcltPatersonSize ps1 ps2 returns:Nothing iff ps1% is definitely strictly smaller than ps2, Just ps_fail otherwise; ps_fail says what went wrong.xghcWhen this says True, ignore this class constraint during a termination check See (PS1) in Note [The PatersonSize of a type]wghcno duplicates in this listwghc Expected typeghc Actual typeghc7Is this an invisible argument to some type application?ghc7Is this an invisible argument to some type application?wwwwwwwwwwwwwwwwwwwwwwCwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxFxxxwwxxxxxxxxxxxxxxxxxxxxxxxxF'FxxxxxxxxxxxxxxxxxGGxxxxxxFxxxxxxxxxxxxxxxxxGAx'xxxxHHHHHHHHHHHHHxccccxxxxxxxxxwwwwwxwwwwwwwwwwwwwwwwwwwxxxxxxxxxxwwwwwwwwwxxxxxxxxxxxwxxExx##'FG&&&&&&&&&CCGGGGGCCCCCC''FACCCCRRRRRRxxxxFG''EEEEEFFEFEEFFFFFFFFEEEFFFFFFFFFFFFFFFFGGG'EEEEEEEEEELLLLLLLLLLxxxwwwwwwwwwwwwwwwwwwwwwwCwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxFxxxwwxxxxxxxxxxxxxxxxxxxxxxxxF'FxxxxxxxxxxxxxxxxxGGxxxxxxFxxxxxxxxxxxxxxxxxGAx'xxxxHHHHHHHHHHHHHxccccxxxxxxxxxwwwwwxwwwwwwwwwwwwwwwwwwwxxxxxxxxxxwwwwwwwwwxxxxxxxxxxxwxxExx##'FG&&&&&&&&&&&CCGGGGGCCCCCC''FACCCCRRRRRRxxxxFG''EEEEEFFEFEEFFFFFFFFEEEFFFFFFFFFFFFFFFFGGG'EEEEEEEEEELLLLLLLLLLxxxw0 Safe-Inferred7fyghcWhere to store evidence for expression holes See Note [Holes] in GHC.Tc.Types.Constraintyghc Evidence for  CallStack implicit parameters.yghcEvCsPushCall origin loc stk represents a call from origin, occurring at loc, in a calling context stk.yghcInstructions on how to make a Typeable0 dictionary. See Note [Typeable evidence terms]yghcDictionary for  Typeable T where T is a type constructor with all of its kind variables saturated. The [EvTerm] is Typeable" evidence for the applied kinds..yghcDictionary for Typeable (s t), given a dictionaries for s and t.yghcDictionary for Typeable (s % w -> t), given a dictionaries for w, s, and t.yghc%Dictionary for a type literal, e.g. Typeable "foo" or  Typeable 3 The y is evidence of, e.g.,  KnownNat 3 (see #10348)yghcIf a ! is !$, flip the orientation of a coercionyghcSmart constructor to create a y y.PRECONDITION: the "from" type of the first wrapper must have a syntactically fixed RuntimeRep (see Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete).yghcIdentifies the  lambda-bound dictionaries of an y. This is used (only) to allow the pattern-match overlap checker to know what Given dictionaries are in scope.7We specifically do not collect dictionaries bound in a y. These are either superclasses of lambda-bound ones, or (extremely numerous) results of binding Wanted dictionaries. We definitely don't want all those cluttering up the Given dictionaries for pattern-match overlap checking!yghc,Any sort of evidence Id, including coercionsyghcd |> cozghc Create a  that unwraps an implicit-parameter dictionary to expose the underlying value. We expect the - to have the form `IP sym ty`, and return a  `co :: IP sym ty ~ ty`zghc Create a > that wraps a value in an implicit-parameter dictionary. See z.zghcConvert the QuoteWrapper into a normal HsWrapper which can be used to apply its contents.zghc-The Semigroup instance is a bit fishy, since  WpCompose, as a data constructor, is "syntactic" and not associative. Concretely, if a, b, and c aren't WpHole: (a <> b) <> c ?= a <> (b <> c)> (a `WpCompose` b) `WpCompose` c /= @ a `WpCompose` (b `WpCompose` c)However these two associations are are "semantically equal" in the sense that they produce equal functions when passed to GHC.HsToCore.Binds.dsHsWrapper.yghc&where to write the erroring expressionghc expected type of that expressionghcfor debug output onlyyghcthe "from" type of the first wrapper MUST have a fixed RuntimeRepghcEither "from" type or "to" type of the second wrapper (used only when the second wrapper is the identity)yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyByyy!!!!yzzyyzzyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyByyy!!!!yzzyyzz Safe-Inferred/7I~ghc!Type checker Specification Pragma~ghcThe Id to be specialised, a wrapper that specialises the polymorphic function, and inlining spec for the specialised function~ghc*Located Type checker Specification Pragmas~ghc#Type checker Specialisation Pragmas~ conveys  SPECIALISE/ pragmas from the type checker to the desugarer~ghcSuper-specialised: a default method should be macro-expanded at every call site~ghcA type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying binding~ghcAbstraction Bindings Export~ghc(Any INLINE pragma is attached to this Id~ghcSee Note [ABExport wrapper] Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly~ghcSPECIALISE pragmas~ghcTypechecked, generalised bindings, used in the output to the type checker. See Note [AbsBinds].~ghcIncludes equality constraints~ghcAbsBinds only gets used when idL = idR after renaming, but these need to be idL's for the collect... code in HsUtil to have the right type~ghc#Evidence bindings Why a list? See GHC.Tc.TyCl.Instance4 Note [Typechecking plan for instance declarations]~ghcTypechecked user bindings~ghc7Extracts the name for a SPECIALIZE instance pragma. In ~, the src field of U signature contains the SourceText for a SPECIALIZE instance pragma of the form: "SourceText {-# SPECIALIZE"Extraction ensures that all variants of the pragma name (with a Z or an S+) are output exactly as used in the pragma.~ghcUsing SourceText in case the pragma was spelled differently or used mixed caseghcAfter the type-checker, the FunBind extension field contains the ticks to put on the rhs, if any, and a coercion from the type of the MatchGroup to the type of the Id. Example: 1 f :: Int -> forall a. a -> a f x y = y Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'.ghcAfter the renamer (but before the type-checker), the FunBind extension field contains the locally-bound free variables of this defn. See Note [Bind free vars]UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~8~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Safe-Inferred/7$ ghcThe locations of forall and k for forall'd type vars Using AddEpAnn to capture possible unicode variantsghcThe locations of forall and k for forall'd term vars Using AddEpAnn to capture possible unicode variantsghcdoes this have a CUSK? See Note [CUSKs: complete user-supplied kind signatures]ghcPartition a list of HsDecls into function/pattern bindings, signatures, type family declarations, type family instances, and documentation comments.Panics when given a declaration that cannot be put into any of the output groups.2The primary use of this function is to implement .ghcThe fixity signatures for each top-level declaration and class method in an W7. See Note [Top-level fixity signatures in an HsGroup]ghcDoes this declaration have a complete, user-supplied kind signature? See Note [CUSKs: complete user-supplied kind signatures]ghc-Maybe return name of the result type variableghcA short description of a DerivStrategy'.ghcReturn K fields> if a data constructor declaration uses record syntax (i.e., S ), where fields- are the field selectors. Otherwise, return J.ghc Convert a W to a @ghc Eliminate a V.ghc Map over the via type if dealing with V. Otherwise, return the V unchanged.XXXXXXXXXXXXXXXXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXWWWWWWWWWWWWWWWVVVVVVVVVVVVWWWWVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVVVVWWWWWWWVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWVVVVVVVVVVXUVVVVVVVVVUUUUUUUUXUUUUWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXWWWWWWWWWWWWWWWVVVVVVVVVVVVWWWWVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVVVVWWWWWWWVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWVVVVVVVVVVXUVVVVVVVVVUUUUUUUUXUUUUWWWWWWWWWWWWWWWWWWWXXXXXXX Safe-Inferred "-,ghcA No Op, used for primops the JS platform cannot or do not support. For example, the prefetching primops do not make sense on the JS platform because we do not have enough control over memory to provide any kind of prefetching mechanism. Hence, these are NoOps.ghc lifted arraysªghc Profiling (cost-centres) enabledghcArray bounds-checking enabledghcthe primitive operationghcwhere to store the resultghc argumentsghcShould we do bounds checking?ghcArrayghcIndexghcResultªª Safe-Inferred"1 êghc%Number of slots occupied by a PrimRepǪghc;can we unbox C x to x, only if x is represented as a NumberȪghcone-constructor types with one primitive field represented as a JS Number can be unboxedɪghcReturn SlotCount as an Intʪghc:Number of slots occupied by a value with the given VarTypeѪghc/can we pattern match on these values in a case?تghc'Find the primitive representation of a . Defined here to avoid module loops. Call this only on unlifted tycons.٪ghcTake a kind (of shape TYPE rr) and produce the @#s of values of types of this kind.ghcAssociate the given values to each RrimRep in the given order, taking into account the number of slots per PrimRepghcAssociate the given values to the Id's PrimReps, taking into account the number of slots per PrimRepghcAssociate the given JExpr to the Id's PrimReps, taking into account the number of slots per PrimRepghcReturn False only if we are *sure* it's a data type Look through newtypes etc as much as possible&êƪŪĪǪȪɪʪ˪̪ͪΪϪЪѪҪӪԪժ֪תت٪ڪ۪ܪݪުߪ&ǪȪêƪŪĪɪʪ˪̪ͪΪϪЪѪҪӪԪժ֪תت٪ڪ۪ܪݪުߪ Safe-Inferred 6ghc(Unfloat some top-level unexported thingsGHC floats constants to the top level. This is fine in native code, but with JS they occupy some global variable name. We can unfloat some unexported things:global constructors, as long as they're referenced only once by another global constructor and are not in a recursive binding groupliterals (small literals may also be sunk if they are used more than once)ghcalways sinkable, values that may be duplicated in the generated code (e.g. small literals)ghc5once sinkable: may be sunk, but duplication is not okghccollect all idents used only once in an argument at the top level and never anywhere elseghcfold over all id in StgArg used at the top level in an StgRhsConghc%fold over all Id in StgArg in the ASTghcsince we have sequential initialization, topsort the non-recursive constructor bindingsghcthe module, since we treat definitions from the current module differentlyghc the bindingsghca map with sunken replacements for nodes, for where the replacement does not fit in the k AST and the new bindings"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith 2experimental Module to deal with JS identifiers Safe-Inferred?.ghcGet fresh unique numberghc6Get fresh local Ident of the form: h$$unit:module_uniqghc2Generate unique Ident for the given ID (uncached!)"The ident has the following forms:global Id: h$unit:module.name[_num][_type_suffix] local Id: h$$unit:module.name[_num][_type_suffix]_uniqRetrieve default variable name for the given Id with sub indexghc)Retrieve all the JS vars for the given Idghc-Retrieve entry variable name for the given Idghc5Retrieve datacon entry variable name for the given IdghcRetrieve datacon worker entry variable name for the given dataconghcRetrieve datacon worker entry variable name for the given dataconghcDeclare all js vars for the id"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred"M^ghcRun the action, m, with no stack infoghcrun the action, m, with current stack info, but don't let modifications propagateghcSet stack depthghcGet stack depthghcModify stack depthghcoverwrite our stack knowledgeghc$retrieve our current stack knowledgeghcModify stack slotsghcadd n% unknown slots to our stack knowledgeghc#add knowledge about the stack slotsghcdrop n slots from our stack knowledgeghcGrow the stack pointer by n without modifying the stack depth. The stack is just a JS array so we add to grow (instead of the traditional subtract)ghcShrink the stack pointer by n'. The stack grows downward so substractghc(Wrapper which adjusts the stack pointer and& modifies the stack depth tracked in  . See also 5 which actually does the stack pointer manipulation.ghcShrink the stack and stack pointer. NB: This function is unsafe when the input n*, is negative. This function wraps around # which actually performs the work.ghcA constant array that holds global function symbols which do N pushes onto the stack. For example:  function h$p1(x1) { ++h$sp; h$stack[(h$sp - 0)] = x1; }; function h$p2(x1, x2) { h$sp += 2; h$stack[(h$sp - 1)] = x1; h$stack[(h$sp - 0)] = x2; }; and so on up to 32.ghc Convert all function symbols in  to global top-level functions. This is a hack which converts the function symbols to variables. This hack is caught in & to turn these into global functions.ghcPartial Push functions. Like 8 except these push functions skip slots. For example,  function h$pp33(x1, x2) { h$sp += 6; h$stack[(h$sp - 5)] = x1; h$stack[(h$sp - 0)] = x2; }; The 33rd entry skips slots 1-4 to bind the top of the stack and the 6th slot. See  and  for use cases.ghcLike # but for the partial push functionsghcoptimized push that reuses existing values on stack automatically chooses an optimized partial push (h$ppN) function when possible.ghc)push a let-no-escape frame onto the stackghc0Pop things, don't update the stack knowledge in ghcLoad 'length (xs :: [JExpr])' things from the stack at offset 'n :: Int'. This function does no stack pointer manipulation, it merely indexes into the stack and loads payloads into xs.ghc"Pop but preserve the first N slotsghc Just like  but operate on s rather than ڡghcBlindly pop N slotsghc?Generate statements to update the current node with a blackholeghcWrapper around =, performs the stack manipulation before updating the Thunk.ghcUpdate a thunk by checking . If the config inlines black holes then update inline, else make an explicit call to the black hole handler.ghc:contents of the slots, True if same value is already thereghcnumber of slots to skipghc!assign stack slot values to these Safe-Inferred"Oaghc%Generate JS expressions for a LiteralLiterals represented with 2 values: * Addr# (Null and Strings): array and offset * 64-bit values: high 32-bit, low 32-bit * labels: call to h$mkFunctionPtr and 0, or function name and 0ghc-generate a literal for the static init tables"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-InferredQghcUnique Module -> Unitghc;Unique Id -> Object.ExportedFun (only to other modules)ghcGenerate module dependency dataGenerate the object's dependency data, taking care that package and module names are only stored once Safe-Inferred "%&U ghc5Used to pass arguments to newClosure with some safetyghcdebug: output symbol namesghcthe object nameghcthings in registersghclayout of the objectghc closure typeghcobject name, for printingghca) argument, depends on type (arity, conid)ghc static refs ghcdebug: output all symbol namesghcthe thing to modifyghc closure typeghcobject name, for printingghclist of item types in the object, if known (free variables, datacon fields)ghcextra a( parameter, for constructor tag or arityghc,object size, -1 (number of vars) for unknownghcthings in registersghc static refsghcobject being info'd see ciVar in  ClosureInfoghcrhs"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith 4experimental Code generation of data constructors Safe-Inferred"YghcGenerate a data constructor. Special handling for unboxed tuplesghcAllocate a data constructor. Allocate in this context means bind the data constructor to toghcAllocate an unboxed data constructor. If we have a bool we calculate the right value. If not then we expect a singleton list and unbox by converting ''C x' to x. NB. This function may panic.ghc Allocate an entry function. See  for the object layout.ghcAllocate a dynamic objectghc csInlineAlloc from StgToJSConfig"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith 8experimental Code generation of application arguments Safe-Inferred\ ghc%Generate JS code for static argumentsghcGenerate JS code for an StgArgghcGenerate a Var as JExprghcGenerate an Id as an Identghc&Generate IDs for stack arguments. See  for use caseghcAllocate Static ConstructorsghcAllocate unboxed constructorsghcAllocate Static listghc.Generate JS code corresponding to a static argghc7Generate JS code corresponding to a list of static args   Safe-Inferred "^ghcgenerate the actual callghc6catch exception and convert them to haskell exceptionsghc/async (only valid with javascript calling conv)ghc#using javascript calling conventionghcasyncghcusing JavaScript calling convghc)Nothing for sync, Just callback for asyncghc"javascript calling convention usedghcpattern calledghc return typeghc5expressions to return in (may be more than necessary)ghc arguments"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred "-mghcApply specificationghcCalling conventionghcnumber of Haskell argumentsghc0number of JavaScript variables for the argumentsghc(Calling convention for an apply functionghc&Fast calling convention: use registersghc&Slow calling convention: use the stackghcPre-generated functions for fast Apply. These are bundled with the RTS.ghc.Generate an application of some args to an Id.The case where args is null is common as it's used to generate the evaluation code for an Id.ghcTry to use a specialized pre-generated application function. If there is none, use h$ap_gen_fast insteadghc"Name of the generic apply functionghc"Expr of the generic apply functionghcReturn the name of the specialized apply function for the given number of args, number of arg variables, and calling convention.ghcReturn the expression of the specialized apply function for the given number of args, number of arg variables, and calling convention.Warning: the returned function may not be generated! Use specApplyExprMaybe if you want to ensure that it exists.ghcReturn the expression of the specialized apply function for the given number of args, number of arg variables, and calling convention. Return Nothing if it isn't generated.ghcMake an ApplySpec from a calling convention, a list of Haskell args, and a list of corresponding JS variablesghc7Find a specialized application function if there is oneghc,List of specialized apply function templatesghc&Generate a tag for the given ApplySpec=Warning: tag doesn't take into account the calling conventionghc1Generate a tag expression for the given ApplySpecghc.Build arrays to quickly lookup apply functionsh$apply[r << 8 | n] = function application for r regs, n args h$paps[r] = partial application for r registers (number of args is in the object)ghc Push a continuation on the stackFirst push the given args, then push an apply function (specialized if possible, otherwise the generic h$ap_gen function).ghcGeneric stack apply function (h$ap_gen) that can do everything, but less efficiently than other more specialized functions.Stack layout: -3: ... -2: args -1: tag (number of arg slots << 8 | number of args)Regs: R1 = applied closureghcGeneric fast apply function (h$ap_gen_fast) that can do everything, but less efficiently than other more specialized functions.3Signature tag in argument. Tag: (regs << 8 | arity) Regs: R1 = closure to apply toghc7Make specialized apply function for the given ApplySpecghc=Make specialized apply function with Stack calling conventionghcthe function to call (Left for generic, Right for specialized)ghcid of the pap objectghc0the function that's called (can be a second pap)ghcnumber of arguments in papghc!values for the supplied arguments"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred"xghc;The garbageCollector resets registers and result variables.ghcReset the register r in JS Land. Note that this "resets" by setting the register to a dummy variable called "null", not by setting to JS's nil value.ghcReset the return variable r in JS Land. Note that this "resets" by setting the register to a dummy variable called "null", not by setting to JS's nil value.ghcDefine closures based on size, these functions are syntactic sugar, e.g., a Haskell function which generates some useful JS. Each Closure constructor follows the naming convention h$cN, where N is a natural number. For example, h$c (with the nat omitted) is a JS Land Constructor for a closure in JS land which has a single entry function f, and no fields; identical to h$c0. h$c1 is a JS Land Constructor for a closure with an entry function f , and a single field x1, 'Just foo' is an example of this kind of closure. h$c2 is a JS Land Constructor for a closure with an entry function and two data fields: x1 and x2. And so on. Note that this has JIT performance implications; you should use h$c1, h$c2, h$c3, ... h$c24 instead of making objects manually so layouts and fields can be changed more easily and so the JIT can optimize better.ghc3JS Payload to perform stack manipulation in the RTSghc#JS payload to declare the registersghc:JS payload to define getters and setters on the registers.ghc;JS payload that defines the functions to load each registerghcAssign registers R1 ... Rn in descending order, that is assign Rn first. This function uses the 7 array to construct functions which set the registers.ghcJS payload which defines an array of function symbols that set N registers from M parameters. For example, h$l2 compiles to:  function h$l4(x1, x2, x3, x4) { h$r4 = x1; h$r3 = x2; h$r2 = x3; h$r1 = x4; }; ghc'JS payload to declare return variables.ghc'JS payload defining the types closures.ghc'JS payload declaring the RTS functions.ghc"print the embedded RTS to a Stringghc'print the RTS declarations to a String.ghc2Wrapper over the RTS to guarentee saturation, see ghc*JS Payload which defines the embedded RTS."(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)Jeffrey Young Luite Stegeman Sylvain Henry Josh Meredith .experimental Code generation of Expressions Safe-Inferred "9#ghcA  represents a possible branching path of an Stg case statement, i.e., a possible code path from an kghcEvaluate an expression in the given expression context (continuation)ghc)regular let binding: allocate heap objectghcGenerate let-no-escape entryLet-no-escape entries live on the stack. There is no heap object associated with them.A let-no-escape entry is called like a normal stack frame, although as an optimization, [] is not set when making the call. This is done later if the thread needs to be suspended.)Updatable let-no-escape binders have one private slot in the stack frame. This slot is initially set to null, changed to h$blackhole when the thunk is being evaluated.ghc/Generate the entry function for a local closureghcGenerate the entry function types for identifiers. Note that this only returns either  or . Everything else (PAP Blackhole etc.) is filtered as not a RuntimeRepKinded type.ghcGenerate the body of an objectghcFind the result type after applying the function to the arguments$It's trickier than it looks because: we don't have the Arity of the Id. The following functions return different values in some cases: - idArity - typeArity . idType - idFunRepArity - typeArity . unwrapType . idType Moreover the number of args may be different than all of these aritiessometimes the type is Any, perhaps after some unwrapping. For example HappyAbsSyn is a newtype around HappyAny which is Any or (forall a. a).Se we're left to use the applied arguments to peel the type (unwrapped) one arg at a time. But passed args are args after unarisation so we need to unarise every argument type that we peel (using typePrimRepArgs) to get the number of passed args consumed by each type arg.In case of failure to determine the type, we default to LiftedRep as it's probably what it is.ghc-Ensure that the set of identifiers has valid A's. This function returns a no-op when  in  is False.ghcGiven a set of  s, bind each  to the appropriate data fields in N registers. This assumes these data fields have already been populated in the registers. For the empty, singleton, and binary case use register 1, for any more use as many registers as necessary.ghc'Pop a let-no-escape frame off the stackghcGenerate an updated given an ghcBlackhole single entryOverwrite a single entry object with a special thunk that behaves like a black hole (throws a JS exception when entered) but pretends to be a thunk. Useful for making sure that the object is not accidentally entered multiple timesghcReorder the things we need to push to reuse existing stack values as much as possible True if already on the stack at that locationghcAllocate local closuresghcConsume Stg case statement and generate a case statement. See also ghcConsume an Stg case alternative and generate the corresponding alternative in JS land. If one alternative is a continuation then we must normalize the other alternatives. See  and .ghcIf  is set, then generate an assertion that asserts the pattern match is valid, e.g., the match is attempted on a Boolean, a Data Constructor, or some number.ghcIf one branch ends in a continuation but another is inline, we need to adjust the inline branch to use the continuation conventionghcLoad an unboxed tuple. Loading means getting all Idents from the input ID's, declaring them as variables in JS land and binding them, in order, to es.ghc4Switch for pattern matching on constructors or primsghcif/else for pattern matching on things that js cannot switch on the list of branches is expected to have the default alternative first, if it existsghc-Wrapper to contruct sequences of (===), e.g., mkEq [l0,l1,l2] [r0,r1,r2] = (l0 === r0) && (l1 === r1) && (l2 === r2)ghc"Generate a primitive If-expressionghc Load parameters from constructorghcDetermine if a branch will end in a continuation or not. If not the inline branch must be normalized. See  NB. not a Monoidghc*Push return arguments onto the stack. The 9 tracks whether the value is already on the stack or not, used in .ghc2Load the return arguments then pop the stack frameghc8allocate multiple, possibly mutually recursive, closuresghcGenerate a primop. This function wraps around the real generator , handling the 1 and all arguments before generating the primop.ghcA list of stack slots. -- Id: stored on the slot -- Int: the part of the value that is stored -- Bool: True when the slot already contains a valueghc"lhs to assign expression result toghcid being matchedghctypeghc3if known, fields in datacon from earlier expressionghcthe alternativesghctoplevel id for the resultghcdatacon to matchghcmatch alternative with binders Safe-Inferred֫ghc6Printed C Type to be used with CAPI calling conventionӫԫի֫ӫԫի֫ Safe-Inferred7OghcCollect class instance matches, including matches that we know are overridden but might still be useful to override other instances (which we call "guards").'See Note [Instance overlap and guards].ghcMinimal matches: we have knocked out all strictly more general matches that are overlapped by a match in this list.ghcGuards: matches that we know we won't pick in the end, but might still be useful for ruling out other instances, as per #20946. See Note [Instance overlap and guards], (A).zghcSet of visible orphan modules, according to what modules have been directly imported. This is based off of the dep_orphs field, which records transitively reachable orphan modules (modules that define orphan instances).zghcz represents the combination of the global type class instance environment, the local type class instance environment, and the set of transitively reachable orphan modules (according to what modules have been directly imported) used to test orphan instance visibility.zghcA type-class instance. Note that there is some tricky laziness at work here. See Note [ClsInst laziness and the rough-match fields] for more details.zghc Class namezghcTop of type args The class itself is always the first element of this listzghcis_dfun_name = idName . is_dfun.We use z for the visibility check, {, which needs to know the   which the dictionary is defined in. However, we cannot use the   attached to { since doing so would mean we would potentially pull in an entire interface file unnecessarily. This was the cause of #12367.{ghcA fuzzy comparison function for class instances, intended for sorting instances before displaying them to the user.{ghcCollects the names of concrete types and type constructors that make up the head of a class instance. For instance, given `class Foo a b`:`instance Foo (Either (Maybe Int) a) Bool` would yield [Either, Maybe, Int, Bool].Used in the implementation of ":info" in GHCi.The x is because of instance Foo a => Baz T where ... The decl is an orphan if Baz and T are both not locally defined, even if Foo *is* locally defined{ghcTest if an instance is visible, by checking that its origin module is in z2. See Note [Instance lookup and orphan instances]{ghcChecks for an exact match of ClsInst in the instance environment. We use this when we do signature checking in  GHC.Tc.Module{ghc/Makes no particular effort to detect conflicts.{ghcTrue when when the instance heads are the same e.g. both are Eq [(a,b)] Used for overriding in GHCi Obviously should be insensitive to alpha-renaming{ghcLook up an instance in the given instance environment. The given class application must match exactly one instance and the match may not contain any flexi type variables. If the lookup is unsuccessful, yield 'Left errorMessage'.{ghcSee Note [Rules for instance lookup] ^ See Note [Safe Haskell Overlapping Instances] in  GHC.Tc.Solver ^ See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.SolverghcRemove from the argument list any InstMatches for which another element of the list is more specific, and overlaps it, using the rules of Nove [Rules for instance lookup]ghcComputes whether the first class instance overrides the second, i.e. the first is more specific and can overlap the second.More precisely, instA  instB returns L precisely when:instA is more specific than instB,instB is not more specific than instA,instA is overlapping OR instB is overlappable.ghcAdd a new solution, knocking out strictly less specific ones See Note [Rules for instance lookup] and Note [Instance overlap and guards].Property/: the order of insertion doesn't matter, i.e. ;insert_overlapping inst1 (insert_overlapping inst2 matches) gives the same result as ;insert_overlapping inst2 (insert_overlapping inst1 matches).{ghcthe name of the classghc)the rough match signature of the instanceghcthe  of the dictionary bindingghcthe  of the dictionary.ghcmay this instance overlap?ghcis this instance an orphan?&zzzzz{{!!!!!!!!!!!zz{zzzzz{{{z{{{{{{{{{{{{zzzzzzz{{{{{{{{{{{{{{{{{{{{LL{{{&zzzzz{{!!!!!!!!!!!zz{zzzzz{{{z{{{{{{{{{{{{zzzzzzz{{{{{{{{{{{{{{{{{{{{LL{{{ Safe-Inferred{ghcThe {/ is essentially a cache for information in the ModIface for home modules only. Information relating to packages will be loaded into global environments in ExternalPackageState.{ghcLocal type environment for this particular module Includes Ids, TyCons, PatSyns{ghcDFunId"s for the instances in this module{ghcDomain may include Ids from other modules{ghcAnnotations present in this module: currently they only annotate things also declared in this module{ghc&Complete match pragmas for this module{ghcConstructs an empty ModDetails {{{{{{{{{{ {{{{{{{{{{ Safe-Inferred9w@@ Safe-Inferredghc.Do we force the result to be representational?ghcDo we apply a sym to the result?zghcCoercion optimisation optionszghc.Enable coercion optimisation (reduce its size)zghcoptCoercion applies a substitution to a coercion, *and* optimises it to reduce its sizeghcOptimize a coercion, making no assumptions. All coercions in the lifting context are already optimized (and sym'd if nec'y)ghcOptimize a coercion, knowing the coercion's role. No other assumptions.ghc=Optimize a coercion, knowing the coercion's non-Phantom role.ghc Optimize a non-phantom coercion.ghc Optimize a non-phantom coercion.ghcOptimize a phantom coercion. The input coercion may not necessarily be a phantom, but the output sure will be.zghcCheck to make sure that an AxInstCo is internally consistent. Returns the conflicting branch, if it exists See Note [Conflict checking with AxiomInstCo]ghc/Conditionally set a role to be representationalghcIf we require a representational role, return that. Otherwise, return the "default" role provided.ghcThe role of the input coercionghc current roleghc"default" rolezzzzzzzzzz Safe-Inferred% Safe-InferredghcEnable process jobs support on Windows if it can be expected to work (e.g. process >= 1.6.9.0).ghc Version of &System.Process.readProcessWithExitCode> that takes a key-value tuple to insert into the environment.ghcRun a command, placing the arguments in an external response file.This command is used in order to avoid overlong command line arguments on Windows. The command line arguments are first written to an external, temporary response file, and then passed to the linker via @filepath. response files for passing them in. See: 'https://gcc.gnu.org/wiki/Response_Files /https://gitlab.haskell.org/ghc/ghc/issues/10777ghcBreak a line of an error message into a filename and the rest of the line, taking care to ignore colons in Windows drive letters (as noted in #17786). For instance, "hi.c: ABCD" is mapped to Just ("hi.c", "ABCD")"C:\hi.c: ABCD" is mapped to Just ("C:\hi.c", "ABCD")ghcstdoutghc program pathghc program argsghcaddition to the environmentghc(exit_code, stdout, stderr) Safe-Inferredghc,Grab compiler info and cache it in DynFlags.ghc-Grab assembler info and cache it in DynFlags. Safe-Inferred]ghcPrepend the working directory to the search path. Note [Filepaths and Multiple Home Units]ghcRun compiler of C-like languages and raw objects (such as gcc or clang).ghc8Run the linker with some arguments and return the outputghcRun the LLVM OptimiserghcRun the LLVM CompilerghcRun the clang compiler (used as an assembler for the LLVM backend on OS X as LLVM doesn't support the OS X system assembler)ghc
Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred" ghc-Retrieve library directories provided by the UnitId in  UnitStateghc0Retrieve the names of the libraries provided by UnitIdghc?A constant holding the JavaScript executable Filename extensionghc5CPP definitions that are inserted into every .pp fileghcCPP definitions for normal operation and profiling. Use CAFs for commonCppDefs_* so that they are shared for every CPP fileghcCPP definitions for normal operation and profiling. Use CAFs for commonCppDefs_* so that they are shared for every CPP fileghcGenerate CPP Definitions depending on a profiled or normal build. This occurs at link time.ghcConstruct the Filename for the "binary" of Haskell code compiled to JavaScript.ghcParse option pragma in JS fileghc Input fileghcParsed options, if any. Safe-Inferred(/7~ghcThis is the extension field for ConPat, added after typechecking It adds quite a few extra fields, to support elaboration of pattern matching.~ghcThe universal arg types 1-1 with the universal tyvars of the constructor/pattern synonym Use (conLikeResTy pat_con cpt_arg_tys) to get the type of the pattern~ghcExistentially bound type variables in correctly-scoped order e.g. [k:* x:k]~ghcDitto *coercion variables* and *dictionaries* One reason for putting coercion variable here I think is to ensure their kinds are zonked~ghc%Bindings involving those dictionaries~ghcExtra wrapper to pass to the matcher Only relevant for pattern-synonyms; ignored for data cons~ghc8Extension constructor for Pat, added after typechecking.~ghc#Coercion Pattern (translation only):During desugaring a (CoPat co pat) turns into a cast with co+ on the scrutinee, followed by a match on pat.~ghcPattern expansion: original pattern, and desugared pattern, for RebindableSyntax and other overloaded syntax such as OverloadedLists. See Note [Rebindable syntax and HsExpansion].~ghcCoercion Pattern If co :: t1 ~ t2, p :: t2, then (CoPat co p) :: t1~ghc)Why not LPat? Ans: existing locn will do~ghcType of whole pattern, t1ghc)Print with type info if -dppr-debug is onghc%Is the pattern any of combination of:(pat) pat :: Type~pat!pat x (variable)ghc p pat returns L if the pattern pat% needs parentheses under precedence p.ghc p cp returns L if the constructor patterns cp% needs parentheses under precedence p.ghc0Parenthesize a pattern without token informationghc p pat checks if  p pat is true, and if so, surrounds pat with a U. Otherwise, it simply returns pat.ghc Are we in a -XStrict1 context? See Note [-XStrict and irrefutability] UUUUUUUUUUUUUUUUUUUU ~~~~~~~U~~~~~~~~TUTUTTTTTTTTTTTTTTTTTTUUUU UUUUUUUUUUUUUUUUUUUU ~~~~~~~U~~~~~~~~TUTUTTTTTTTTTTTTTTTTTTUUUU Safe-Inferred 1*ghcAn accumulator to build a prefix data constructor, e.g. when parsing  MkT A B C), the accumulator will evolve as follows:  1. PrefixDataConBuilder [] MkT 2. PrefixDataConBuilder [A] MkT 3. PrefixDataConBuilder [A, B] MkT 4. PrefixDataConBuilder [A, B, C] MkT There are two reasons we have a separate builder type instead of using HsConDeclDetails GhcPs directly: It's faster, because  gives us constant-time snoc.Having a separate type helps ensure that we don't forget to finalize a RecTy into a S (we do that in dataConBuilderDetails).See Note [PatBuilder] for another builder type used in the parser. Here the technique is similar, but the motivation is different.ghc?See Note [Ambiguous syntactic categories] and Note [PatBuilder]ghc"Last two are the locations of the '|' before and after the payload Safe-Inferred /167ΈZghc%TH finalizers produced by the splice.Zghc8The result of splicing; See Note [Lifecycle of a splice]Zghc&Finalizers produced by a splice with See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice. For how this is used.ghcPending Type-checker SpliceghcPending Renamer SpliceghcMatch separator locationghc'Command Syntax Table (for Arrow syntax)ghc'('ghc')'׀ghc)HsWrap appears only in typechecker outputـghc7An expression with wrappers, used for rebindable syntaxThis should desugar to syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0) (syn_arg_wraps[1] arg1) ...:where the actual arguments come from elsewhere in the AST.߀ghcThe function to use in rebindable syntax. See Note [NoSyntaxExpr].ghcPost-Type checking TableWe use a PostTcTable where there are a bunch of pieces of evidence, more than is convenient to keep individually.ghcPost-Type checking ExpressionPostTcExpr is an evidence expression attached to the syntax tree by the type checker (c.f. postTcType).ghcThis is used for rebindable-syntax pieces that are too polymorphic for tcSyntaxOp (trS_fmap and the mzip in ParStmt)ghcMake a 'SyntaxExpr GhcRn' from an expression Used only in getMonadFailOp. See Note [Monad fail : Rebindable syntax, overloaded strings] in GHC.Rename.ExprghcMake a   from a 4 (the "rn" is because this is used in the renamer).ghc p e returns L if the expression e% needs parentheses under precedence p.ghc4Parenthesize an expression without token informationghc p e checks if  p e is true, and if so, surrounds e with an Y. Otherwise, it simply returns e.ghc.Is there only one RHS in this list of matches?ȁghc(Just print the original expression (the a).YYYYYYYY YYYZYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZYYY YYYY YYYYY XXX YYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXXXXXXYYYXXYXYXYYYYYYYYYYYYYYYYYYYYYYYZZZYYYYYZZZZYYYYYXXXXXXYYXXXXXYYYYYYYYYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZ߀ـڀۀ܀݀ހ׀؀рҀӀԀՀր̀̀΀πЀȀɀʀˀ€ÀĀŀƀǀZZZZZZZZZZZZZ߀ـڀۀ܀݀ހ׀؀рҀӀԀՀր̀̀΀πЀȀɀʀˀ€ÀĀŀƀǀZZZZZZ Safe-Inferred+ghcPretty-print an M.ghcPretty-print a M.#Generic helpers for the HsSyn type.((c) The University of Glasgow, 1992-2006 Safe-Inferred()*/1P"ځghcThis class specifies how to collect variable identifiers from extension patterns in the given pass. Consumers of the GHC API that define their own passes should feel free to implement instances in order to make use of functions which depend on it.In particular, Haddock already makes use of this, with an instance for its DocNameI pass so that it can reuse the code in GHC for collecting binders.ށghc2Indicate if evidence binders have to be collected.This type is used as a boolean (should we collect evidence binders or not?) but also to pass an evidence that the AST has been typechecked when we do want to collect evidence binders, otherwise these binders are not available.*See Note [Dictionary binders in ConPatOut]߁ghcDon't collect evidence bindersghcCollect evidence bindersghc e => (e)ghcA simple case alternative with a single pattern, no binds, no guards; pre-typecheckingghcWrap in parens if  appPrec says it needs them So f x becomes (f x), but 3 stays as 3.ghcA useful function for building OpApps. The operator is always a variable, and we don't know the fixity yet.ghc NB: Only for   .ghc Wildcard pattern - after parsingghc!Wildcard pattern - after renamingghc4The Big equivalents for the source tuple expressionsghc1The Big equivalents for the source tuple patternsghc Convert an T to an T.ghc Convert an T to an T.ÂghcConvert U to U. The former is what is parsed, but the latter is what we need in class/instance declarations΂ghc8Not infix, with place holders for coercion and free varsςghc!In Name-land, with empty bind_fvsӂghcIf any of the matches in the U are infix, the U is considered infix.Ԃghc Return the 0 encompassing the contents of any enclosed bindsՂghcConvenience function using ΂. This is for generated bindings only, do not use for user-written code.ւghc#Make a prefix, non-strict function X؂ghcShould we treat this as an unlifted bind? This will be true for any bind that binds an unlifted variable, but we must be careful around AbsBinds. See Note [Unlifted id check in isUnliftedHsBind]. For usage information, see Note [Strict binds checks] is GHC.HsToCore.Binds.قghc5Is a binding a strict variable or pattern bind (e.g. !x = ...)?ۂghcCollect  binders only, or "s + pattern synonyms, respectively݂ghc Collect both s and pattern-synonym binders߂ghcSame as ނ#, but works over a list of bindingsghcCollect s, or /s + pattern synonyms, depending on boolean flagghcUsed exclusively for the bindings of an instance decl which are all FunBindsghcReturns all the binding names of the decl. The first one is guaranteed to be the name of the decl. The first component represents all binding names except record fields; the second represents field occurrences. For record fields mentioned in multiple constructors, the SrcLoc will be from the first occurrence.3Each returned (Located name) has a SrcSpan for the whole- declaration. See Note [SrcSpan for binders]ghcSee Note [SrcSpan for binders]ghcCollects record pattern-synonym selectors only; the pattern synonym names are collected by ܂.ghcthe < returned are for the whole declarations, not just the namesghcthe < returned are for the whole declarations, not just the namesׂւłĂƂǂȂ͂˂̂ɂʂ΂тЂՂς҂ӂԂss‚؂قڂ܂߂ۂނ݂ځ܁ہ݁ށ߁ׂւłĂƂǂȂ͂˂̂ɂʂ΂тЂՂς҂ӂԂss‚؂قڂ܂߂ۂނ݂ځ܁ہ݁ށ߁ Safe-Inferred67  Safe-Inferred/671ghcextra source files (e.g. from #includes). The lexer collects these from '#  file  line' pragmas, which the C preprocessor leaves behind. These files and their timestamps are stored in the .hi file, so that we can force recompilation if any of them change (#3589)ghc,Haskell Module extension point: GHC specificghcLayout info for the module. For incomplete modules (e.g. the output of parseHeader), it is NoLayoutInfo.ghc9reason/explanation for warning/deprecation of this module,s : -% ,-ghc-Haddock module info and description, unparsed,s : -% ,-YYYYYYY UUUUUUUUUUUUUUUUUUUUYTWWWVVVVWWWVVVVVWWWWWSSVVVVVVVVVV ZZZZZZZZ XXXXXXXXXXXXXXXXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWVVVVVVVVVVVVWWWWVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWVVVVVVVVVVUVVVVVVVVVUUUUUUUUUUUUWWWWWWWWWWWXXXXXXUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU YYYZYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZ UTTUTTTTTTTTTTTTTTTTTTSSTTTTSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTSSSTTTTTTTTTSSSSSTSSSSSSSSSSSSSSSSSSSSSSSYYY 0 YYYY YYYYYUWWW XXX0GGGGGHHHHHHHHHH YYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXXXXXXU 0000000000/////00000000000YYYUGGGGGXXYXYXYYYYYYYYYYYYYYYYYYYY YYY0000000//00GGGGUUUUUUUUUUZZZYYYYYZZZZYYYYYXXXXXXYYXXXXXYYYYYYYYYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXUUUUTTTTTTTT XX HUUUUUUUUUZZZZZZZZZ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ZZZZZZZ߀ـڀۀ܀݀ހ׀؀рҀӀԀՀր̀̀΀πЀȀɀʀˀ€ÀĀŀƀǀZZZZZZ9999999999999999999999999~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~USSSSsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssځ܁ہ݁ށ߁ׂւłĂƂǂȂ͂˂̂ɂʂ΂тЂՂς҂ӂԂ‚؂قڂ܂߂ۂނ݂////////////////////////////////////////////////////////,-------,,,----------------------------------------------------------------------------------------------,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+,,,,,,,,.-------.-...-------------------..................................ZZZZZZZZ Safe-Inferred΍ghcData for a module node in a  ModuleGraph/. Module nodes of the module graph are one of:A regular Haskell source moduleA hi-boot source moduleЍghcIdentity of the moduleэghc8The module source either plain Haskell, hs-boot, or hsigҍghc5Location of the various files belonging to the moduleӍghcContent hash of source fileԍghc#Timestamp of object, if we have oneՍghc+Timestamp of dynamic object, if we have one֍ghcTimestamp of hi file, if we have one See Note [When source is considered modified] and #9243׍ghc%Timestamp of hie file, if we have one؍ghcSource imports of the moduleٍghc7Non-source imports of the module from the module *text*ڍghc;Whether the special module GHC.Prim was imported explicitlyۍghcThe parsed, nonrenamed source, if we have it. This is also used to support "inline module syntax" in Backpack files.܍ghc$Filename of preprocessed source fileݍghcCached flags from OPTIONS, INCLUDE and LANGUAGE$ pragmas in the modules source codeލghc-The actual preprocessed source, if we have itghc summarises everything we know about a compiled module. The  is the stuff *before* linking, and can be written out to an interface file. The 'ModDetails is after linking and can be completely recovered from just the .4When we read an interface file, we also construct a . from it, except that we explicitly make the  and a few other fields empty; as when reading we consolidate the declarations etc. into a number of indexed maps and environments in the ExternalPackageState.See Note [Strictness in ModIface] to learn about why some fields are strict and others are not.ڋghcName of the module we are forۋghcAre we a sig of another mod?܋ghcBoot? Signature?݋ghcThe dependencies of the module. This is consulted for directly-imported modules, but not for anything else (hence lazy)ދghcUsages; kept sorted so that it's easy to decide whether to write a new iface file (changing usages doesn't affect the hash of this module) NOT STRICT! we read this field lazily from the interface file It is *only* consulted by the recompilation checkerߋghcExports Kept sorted by (mod,occ), to make version comparisons easier Records the modules that are the declaration points for things exported by this module, and the  s of those thingsghcModule required TH splices when it was compiled. This disables recompilation avoidance (see #481).ghcFixities NOT STRICT! we read this field lazily from the interface fileghcWarnings NOT STRICT! we read this field lazily from the interface fileghcAnnotations NOT STRICT! we read this field lazily from the interface fileghcType, class and variable declarations The hash of an Id changes if its fixity or deprecations change (as well as its type of course) Ditto data constructors, class operations, except that the hash of the parent class/tycon changesghcExtra variable definitions which are **NOT** exposed but when combined with mi_decls allows us to restart code generation. See Note [Interface Files with Core Definitions] and Note [Interface File with Core: Sharing RHSs]ghc6Binds all the things defined at the top level in the original source code for this module. which is NOT the same as mi_exports, nor mi_decls (which may contains declarations for things not actually defined by the user). Used for GHCi and for inspecting the contents of modules via the GHC API only.(We need the source file to figure out the top-level environment, if we didn't compile this module from source then this field contains Nothing).1Strictly speaking this field should live in the  HomeModInfo", but that leads to more plumbing.ghcSorted class instanceghcSorted family instancesghc Sorted rulesghc:True if this program uses Hpc at any point in the program.ghc/Safe Haskell Trust information for this module.ghcDo we require the package this module resides in be trusted to trust this module? This is used for the situation where a module is Safe (so doesn't require the package be trusted itself) but imports some trustworthy modules from its own package (which does require its own package be trusted). See Note [Trust Own Package] in GHC.Rename.Namesghc:Docstrings and related data for use by haddock, the ghci :doc command, and other tools.Just _  = the module was built with -haddock.ghcEither () or % for a fully instantiated interface.ghcAdditional optional fields, where the Map key represents the field name, resulting in a (size, serialized data) pair. Because the data is intended to be serialized through the internal 3 class (increasing compatibility with types using  and  FastString,, such as HIE), this format is chosen over  ByteStrings.ghc8Hash of the .hs source, used for recompilation checking.ghcSelects a IfaceDecl representation. For fully instantiated interfaces we also maintain a fingerprint, which is used for recompilation checks.ghc9Partial interface built based on output of core pipeline.ghcExtends a PartialModIface with information which is either: * Computed after codegen * Or computed just before writing the iface to disk. (Hashes) In order to fully instantiate it.ghcHash of the whole interfaceghcHash of the ABI onlyghcHash of the important flags used when compiling the module, excluding optimisation flagsghcHash of optimisation flagsghcHash of hpc flagsghcHash of pluginsghcWhether this module has orphansghcWhether this module has family instances. See Note [The type family instance consistency story].ghcHash of export listghc:Hash for orphan rules, class and family instances combinedghcCached lookup for ghcCached lookup for ghcCached lookup for . The Nothing in  means that the thing isn't in decls. It's useful to know that when seeing if we are up to date wrt. the old interface. The  + is the parent of the name, if it has one.ghcOld-style accessor for whether or not the ModIface came from an hs-boot file.ghc-Lookups up a (possibly cached) fixity from a . If one cannot be found,  is returned instead.ghcThe semantic module for this interface; e.g., if it's a interface for a signature, if ڋ is p[A= A]:A,  will be  A.ghc:The "precise" free holes, e.g., the signatures that this  depends on.ghcGiven a set of free holes, and a unit identifier, rename the free holes according to the instantiation of the unit identifier. For example, if we have A and B free, and our unit identity is p[A= C ,B=impl:B]%, the renamed free holes are just C.ghcConstructs cache for the  field of a ;؋ًڋۋ܋݋ދߋ׋֋Ջ;؋ًڋۋ܋݋ދߋ׋֋Ջ Safe-Inferred/՗ghc ..., we are checking the type a because it's the type of a term variable bound in a lambda, so we use Ӆ. ghcThe context in which a representation-polymorphism check was performed.Does not include the type on which the check was performed; see   for that. ghc  stores the origin of a skolem type variable, so that we can display this information to the user in case of a type error.The  field allows us to report all skolem type variables bound in the same place in a single report. ghc  stores the origin of a skolem type variable (e.g. bound by a user-written forall, the header of a data declaration, a deriving clause, ...).This information is displayed when reporting an error message, such as "Couldn't match k with l" C [a] where ... When typechecking the instance decl itself, including producing evidence for the superclasses of C, the superclasses of (Foo a) and (Bar a) will have  origin.ghc is used only for the Wanted constraints for the superclasses of an instance declaration.ghcTesting whether the constraint associated with an instance declaration in a signature file is satisfied upon instantiation.Test cases: backpack should_failbkpfail{11,43}.bkpghc The thing that has type "actual"ghcIs at least one of the three elements above visible? (Errors from the polymorphic subsumption check are considered visible.) Only used for prioritizing error messages.ghc"Some kind of type variable binder.Used for reporting errors, in   and TcSolverReportMsg.ghcSome thing which has a type.This datatype is used when we want to report to the user that something has an unexpected type.ghcReport Redundant Constraints.ghc"Don't report redundant constraintsghcReport redundant constraints, and here is the SrcSpan for the constraints E.g. f :: (Eq a, Ord b) => blah The span is for the (Eq a, Ord b)ghcUserTypeCtxt describes the origin of the polymorphic type in the places where we need an expression to have that typeghc8Wrap up the origin of a skolem type variable with a new 8, so that we can common up skolem type variables whose   shares a certain .ghcDid a constraint arise from expanding a Wanted constraint to look at superclasses?ghc)Extract a suitable CtOrigin from a HsExprghc-Extract a suitable CtOrigin from a MatchGroupghc-Extract a suitable CtOrigin from guarded RHSsghc7Extract a suitable CtOrigin from a list of guarded RHSsghcShort one-linersghcPrint the context for a FixedRuntimeRep# representation-polymorphism check.6Note that this function does not include the specific A4 which is not fixed. That information is stored in   and is reported separately. ghcrebindable syntax operatorghc!function used in the view patternghcfunctionghcargumentghcname of the functionghc equationsghc!the entire lambda-case expressionghcargument position (1-indexed)ghcJust like GivenOriginghcThe number of superclass selections necessary to get this constraint; see Note [Replacement vs keeping] in GHC.Tc.Solver.InteractghcTrue => "blocked": cannot use this to solve naked superclass Wanteds i.e. ones with (ScOrigin _ NakedSc) False => can use this to solve all Wanted constraints See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instanceghc)Module in which the instance was declaredghcThe declared typeclass instanceghcThe Unique is used to common up skolem variables bound at the same location (only used in pprSkols)ghc ... Differentiated from TypeHole because a ConstraintHole is simplified differently. See Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver.χghcA hole stores the information needed to report diagnostics about holes in terms (unbound identifiers or underscores) or in types (also called wildcards, as used in partial type signatures). See Note [Holes].чghcWhat flavour of hole is this?҇ghcThe name of this holeӇghcType to be printed to the user For expression holes: type of expr For type holes: the missing typeԇghcWhere hole was writtenՇghcA delayed error, to be reported after constraint solving, in order to benefit from deferred unifications.ևghc A hole (in a type or in a term).See Note [Holes].ׇghc+A type could not be ensured to be concrete.;See Note [The Concrete mechanism] in GHC.Tc.Utils.Concrete.އghcA އ is a type that can appear on the left of a canonical equality: a type variable or exactly-saturated type family application.ghcA -type is one that has been fully rewritten with respect to the inert set; that is, it has been rewritten by the algorithm in GHC.Tc.Solver.Rewrite. (Historical note: , for years and years, meant that a type was type-family-free. It does *not* mean this any more.)ghc?Are we sure that more solving will never solve this constraint?ghc8No problems in checking the validity of a type equality.ghcCheck whether a  is marked successful.ghcCheck whether a  has a ghcCheck whether a  has one  and no otherghcMark a  as not having an insoluble occurs-check: any occurs check under a type family or in a representation equality is soluble.ghcRetain only information about occurs-check failures, because only that matters after recurring into a kind.ghcReturns the evidence  for the argument  when this  is a .Returns J otherwise.ghcMakes a new equality predicate with the same role as the given evidence.ghcGet the flavour of the given ghc(Get the equality relation for the given ghcIs a type a canonical LHS? That is, is it a tyvar or an exactly-saturated type family application? Does not look through type synonyms.ghc Convert a އ back into a ghcRetrieve the kind of a އghcAre two އs equal?ghcReturns free variables of constraints as a non-deterministic setghcReturns free variables of constraints as a non-deterministic setghcReturns free variables of constraints as a deterministically ordered list. See Note [Deterministic FV] in GHC.Utils.FV.ghcReturns free variables of constraints as a deterministically ordered list. See Note [Deterministic FV] in GHC.Utils.FV.ghcReturns free variables of constraints as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of constraints as a composable FV computation. See Note [Deterministic FV] in GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a non-deterministic set. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a deterministically ordered list. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a deterministically ordered list. See Note [Deterministic FV] in GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a composable FV computation. See Note [Deterministic FV] in GHC.Utils.FV.ghcReturns free variables of WantedConstraints as a non-deterministic set. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of WantedConstraints as a deterministically ordered list. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of WantedConstraints as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of Implication as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghcA constraint is considered to be a custom type error, if it contains custom type errors anywhere in it. See Note [Custom type errors in constraints]ghcTrue if taking superclasses of givens, or of wanteds (to perhaps expose more equalities or functional dependencies) might help to solve this constraint. See Note [When superclasses help]ghcChecks whether a the given wanted constraints are solved, i.e. that there are no simple constraints left and all the implications are solved.ghc#Gather all the type variables from  that it would be unhelpful to default. For the moment, these are only w metavariables participating in a nominal equality whose other side is not concrete; it's usually better to report those as errors instead of defaulting.ňghcReturns True of equality constraints that are definitely insoluble, as well as TypeError constraints. Can return L for Given constraints, unlike È.This function is critical for accurate pattern-match overlap warnings. See Note [Pattern match warnings with insoluble Givens] in GHC.Tc.SolverNote that this does not traverse through the constraint to find nested custom type errors: it only detects TypeError msg :: Constraint, and not e.g. Eq (TypeError msg).ƈghcDoes this hole represent an "out of scope" error? See Note [Insoluble holes]҈ghc)Get the equality relation relevant for a ӈghcGet the role relevant for a Ոghc$Extract the set of rewriters from a  See Note [Wanteds rewrite Wanteds] If the provided CtEvidence is not for a Wanted, just return an empty set.݈ghcSet the type of CtEvidence.-This function ensures that the invariants on  hold, by updating the evidence and the ctev_pred in sync with each other. See Note [CtEvidence invariants].ghcMakes a ? from all the coercion holes that occur in the given coercion.ghcMakes a ; from all the coercion holes that occur in the given type.ghcMakes a < from all the coercion holes that occur in the given types.ghc-Extract the flavour, role, and boxity from a ghc$Extract the flavour and role from a ghc+Take a CtLoc and moves it to the kind levelghc of the familyghcexactly saturating the family؇هڇۇ܇݇ψЈш҈ֈԈ׈؈Ոއ߇χЇч҇Ӈԇˇ͇̇·ƈՇևׇƇLJȇɇʇ‡ÇćŇˆÈĈňLjɈȈʈވ߈ӈ݈ۈ܈وڈΈ̈ˈ͈؇هڇۇ܇݇ψЈш҈ֈԈ׈؈Ոއ߇χЇч҇Ӈԇˇ͇̇·ƈՇևׇƇLJȇɇʇ‡ÇćŇˆÈĈňLjɈȈʈވ߈ӈ݈ۈ܈وڈΈ̈ˈ͈ Safe-InferredghcSubtract two natural numbers.ghcCompute the exact logarithm of a natural number. The logarithm base is the second argument.ghcDivide two natural numbers.ghcCompute the exact root of a natural number. The second argument specifies which root we are computing.ghcCompute the n-th root of a natural number, rounded down to the closest natural number. The boolean indicates if the result is exact (i.e., True means no rounding was done, False means rounded down). The second argument specifies which root we are computing. ghcCompute the logarithm of a number in the given base, rounded down to the closest integer. The boolean indicates if we the result is exact (i.e., True means no rounding happened, False means we rounded down). The logarithm base is the second argument. ?????????? Safe-Inferred )*D Safe-Inferred ghcSee Note [Safe Haskell Overlapping Instances Implementation] in GHC.Tc.SolverghcReturns True iff there are no Given constraints that might, potentially, match the given class consraint. This is used when checking to see if a Given might overlap with an instance. See Note [Instance and Given overlap] in GHC.Tc.Solver.Interactghc+Is it (potentially) loopy to use the first ct1 to solve ct2?Necessary (but not sufficient) conditions for this function to return True:ct1 and ct2& both arise from superclass expansion,ct1 is a Given and ct2 is a Wanted.See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance, (sc2).ghc don't solve itghccbv, must be a CycleBreakerTvghc'type family application the cbv maps toghccbv, must be a CycleBreakerTvghccbv's expansion0ȉɉʉˉ̉ԉՉЉ҉Ӊω͉щΉ։‰ÉĉʼnƉ׉݉߉؉ىډۉ܉މlj0ȉɉʉˉ̉ԉՉЉ҉Ӊω͉щΉ։‰ÉĉʼnƉ׉݉߉؉ىډۉ܉މlj Safe-Inferred (4&ghc)Represents the head of a match against a ^ or literal. Really similar to ].ghcUndecidable semantic equality result. See Note [Undecidable Equality for PmAltCons]ghcLiterals (simple and overloaded ones) for pattern match checking.-See Note [Undecidable Equality for PmAltCons]ghc A data type that caches for the  of x the results of querying dsGetCompleteMatches* and then striking out all occurrences of K for which we already know x D K from these sets.For motivation, see Section 5.3 in Lower Your Guards. See also Note [Implementation of COMPLETE pragmas]ghcThe residual set for the vanilla COMPLETE set from the data defn. Tracked separately from , because it might only be known much later (when we have enough type information to see the ? of the match), or not at all even. Until that happens, it is J.ghcThe residual sets for all COMPLETE sets from pragmas that are visible when compiling this module. Querying that set with dsGetCompleteMatches requires DsM, so we initialise it with J until first needed in a DsM context.ghcSee .ghcInformation about an . Stores positive () facts, like  x ~ Just 42, and negative (5) facts, like "x is not (:)". Also caches the type (vi_ty), the  of a COMPLETE set ().+Subject to Note [The Pos/Neg invariant] in GHC.HsToCore.Pmc.Solver.ghcThe  in question. Important for adding new constraints relative to this  when we don't easily have the  available.ghcPositive info:  apps it is (i.e. x ~ [Just y, PatSyn z]), all at the same time (i.e. conjunctive). We need a list because of nested pattern matches involving pattern synonym case x of { Just y -> case x of PatSyn z -> ... } However, no more than one RealDataCon in the list, otherwise contradiction because of generativity.ghcNegative info: A list of *s that it cannot match. Example, assuming 0 data T = Leaf Int | Branch T T | Node Int T then x D [Leaf, Node] means that x cannot match a Leaf or Node, and hence can only match Branch!. Is orthogonal to anything from , in the sense that  returns PossiblyOverlap for any pairing between  and .ghc8Can this variable be E? Models (mutually contradicting) x ~ E and x D E constraints. E.g. * : Don't know; Neither x ~ E nor x D E. * : x ~ E * : x D EghcA cache of the associated COMPLETE sets. At any time a superset of possible constructors of each COMPLETE set. So, if it's not in here, we can't possibly match on it. Complementary to . We still need it to recognise completion of a COMPLETE set efficiently for large enums.ghcThe term oracle state. Stores  for encountered s. These entries are possibly shared when we figure out that two variables must be equal, thus represent the same set of values.!See Note [TmState invariants] in GHC.HsToCore.Pmc.Solver.ghcFacts about term variables. Deterministic env, so that we generate deterministic error messages.ghcAn environment for looking up whether we already encountered semantically equivalent expressions that we want to represent by the same  representative.ghcWhich  needs to be checked for inhabitants because of new negative constraints (e.g. x D E or x D K).ghcThe type oracle state. An  that we incrementally add local type constraints to, together with a sequence number that counts the number of times we extended it with new facts.ghcA disjunctive bag of "s, representing a refinement type.ghcA normalised refinement type D ("nabla"), comprised of an inert set of canonical (i.e. mutually compatible) term and type constraints that form the refinement type's predicate.ghcType oracle; things like a~Intghc"Term oracle; things like x~Nothingghc+An initial nabla that is always satisfiableghc!Initial state of the term oracle.ghcLike lookupVarInfo ts x, but lookupVarInfo ts x = (y, vi)3 also looks through newtype constructors. We have x ~ N1 (... (Nk y)) such that the returned y doesn't have a positive newtype constructor constraint associated with it (yet). The  returned is that of y's representative.Careful, this means that idType x might be different to idType y", even modulo type normalisation!See also Note [Coverage checking Newtype matches] in GHC.HsToCore.Pmc.Solver.ghcWhen  can be decided. True  = Equal, False  = Disjoint.ghc/Undecidable equality for values represented by 1s. See Note [Undecidable Equality for PmAltCons] Just True ==> Surely equal Just False. ==> Surely different (non-overlapping, even!)Nothing" ==> Equality relation undecidableghc Type of a ghc/Undecidable equality for values represented by ^4s. See Note [Undecidable Equality for PmAltCons]. ^s aren't enforced to be generative, so two syntactically different ^s might match the exact same values. Without looking into and reasoning about the pattern synonym's definition, we can't decide if their sets of matched values is different. Just True ==> Surely equal Just False. ==> Surely different (non-overlapping, even!)Nothing" ==> Equality relation undecidableghcWhether there is a  in the  that compares  to the given  according to .ghc'We can't in general decide whether two ?s match the same set of values. In addition to the reasons in  and , a 2 might or might not represent the same value as a 1. See Note [Undecidable Equality for PmAltCons]. Just True ==> Surely equal Just False. ==> Surely different (non-overlapping, even!)Nothing" ==> Equality relation undecidable.Examples (omitting some constructor wrapping):/eqPmAltCon (LitInt 42) (LitInt 1) == Just False: Lit equality is decidable0eqPmAltCon (DataCon A) (DataCon B) == Just False": DataCon equality is decidable4eqPmAltCon (LitOverInt 42) (LitOverInt 1) == Nothing$: OverLit equality is undecidable-eqPmAltCon (PatSyn PA) (PatSyn PB) == Nothing#: PatSyn equality is undecidable-eqPmAltCon (DataCon I#) (LitInt 1) == Nothing: DataCon to Lit comparisons are undecidable without reasoning about the wrapped Int#5eqPmAltCon (LitOverInt 1) (LitOverInt 1) == Just True2: We assume reflexivity for overloaded literals/eqPmAltCon (PatSyn PA) (PatSyn PA) == Just True/: We assume reflexivity for Pattern Synonymsghc Type of a ghcIs a match on this constructor forcing the match variable? True of data constructors, literals and pattern synonyms (#17357), but not of newtypes. See Note [Coverage checking Newtype matches] in GHC.HsToCore.Pmc.Solver.ghcNot user-facing.ghcSyntactic equality.ghcSyntactic equality.ŠghcNot user-facing.ÊghcNot user-facing.^^ Safe-Inferred(9ÏˊghcUsed as tree payload post-checking. The redundancy info we elaborated.̊ghc;Used as tree payload pre-checking. The LYG guards to check.͊ghc#Pattern-match coverage check resultϊghc,A hole for redundancy info and covered sets.ЊghcThe set of uncovered values falling out at the bottom. (for -Wincomplete-patterns, but also important state for the algorithm)ъghc&A flag saying whether we ran into the maxPmCheckModels limit for the purpose of suggesting to crank it up in the warning message. Writer state.ҊghcRedundancy sets, used to determine redundancy of RHSs and bang patterns (later digested into a CIRB).ԊghcThe Covered= set; the set of values reaching a particular program point.ՊghcThe  Diverging set; empty if no match can lead to divergence. If it wasn't empty, we have to turn redundancy warnings into inaccessibility warnings for any subclauses.֊ghcIf any of the  is empty, the corresponding  pin-points a bang pattern in source that is redundant. See Note [Dead bang patterns].ڊghc(A guard tree denoting a pattern binding.܊ghc%A guard tree denoting an -XEmptyCase.ߊghcA guard tree denoting GRHS&: A payload describing the grds and a / useful for printing out in warnings messages.ghcA guard tree denoting GRHSs : A bunch of % guards for local bindings from the GRHSss where clauses and the actual list of GRHS=. See Note [Long-distance information for HsLocalBinds] in GHC.HsToCore.Pmc.Desugar.ghcA guard tree denoting Match5: A payload describing the pats and a bunch of GRHS.ghcA guard tree denoting  MatchGroup.ghcA sequence of s.ghcMeans by which we identify a source construct for later pretty-printing in a warning message.   for the equation to show,  for the location.ghcA very simple language for pattern guards. Let bindings, bang patterns, and matching variables against flat constructor patterns. The LYG guard language.ghcPmCon x K dicts args corresponds to a K dicts args <- x guard. The args" are bound in this construct, the x0 is just a use. For the arguments' meaning see .ghcPmBang x corresponds to a  seq x True guard. If the extra  is present, the bang guard came from a source bang pattern, in which case we might want to report it as redundant. See Note [Dead bang patterns] in GHC.HsToCore.Pmc.Check.ghc PmLet x expr corresponds to a  let x = expr guard. This actually binds x.ghcFormat a LYG sequence (e.g. Matches of a  MatchGroup or GRHSs) as {  firstalt; ...;  lastalt }ghcShould not be user-facing.ghcFormat LYG guards as | True <- x, let x = 42, !zߊڊۊ܊݊ފҊӊԊՊ֊׊؊ي͊ΊϊЊъ̊ˊ^1ߊڊۊ܊݊ފҊӊԊՊ֊׊؊ي͊ΊϊЊъ̊ˊ Safe-Inferred˿ghcThe result of .ghcPretty-print the guts of an uncovered value vector abstraction, i.e., its components and refutable shapes associated to any mentioned variables. Example for )([Just p, q], [p :-> [3,4], q :-> [0,5]]): (Just p) q where p is not one of {3, 4} q is not one of {0, 5} When the set of refutable shapes contains more than 3 elements, the additional elements are indicated by "...".ghc5Output refutable shapes of a variable in the form of "var is not one of {2, Nothing, 3}. Will never print more than 3 refutable shapes, the tail is indicated by an ellipsis.ghcExtract and assigns pretty names to constraint variables with refutable shapes.ghc*Allocates a new, clean name for the given ! if it doesn't already have one.ghcPretty print a variable, but remember to prettify the names of the variables that refer to neg-literals. The ones that cannot be shown are printed as underscores.ghcExtract a list of s out of a sequence of cons cells, optionally terminated by a wildcard variable instead of []. Some examples:pmExprAsList (1:2:[]) == Just ( [1,2]), a regular, [].-terminated list. Should be pretty-printed as [1,2].pmExprAsList (1:2:x) == Just ( [1,2] x), a list prefix ending in a wildcard variable x (of list type). Should be pretty-printed as (1:2:_). pmExprAsList [] == Just ( []) Safe-Inferred )*<ghcAn existential wrapper around X GhcPs GhcPs body.ghc1The context for an "empty statement group" error.ghc6Empty statement group in a parallel list comprehensionghc7Empty statement group in a transform list comprehensionExample: [() | then ()]ghc$Empty statement group in do notationExample: doghc'Empty statement group in arrow notationExample: proc () -> doghcThe phase in which an exception was encountered when dealing with a TH spliceghcThe information necessary to report mismatched numbers of arguments in a match group.ghc1Context for a mismatch in the number of argumentsghcName of the functionghcPattern match specificsghcStores the information to be reported in a representation-polymorphism error message.ghcWhat is the original type we checked for representation-polymorphism, and what specific check did we perform?ghcWhich non-concrete type did we try to unify this concrete type variable with?ghc3Whether we ran out of fuel generating the bindings.ghc.A collection of hole fits and refinement fits.ghcA collection of valid hole fits or refinement fits, in which some fits might have been suppressed.ghcWhether we have suppressed any fits because there were too many.ghcThis datatype collates instances that match or unifier, in order to report an error message for an unsolved typeclass constraint.ghc!Explain a problem with an import.ghc/Couldn't find a module with the requested name.ghc9The imported modules don't export what we're looking for.ghcA message that aims to explain why two types couldn't be seen to be representationally equal.ghcNot knowing the role of a type constructor prevents us from concluding that two types are representationally equal.Example:foo :: Applicative m => m (Sum Int) foo = coerce (pure $ 1 :: Int)We don't know what role m2 has, so we can't coerce `m Int` to `m (Sum Int)`.#Test cases: T8984, TcCoercibleFail.ghcThe fact that a - is abstract prevents us from decomposing a TyConApp: and deducing that two types are representationally equal.Test cases: none.ghc Down Int foo = coerceTest cases: TcCoercibleFail.ghcReport an error involving a χ.This could be an out of scope data constructor or variable, a typed hole, or a wildcard in a type.ghcReport an out-of-scope data constructor or variable masquerading as an expression hole.Report a typed hole, or wildcard, with additional information.ghc2Configuration for pretty-printing valid hole fits.ghc Some form of "not in scope" error. See also the  constructor of .ghcA run-of-the-mill "not in scope" error.ghc An exact  was not in scope.This usually indicates a problem with a Template Haskell splice.Test cases: T5971, T18263.ghcalways at least 2 elementsÐghc"Couldn't find a top-level binding.Happens when specifying an annotation for something that is not in scope.,Test cases: annfail01, annfail02, annfail11.ĐghcA class doesn't have a method with this name, or, a class doesn't have an associated type with this name, or, a record doesn't have a record field with this name.Őghc'Explain how a kind equality originated.ǐghcExpected/actual information.Ȑghc&Display the expected and actual types.ɐghcDisplay the expected and actual types, after expanding type synonyms.ΐghc$Add some information about ambiguityϐghc?Some type variables remained ambiguous: print them to the user.Аghc?Remind the user that a particular type family is not injective.ѐghcTrue  => start the message with "Ambiguous type variable ..." False  =? create a message of the form "The type variable is ambiguous."ҐghcAmbiguous kind and type variables, respectively. Guaranteed to not both be empty.Ӑghc:Add some information to disambiguate errors in which two Names( would otherwise appear to be identical.)See Note [Disambiguating (X ~ X) errors].ՐghcWhether the two "s also came from the same package.ؐghcA cue to print out information about type variables, e.g. where they were bound, when there is a mismatch  tv1 ~ ty2.ݐghc(Additional information to be given in a & message, which is then passed on to mk_supplementary_ea_msg.ghc7A type equality between a type variable and a polytype.(Test cases: T12427a, T2846b, T10194, ...ghcAn occurs check.ghc)A skolem type variable escapes its scope.Example:7data Ex where { MkEx :: a -> MkEx } foo (MkEx x) = x#Test cases: TypeSkolEscape, T11142.ghcCan't unify the type variable with the other type due to the kind of type variable it is.For example, trying to unify a SkolemTv with the type Int, or with a TyVarTv.ghc:Whether to use expected/actual in a type mismatch message.ghcDon't use expected/actual.ghcUse expected/actual.ghc/Whether to also mention type synonym expansion.ghc"Couldn't unify two types or kinds.Example:93 + 3# -- can't match a lifted type with an unlifted typeTest cases: T1396, T8263, ...ghcA type has an unexpected kind.Test cases: T2994, T7609, ...ghc?A mismatch between two types, which arose from a type equality.Test cases: T1470, tcfail212.ghcCouldn't solve some Wanted constraints using the Givens. Used for messages such as "No instance for ..." and "Could not deduce ... from".ghc6Should this be phrased in terms of expected vs actual?ghc0The constraint in which the mismatch originated.ghc8First type (the expected type if if mismatch_ea is True)ghc4Second type (the actual type if mismatch_ea is True)ghcWhat thing is  the kind of?ghcThe overall expected typeghcThe overall actual typeghcWhat thing is  the kind of?ghc)The Wanted constraints we couldn't solve. N.B.: the  at the head of the list has been tidied, perhaps not the others.ghc!Some additional info consumed by mk_supplementary_ea_msg.ghcAn error reported after constraint solving. This is usually, some sort of unsolved constraint error, but we try to be specific about the precise problem we encountered.ghc4Quantified variables appear out of dependency order.Example:forall (a :: k) k. ...:Test cases: BadTelescope2, T16418, T16247, T16726, T18451.ghcWe came across a custom type error and we have decided to report it.Example:9type family F a where F a = TypeError (Text "error")err :: F () err = ()1Test cases: CustomTypeErrors0{1,2,3,4,5}, T12104.ghcWe want to report an out of scope variable or a typed hole. See .ghcTrying to unify an untouchable variable, e.g. a variable from an outer scope.Test case: Simple14ghc4Cannot unify a variable, because of a type mismatch.ghcA mismatch between two types.ghc:A violation of the representation-polymorphism invariants.See  and FixedRuntimeRepContext for more information.ghcAn equality between two types is blocked on a kind equality between their kinds.Test cases: none.ghc9Something was not applied to sufficiently many arguments.Example:instance Eq Maybe where {..}Test case: T11563.ghc,Trying to use an unbound implicit parameter.Example:foo :: Int foo = ?paramTest case: tcfail130.ghcA constraint couldn't be solved because it contains ambiguous type variables.Example:!class C a b where f :: (a,b) x = fst fTest case: T4921.ghcCould not solve a constraint; there were several unifying candidate instances but no matching instances. This is used to report as much useful information as possible about why we couldn't choose any instance, e.g. because of ambiguous type variables.ghcCould not solve a constraint using available instances because the instances overlap.,Test cases: tcfail118, tcfail121, tcfail218.ghcCould not solve a constraint from instances because instances declared in a Safe module cannot overlap instances from other modules (with -XSafeHaskell).%Test cases: SH_Overlap{1,2,5,6,7,11}.ghcA predicate with its arising location; used to encapsulate a constraint that will give rise to a diagnostic.ghc=for Wanteds, where to put the evidence for Givens, Nothingghc Context needed when reporting a , such as the enclosing implication constraints or whether we are deferring type errors.ghcEnclosing implications (innermost first) ic_skols and givens are tidied, rest are notghcWe make some errors (depending on cec_defer) into warnings, and emit evidence bindings into  for unsolved constraintsghc*Whether to defer type errors until runtimeghc*Reason for reporting holes in expressions.ghc$Reason for reporting holes in types.ghc(Reason for reporting out of scope holes.ghcTrue  = -Wredundant-constraintsghcTrue  = -fprint-expanded-synonymsghcTrue  = More important errors have occurred, so create bindings if need be, but don't issue any more errors/warnings See Note [Suppressing error messages]ghcA , together with context (e.g. enclosing implication constraints) that are needed in order to report it.ghcContext for what we wish to report. This can change as we enter implications, so is stored alongside the content.ghc%The content of the message to report.ghc%Additional information to print in a ‘<, after the important messages and after the error context.See Note [Error report].‘ghcA collection of main error messages and supplementary information.In practice, we will: - display the important messages first, - then the error context (e.g. by way of a call to ), - then the supplementary information (e.g. relevant bindings, valid hole fits), - then the hints ("Possible fix: ...").So this is mostly just a way of making sure that the error context appears early on rather than at the end of the message.$See Note [Error report] for details.Ǒghc2Is the object we are dealing with exported or not?Used for reporting "missing signature" warnings, see .ʑghc/What kind of thing is missing a type signature?Used for reporting "missing signature" warnings, see tcRnMissingSignature.͑ghcwhether -XCUSKs is enabledΑghcIf Б, the associated type of a typeclass is not parameterized over the last type variable of the classϑghc'The associated type family of the classёghcIf ґ, the associated type of a typeclass contains the last type variable of the class in a kind, which is not (yet) allowed by GHC.ґghc'The associated type family of the classԑghcA type representing whether or not the input type has associated data family instances.בghc;Whether a sole extra-constraint wildcard is allowed, e.g. _ => .. as opposed to ( .., _ ) => ...ڑghc6A context in which we don't allow anonymous wildcards.ghc-The type must not have some datatype context.ghcThe data constructor must not have exotic unlifted or polymorphic arguments.ghc3The data constructor must be a vanilla constructor.ghcThe type must have some type parameters. check (d) from Note [Requirements for deriving Generic and Rep] in GHC.Tc.Deriv.Generics.ghc9The data constructor must not have existential arguments.ghcThe derivation applies a type to an argument involving the last parameter but the applied type is not of kind * -> *.ghc The given # must be truly polymorphic in the last argument of the data type.ghc The given #7 must not use the type variable in a function argument"ghc The given # must not contain function typesghc The given # must use the type variable only as the last argument of a data typeghc The given #; is a GADT so we cannot directly derive an istance for it.ghc The given #( has existentials type vars in its type.ghc The given # has constraints in its type.ghc The given # has a higher-rank type.ghc8Why a particular typeclass instance couldn't be derived.ghc*The typeclass instance is not well-kinded.ghc=The instance type | We cannot derive instances in boot filesghc&We cannot use GND on non-newtype typesghc-We cannot derive instances of nullary classesghc,Last arg must be newtype or data applicationghc The given  is not a class.ghc"The given (representation of the)  has no data constructors.ghc/GHC simply doesn't how to how derive the input @ for the given .ghc The given  must be an enumeration. See Note [Enumeration types] in GHC.Core.TyConghc The given  must have  precisely one constructor.ghc.The given data type must have some parameters.ghc2The given data type must not have a class context.ghcWe couldn't derive an instance for a particular data constructor for a variety of reasons.ghcWe couldn't derive a 6 instance for the given type for a variety of reasonsghcWe couldn't derive an instance either because the type was not an enum type or because it did have more than one constructor.ghcA data type to describe why a variable is not closed. See Note [Not-closed error messages] in GHC.Tc.Gen.ExprghcHelper type used in checkDataKindSig.Superficially similar to  ContextKind, but it lacks AnyKind and , and instead of TheKind liftedTypeKind provides 3, which is much simpler to match on and handle in isAllowedDataResKind.ghc'A description of whether something is adata or newtype () data instance or newtype instance () data family ()/At present, this data type is only consumed by checkDataKindSig.ghcWhy the particular injectivity error arose together with more information, if any.ghcWhy the particular illegal newtype error arose together with more information, if any.ghcIn what context did we require a type to have a fixed runtime representation?Used by  for throwing representation polymorphism errors when validity checking.See Note [Representation polymorphism checking] in GHC.Tc.Utils.ConcreteghcData constructor fields must have a fixed runtime representation.Tests: T11734, T18534.ghcPattern synonym signature arguments must have a fixed runtime representation.Test: RepPolyPatSynArg.ghcPattern synonym signature scrutinee must have a fixed runtime representation.Test: RepPolyPatSynRes.ghc Where a shadowed name comes fromghc(The shadowed name is local to the moduleghc?The shadowed name is global, typically imported from elsewhere.ghcWhich parts of a record field are affected by a particular error or warning.’ghc>Whether the error pertains to a function argument or a result.ŒghcSpecifies which calling convention is unsupported on the current platformɒghcSpecifies which back ends can handle a requested foreign import or exportʒghcLabel for a TH declarationӒghcThe reason a TH splice could not be converted to a Haskell expressionghcSourceghc3Identifies the TH splice attempting to be convertedghcThings forbidden in  type data1 declarations. See Note [Type data declarations]ghc8An error which might arise during typechecking/renaming.ghcSimply wraps an unknown N message a. It can be used by plugins to provide custom diagnostic messages originated during typechecking/renaming.ghcTcRnMessageWithInfo is a constructor which is used when extra information is needed to be provided in order to qualify a diagnostic and where it was originated (and why). It carries an extra { which can be used to pretty-print some names and it wraps a , which includes any extra context associated with this diagnostic.ghcTcRnWithHsDocContext annotates an error message with the context in which it originated.ghcTcRnSolverReport is the constructor used to report unsolved constraints after constraint solving, as well as other errors such as hole fit errors.See the documentation of the 8 datatype for an overview of the different errors.ghcTcRnRedundantConstraints is a warning that is emitted when a binding has a user-written type signature which contains superfluous constraints.Example:f :: (Eq a, Ord a) => a -> a -> a f x y = (x < y) || x == y -- `Eq a` is superfluous: the `Ord a` constraint suffices. Bool foo MkFalse = False foo MkTrue = True -- Inaccessible: requires True ~ FalseTest cases: T7293, T7294, T15558, T17646, T18572, T18610, tcfail167.ghcA type which was expected to have a fixed runtime representation does not have a fixed runtime representation.Example:data D (a :: TYPE r) = MkD aTest cases: T11724, T18534, RepPolyPatSynArg, RepPolyPatSynUnliftedNewtype, RepPolyPatSynRes, T20423ghcTcRnImplicitLift is a warning (controlled with -Wimplicit-lift) that occurs when a Template Haskell quote implicitly uses lift.Example: warning1 :: Lift t => t -> Q Exp warning1 x = [| x |]Test cases: th/T17804ghcTcRnUnusedPatternBinds is a warning (controlled with -Wunused-pattern-binds) that occurs if a pattern binding binds no variables at all, unless it is a lone wild-card pattern, or a banged pattern.Example: Just _ = rhs3 -- Warning: unused pattern binding (_, _) = rhs4 -- Warning: unused pattern binding _ = rhs3 -- No warning: lone wild-card pattern !() = rhs4 -- No warning: banged pattern; behaves like seq+Test cases: rename/{T13646,T17c,T17e,T7085}ghcTcRnDodgyImports is a warning (controlled with -Wdodgy-imports) that occurs when a datatype T is imported with all constructors, i.e. 'T(..)', but has been exported abstractly, i.e. T.Test cases: renameshould_compileT7167ghcTcRnDodgyExports is a warning (controlled by -Wdodgy-exports) that occurs when a datatype T is exported with all constructors, i.e. 'T(..)', but is it just a type synonym or a type/data family.Example: module Foo ( T(..) -- Warning: T is a type synonym , A(..) -- Warning: A is a type family , C(..) -- Warning: C is a data family ) wheretype T = Int type family A :: * -> * data family C :: * -> *Test cases: warningsshould_compileDodgyExports01ghcTcRnMissingImportList is a warning (controlled by -Wmissing-import-lists) that occurs when an import declaration does not explicitly list all the names brought into scope.Test cases: renameshould_compileT4489ghcWhen a module marked trustworthy or unsafe (using -XTrustworthy or -XUnsafe) is compiled with a plugin, the TcRnUnsafeDueToPlugin warning (controlled by -Wunsafe) is used as the reason the module was inferred to be unsafe. This warning is not raised if the -fplugin-trustworthy flag is passed.Test cases: plugins/T19926ghcTcRnModMissingRealSrcSpan is an error that occurs when compiling a module that lacks an associated .Test cases: NoneghcTcRnIdNotExportedFromModuleSig is an error pertaining to backpack that occurs when an identifier required by a signature is not exported by the module or signature that is being used as a substitution for that signature.Example(s): NoneTest cases: backpack should_fail bkpfail36ghcTcRnIdNotExportedFromLocalSig is an error pertaining to backpack that occurs when an identifier which is necessary for implementing a module signature is not exported from that signature.Example(s): NoneTest cases: backpack should_fail#bkpfail30 backpack should_fail#bkpfail31 backpack should_fail bkpfail34ghcTcRnShadowedName is a warning (controlled by -Wname-shadowing) that occurs whenever an inner-scope value has the same name as an outer-scope value, i.e. the inner value shadows the outer one. This can catch typographical errors that turn into hard-to-find bugs. The warning is suppressed for names beginning with an underscore.Examples(s): f = ... let f = id in ... f ... -- NOT OK, f is shadowed f x = do { _ignore <- this; _ignore <- that; return (the other) } -- suppressed via underscoreTest cases: typecheckshould_compileT10971a renameshould_compilern039 renameshould_compilern064 renameshould_compileT1972 rename should_failT2723 renameshould_compile$T3262 driver/werrorghcTcRnDuplicateWarningDecls is an error that occurs whenever a warning is declared twice.Examples(s): None.Test cases: None.ghcTcRnDuplicateWarningDecls is an error that occurs whenever the constraint solver in the simplifier hits the iterations' limit.Examples(s): None.Test cases: None.ghcTcRnIllegalPatSynDecl is an error that occurs whenever there is an illegal pattern synonym declaration. Examples(s):varWithLocalPatSyn x = case x of P -> () where pattern P = () -- not valid, it can't be local, it must be defined at top-level.Test cases: patsyn should_faillocalghcTcRnLinearPatSyn is an error that occurs whenever a pattern synonym signature uses a field that is not unrestricted.Example(s): NoneTest cases: linear should_fail LinearPatSyn2ghcTcRnEmptyRecordUpdate is an error that occurs whenever a record is updated without specifying any field. Examples(s):$(deriveJSON defaultOptions{} ''Bad) -- not ok, no fields selected for update of defaultOptionsTest cases: th/T12788ghcTcRnIllegalFieldPunning is an error that occurs whenever field punning is used without the NamedFieldPuns extension enabled. Examples(s):data Foo = Foo { a :: Int }foo :: Foo -> Int foo Foo{a} = a -- Not ok, punning used without extension.Test cases: parser should_failRecordDotSyntaxFail12ghcTcRnIllegalWildcardsInRecord is an error that occurs whenever wildcards (..) are used in a record without the relevant extension being enabled. Examples(s):data Foo = Foo { a :: Int }foo :: Foo -> Int foo Foo{..} = a -- Not ok, wildcards used without extension.Test cases: parser should_failRecordWildCardsFailghcTcRnIllegalWildcardInType is an error that occurs when a wildcard appears in a type in a location in which wildcards aren't allowed. Examples:Type synonyms: type T = _!Class declarations and instances: class C _ instance C _Standalone kind signatures:type D :: _ data DTest cases: ExtraConstraintsWildcardInTypeSplice2 ExtraConstraintsWildcardInTypeSpliceUsed ExtraConstraintsWildcardNotLast ExtraConstraintsWildcardTwice NestedExtraConstraintsWildcard NestedNamedExtraConstraintsWildcard PartialClassMethodSignature PartialClassMethodSignature2 T12039 T13324_fail1 UnnamedConstraintWildcard1 UnnamedConstraintWildcard2 WildcardInADT1 WildcardInADT2 WildcardInADT3 WildcardInADTContext1 WildcardInDefault WildcardInDefaultSignature WildcardInDeriving WildcardInForeignExport WildcardInForeignImport WildcardInGADT1 WildcardInGADT2 WildcardInInstanceHead WildcardInInstanceSig WildcardInNewtype WildcardInPatSynSig WildcardInStandaloneDeriving WildcardInTypeFamilyInstanceRHS WildcardInTypeSynonymRHS saks_fail003 T15433aghcTcRnDuplicateFieldName is an error that occurs whenever there are duplicate field names in a record.Examples(s): None.Test cases: None.ghcTcRnIllegalViewPattern is an error that occurs whenever the ViewPatterns syntax is used but the ViewPatterns language extension is not enabled..Examples(s): data Foo = Foo { a :: Int }8foo :: Foo -> Int foo (a -> l) = l -- not OK, the  ViewPattern extension is not enabled.Test cases: parser should_failViewPatternsFailghcTcRnCharLiteralOutOfRange is an error that occurs whenever a character is out of range.Examples(s): NoneTest cases: NoneghcTcRnIllegalWildcardsInConstructor is an error that occurs whenever the record wildcards '..'6 are used inside a constructor without labeled fields.Examples(s): NoneTest cases: NoneghcTcRnIgnoringAnnotations is a warning that occurs when the source code contains annotation pragmas but the platform in use does not support an external interpreter such as GHCi and therefore the annotations are ignored.Example(s): NoneTest cases: NoneghcTcRnAnnotationInSafeHaskell is an error that occurs if annotation pragmas are used in conjunction with Safe Haskell.Example(s): NoneTest cases: annotations should_failT10826ghcTcRnInvalidTypeApplication is an error that occurs when a visible type application is used with an expression that does not accept "specified" type arguments.Example(s): foo :: forall {a}. a -> a foo x = x bar :: () bar = let x = foo @Int 42 in ()Test cases: overloadedrecflds should_fail1overloadedlabelsfail03 typecheck should_fail/ExplicitSpecificity1 typecheck should_fail0ExplicitSpecificity10 typecheck should_fail/ExplicitSpecificity2 typecheck should_fail!T17173 typecheck should_failVtaFailghcExample(s): foo :: forall a. a foo = tagToEnum# 0#Test cases: typecheck should_fail tcfail164ghc=TcRnTagToEnumResTyNotAnEnum is an error that occurs when the  'tagToEnum#' function is given a result type that is not an enumeration type.Example(s): foo :: Int -- not an enumeration TyCon foo = tagToEnum# 0#Test cases: typecheck should_fail tcfail164ghc b -> _ f x y = [x, y]Test cases: partial-sigs should_failT14449ghcTcRnPartialTypeSigBadQuantifier is an error that occurs when a type variable being quantified over in the partial type signature of a function gets unified with a type that is free in that function's context.Example(s): foo :: Num a => a -> a foo xxx = g xxx where g :: forall b. Num b => _ -> b g y = xxx + yTest cases: partial-sig should_failT14479ghcTcRnMissingSignature is a warning that occurs when a top-level binding or a pattern synonym does not have a type signature.Controlled by the flags: -Wmissing-signatures -Wmissing-exported-signatures -Wmissing-pattern-synonym-signatures -Wmissing-exported-pattern-synonym-signatures -Wmissing-kind-signaturesTest cases: T11077 (top-level bindings) T12484 (pattern synonyms) T19564 (kind signatures)ghcTcRnPolymorphicBinderMissingSig is a warning controlled by -Wmissing-local-signatures that occurs when a local polymorphic binding lacks a type signature.Example(s): id a = aTest cases: warningsshould_compileT12574ghcTcRnOverloadedSig is an error that occurs when a binding group conflicts with the monomorphism restriction.Example(s): data T a = T a mono = ... where x :: Applicative f => f a T x = ...Test cases: typecheckshould_compileT11339ghcTcRnTupleConstraintInst is an error that occurs whenever an instance for a tuple constraint is specified.Examples(s): class C m a class D m a f :: (forall a. Eq a => (C m a, D m a)) => m a f = undefined)Test cases: quantified-constraints/T15334ghcTcRnAbstractClassInst is an error that occurs whenever an instance of an abstract class is specified.Examples(s): -- A.hs-boot module A where class C a- B.hs module B where import {-# SOURCE #-} A instance C Int where- A.hs module A where import B class C a where f :: a:- Main.hs import A main = print (f :: Int)Test cases: typecheck should_failT13068ghcTcRnNoClassInstHead is an error that occurs whenever an instance head is not headed by a class.Examples(s): instance cTest cases: typecheckrename!T5513 typecheckrenameT16385ghcTcRnUserTypeError is an error that occurs due to a user's custom type error, which can be triggered by adding a  TypeError< constraint in a type signature or typeclass instance.Examples(s): f :: TypeError (Text "This is a type error") f = undefinedTest cases: typecheck should_fail.CustomTypeErrors02 typecheck should_failCustomTypeErrors03ghcTcRnConstraintInKind is an error that occurs whenever a constraint is specified in a kind.4Examples(s): data Q :: Eq a => Type where {}Test cases: dependent should_failT13895 polykinds/T16263 saks should_fail(saks_fail004 typecheck should_fail#T16059a typecheck should_failT18714ghcTcRnUnboxedTupleTypeFuncArg is an error that occurs whenever an unboxed tuple or unboxed sum type is specified as a function argument, when the appropriate extension (`-XUnboxedTuples` or `-XUnboxedSums`) isn't enabled.Examples(s): -- T15073.hs import T15073a newtype Foo a = MkFoo a deriving P- T15073a.hs class P a where p :: a -> (# a #)Test cases: deriving should_fail$T15073.hs deriving should_fail&T15073a.hs typecheck should_failT16059dghcTcRnLinearFuncInKind is an error that occurs whenever a linear function is specified in a kind.(Examples(s): data A :: * %1 -> *Test cases: linear should_fail#LinearKind linear should_fail$LinearKind2 linear should_fail LinearKind3ghcTcRnForAllEscapeError is an error that occurs whenever a quantified type's kind mentions quantified type variable.Examples(s): type T :: TYPE (BoxedRep l) data T = MkTTest cases: unlifted-datatypes should_failUnlDataNullaryPolyghcTcRnVDQInTermType is an error that occurs whenever a visible dependent quantification is specified in the type of a term.Examples(s): a = (undefined :: forall k -> k -> Type) @IntTest cases: dependent should_fail"T15859 dependent should_fail(T16326_Fail1 dependent should_fail(T16326_Fail2 dependent should_fail(T16326_Fail3 dependent should_fail(T16326_Fail4 dependent should_fail(T16326_Fail5 dependent should_fail(T16326_Fail6 dependent should_fail(T16326_Fail7 dependent should_fail(T16326_Fail8 dependent should_fail(T16326_Fail9 dependent should_fail)T16326_Fail10 dependent should_fail)T16326_Fail11 dependent should_fail)T16326_Fail12 dependent should_fail"T17687 dependent should_failT18271ghcTcRnBadQuantPredHead is an error that occurs whenever a quantified predicate lacks a class or type variable head.Examples(s): class (forall a. A t a => A t [a]) => B t where type A t a :: Constraint)Test cases: quantified-constraints/T16474ghcTcRnIllegalTupleConstraint is an error that occurs whenever an illegal tuple constraint is specified.Examples(s): g :: ((Show a, Num a), Eq a) => a -> a g = undefinedTest cases: typecheck should_fail tcfail209aghcTcRnNonTypeVarArgInConstraint is an error that occurs whenever a non type-variable argument is specified in a constraint.;Examples(s): data T instance Eq Int => Eq TTest cases: ghciscriptsT13202 ghciscriptsT13202a polykinds/T12055a typecheck should_fail"T10351 typecheck should_fail"T19187 typecheck should_fail!T6022 typecheck should_failT8883ghcTcRnIllegalImplicitParam is an error that occurs whenever an illegal implicit parameter is specified.Examples(s): type Bla = ?x::Int data T = T instance Bla => Eq T8Test cases: polykinds/T11466 typecheck should_fail!T8912 typecheck should_fail%tcfail041 typecheck should_fail%tcfail211 typecheck should_failtcrun045ghcTcRnIllegalConstraintSynonymOfKind is an error that occurs whenever an illegal constraint synonym of kind is specified.Examples(s): type Showish = Show f :: (Showish a) => a -> a f = undefinedTest cases: typecheck should_fail tcfail209ghcTcRnIllegalClassInst is an error that occurs whenever a class instance is specified for a non-class.Examples(s): type C1 a = (Show (a -> Bool)) instance C1 Int whereTest cases: polykinds/T13267ghcTcRnOversaturatedVisibleKindArg is an error that occurs whenever an illegal oversaturated visible kind argument is specified.Examples(s): type family F2 :: forall (a :: Type). Type where F2 @a = Maybe aTest cases: typecheck should_fail"T15793 typecheck should_failT16255ghcTcRnBadAssociatedType is an error that occurs whenever a class doesn't have an associated type.=Examples(s): $(do d <- instanceD (cxt []) (conT ''Eq appT conT ''Foo) [tySynInstD $ tySynEqn Nothing (conT ''Rep appT conT ''Foo) (conT ''Maybe)] return [d]) ======> instance Eq Foo where type Rep Foo = MaybeTest cases: th/T12387aghcTcRnForAllRankErr is an error that occurs whenever an illegal ranked type is specified.Examples(s): foo :: (a,b) -> (a~b => t) -> (a,b) foo p x = pTest cases: - ghci should_runT15806 - indexed-types should_fail SimpleFail15 - typecheck should_failT11355 - typecheck should_failT12083a - typecheck should_failT12083b - typecheck should_failT16059c - typecheck should_failT16059e - typecheck should_failT17213 - typecheck should_failT18939_Fail - typecheck should_failT2538 - typecheck should_failT5957 - typecheck should_failT7019 - typecheck should_failT7019a - typecheck should_failT7809 - typecheck should_failT9196 - typecheck should_failtcfail127 - typecheck should_failtcfail184 - typecheck should_failtcfail196 - typecheck should_fail tcfail197ghcTcRnMonomorphicBindings is a warning (controlled by -Wmonomorphism-restriction) that arise when the monomorphism restriction applies to the given bindings.Examples(s): {-# OPTIONS_GHC -Wmonomorphism-restriction #-}bar = 10foo :: Int foo = bar&main :: IO () main = print foo)The example above emits the warning (for bar), because without monomorphism restriction the inferred type for bar: is 'bar :: Num p => p'. This warning tells us that if= we were to enable '-XMonomorphismRestriction' we would make bar less polymorphic, as its type would become 'bar :: Int', so GHC warns us about that.Test cases: typecheckshould_compileT13785ghcTcRnOrphanInstance is a warning (controlled by -Wwarn-orphans) that arises when a typeclass instance is an "orphan", i.e. if it appears in a module in which neither the class nor the type being instanced are declared in the same module.Examples(s): NoneTest cases: warningsshould_compile!T9178 typecheckshould_compileT4912ghcTcRnFunDepConflict is an error that occurs when there are functional dependencies conflicts between instance declarations.Examples(s): NoneTest cases: typecheck should_fail!T2307 typecheck should_fail%tcfail096 typecheck should_fail tcfail202ghcTcRnDupInstanceDecls is an error that occurs when there are duplicate instance declarations.Examples(s): class Foo a where foo :: a -> Int)instance Foo Int where foo = id/instance Foo Int where foo = const 42Test cases: cabalT12733"T12733 typecheck should_fail%tcfail035 typecheck should_fail$tcfail023 backpack should_fail%bkpfail18 typecheck should_fail+TcNullaryTCFail typecheck should_fail%tcfail036 typecheck should_failtcfail073 module/mod51 module/mod52 module/mod44ghcTcRnConflictingFamInstDecls is an error that occurs when there are conflicting family instance declarations.Examples(s): None.Test cases: indexed-types should_fail4ExplicitForAllFams4b indexed-types should_fail&NoGood indexed-types should_fail$Over indexed-types should_fail1OverDirectThisMod indexed-types should_fail3OverIndirectThisMod indexed-types should_fail-SimpleFail11a indexed-types should_fail-SimpleFail11b indexed-types should_fail-SimpleFail11c indexed-types should_fail-SimpleFail11d indexed-types should_fail,SimpleFail2a indexed-types should_fail,SimpleFail2b indexed-types should_fail-T13092/T13092 indexed-types should_fail/T13092c/T13092c indexed-types should_fail&T14179 indexed-types should_fail&T2334A indexed-types should_fail%T2677 indexed-types should_fail&T3330b indexed-types should_fail%T4246 indexed-types should_fail&T7102a indexed-types should_failT9371 polykinds/T7524 typecheck should_failUnliftedNewtypesOverlapghcTcRnBangOnUnliftedType is a warning (controlled by -Wredundant-strictness-flags) that occurs when a strictness annotation is applied to an unlifted type.Example(s): data T = MkT !Int# -- Strictness flag has no effect on unlifted typesTest cases: typecheckshould_compile"T20187a typecheckshould_compileT20187bghcTcRnLazyBangOnUnliftedType is a warning (controlled by -Wredundant-strictness-flags) that occurs when a lazy annotation is applied to an unlifted type.Example(s): data T = MkT ~Int# -- Lazy flag has no effect on unlifted typesTest cases: typecheckshould_compile"T21951a typecheckshould_compileT21951bghcTcRnMultipleDefaultDeclarations is an error that occurs when a module has more than one default declaration.Example: default (Integer, Int) default (Double, Float) -- 2nd default declaration not allowedText cases: module/mod58ghcTcRnBadDefaultType is an error that occurs when a type used in a default declaration does not have an instance for any of the applicable classes..Example(s): data Foo default (Foo)Test cases: typecheck should_failT11974bghcTcRnPatSynBundledWithNonDataCon is an error that occurs when a module's export list bundles a pattern synonym with a type that is not a proper `data` or  `newtype` construction.Example(s): module Foo (MyClass(.., P)) where pattern P = Nothing class MyClass a where foo :: a -> IntTest cases: patsyn should_fail export-classghcTcRnPatSynBundledWithWrongType is an error that occurs when the export list of a module has a pattern synonym bundled with a type that does not match the type of the pattern synonym.Example(s): module Foo (R(P,x)) where data Q = Q Int data R = R pattern P{x} = Q xText cases: patsyn should_fail)export-ps-rec-sel patsyn should_fail+export-type-synonym patsyn should_fail export-typeghc0TcRnDupeModuleExport is a warning controlled by -Wduplicate-exports that occurs when a module appears more than once in an export list.Example(s): module Foo (module Bar, module Bar) import BarText cases: None“ghcTcRnExportedModNotImported is an error that occurs when an export list contains a module that is not imported.Example(s): NoneText cases: module/mod135 module/mod8 rename should_fail#rnfail028 backpack should_fail bkpfail48ÓghcTcRnNullExportedModule is a warning controlled by -Wdodgy-exports that occurs when an export list contains a module that has no exports.Example(s): module Foo (module Bar) where import Bar ()Test cases: NoneēghcTcRnMissingExportList is a warning controlled by -Wmissing-export-lists that occurs when a module does not have an explicit export list.Example(s): NoneTest cases: typecheck should_failMissingExportList03œghcTcRnExportHiddenComponents is an error that occurs when an export contains constructor or class methods that are not visible.Example(s): NoneTest cases: NoneƓghcTcRnDuplicateExport is a warning (controlled by -Wduplicate-exports) that occurs when an identifier appears in an export list more than once.Example(s): NoneTest cases: module/MultiExport module/mod128 module/mod14 module/mod5 overloadedrecflds should_fail(DuplicateExports patsynshould_compileT11959ǓghcTcRnExportedParentChildMismatch is an error that occurs when an export is bundled with a parent that it does not belong toExample(s): module Foo (T(a)) where data T a = TrueTest cases: module/T11970 module/T11970B module/mod17 module/mod3 overloadedrecflds should_failNoParentȓghcTcRnConflictingExports is an error that occurs when different identifiers that have the same name are being exported by a module.Example(s): module Foo (Bar.f, module Baz) where import qualified Bar (f) import Baz (f)Test cases: module/mod131 module/mod142 module/mod143 module/mod144 module/mod145 module/mod146 module/mod150 module/mod155 overloadedrecflds should_fail)T14953 overloadedrecflds should_fail/overloadedrecfldsfail10 rename should_fail!rnfail029 rename should_fail$rnfail040 typecheck should_fail#T16453E2 typecheck should_fail$tcfail025 typecheck should_fail tcfail026ɓghcTcRnAmbiguousField is a warning controlled by -Wambiguous-fields occurring when a record update's type cannot be precisely determined. This will not be supported by -XDuplicateRecordFields in future releases.Example(s): data Person = MkPerson { personId :: Int, name :: String } data Address = MkAddress { personId :: Int, address :: String } bad1 x = x { personId = 4 } :: Person -- ambiguous bad2 (x :: Person) = x { personId = 4 } -- ambiguous good x = (x :: Person) { personId = 4 } -- not ambiguousTest cases: overloadedrecflds should_failoverloadedrecfldsfail06ʓghcTcRnMissingFields is a warning controlled by -Wmissing-fields occurring when the intialisation of a record is missing one or more (lazy) fields.Example(s): data Rec = Rec { a :: Int, b :: String, c :: Bool } x = Rec { a = 1, b = "two" } -- missing field cTest cases: deSugarshould_compileT13870 deSugarshould_compileds041 patsynshould_compileT11283 renameshould_compileT5334 renameshould_compileT12229 renameshould_compile T5892a warnings should_fail WerrorFail2˓ghcTcRnFieldUpdateInvalidType is an error occurring when an updated field's type mentions something that is outside the universally quantified variables of the data constructor, such as an existentially quantified type.Example(s): data X = forall a. MkX { f :: a } x = (MkX ()) { f = False }Test cases: patsyn should_fail+records-exquant typecheck should_failT3323̓ghcTcRnNoConstructorHasAllFields is an error that occurs when a record update has fields that no single constructor encompasses.Example(s): data Foo = A { x :: Bool } | B { y :: Int } foo = (A False) { x = True, y = 5 }Test cases: overloadedrecflds should_fail/overloadedrecfldsfail08 patsyn should_fail4mixed-pat-syn-record-sels typecheck should_failT7989ғghcTcRnSpecialClassInst is an error that occurs when a user attempts to define an instance for a built-in typeclass such as  Coercible, , or KnownNat, outside of a signature file.Test cases: deriving should_failT9687 deriving should_failT14916 polykinds/T8132 typecheck should_fail+TcCoercibleFail2 typecheck should_fail!T12837 typecheck should_failT14390ӓghcTcRnUselessTypeable is a warning (controlled by -Wderiving-typeable) that occurs when trying to derive an instance of the  class. Deriving  is no longer necessary (hence the "useless") as all types automatically derive  in modern GHC versions.Example(s): None.Test cases: warningsshould_compileDerivingTypeableԓghcTcRnDerivingDefaults is a warning (controlled by -Wderiving-defaults) that occurs when both DeriveAnyClass and GeneralizedNewtypeDeriving2 are enabled, and therefore GHC defaults to DeriveAnyClass/, which might not be what the user wants.Example(s): None.Test cases: typecheckshould_compile!T15839a derivingshould_compileT16179ՓghcTcRnNonUnaryTypeclassConstraint is an error that occurs when GHC encounters a non-unary constraint when trying to derive a typeclass.Example(s): class A deriving instance A data B deriving A -- We cannot derive A, is not unary (i.e. 'class A a').Test cases: deriving should_failT7959 deriving should_fail$drvfail005 deriving should_fail$drvfail009 deriving should_fail drvfail006֓ghcTcRnPartialTypeSignatures is a warning (controlled by -Wpartial-type-signatures) that occurs when a wildcard '_' is found in place of a type in a signature or a type class derivation5Example(s): foo :: _ -> Int foo = ...!deriving instance _ => Eq (Foo a)Test cases: dependentshould_compile!T11241 dependentshould_compile!T15076 dependentshould_compile#T14880-2 typecheckshould_compile!T17024 typecheckshould_compile$T10072 partial-sigs should_fail(TidyClash2 partial-sigs should_fail.Defaulting1MROff partial-sigs should_fail:WildcardsInPatternAndExprSig partial-sigs should_fail$T10615 partial-sigs should_fail%T14584a partial-sigs should_fail'TidyClash partial-sigs should_fail$T11122 partial-sigs should_fail$T14584 partial-sigs should_fail$T10045 partial-sigs should_fail;PartialTypeSignaturesDisabled partial-sigs should_fail$T10999 partial-sigs should_failExtraConstraintsWildcardInExpressionSignature partial-sigs should_failExtraConstraintsWildcardInPatternSplice partial-sigs should_fail4WildcardInstantiations partial-sigs should_run$T15415 partial-sigsshould_compile$T10463 partial-sigsshould_compile%T15039a partial-sigsshould_compile%T16728b partial-sigsshould_compile%T15039c partial-sigsshould_compile$T10438 partial-sigsshould_compile)SplicesUsed partial-sigsshould_compile$T18008 partial-sigsshould_compile*ExprSigLocal partial-sigsshould_compile%T11339a partial-sigsshould_compile$T11670 partial-sigsshould_compile;WarningWildcardInstantiations partial-sigsshould_compile$T16728 partial-sigsshould_compile$T12033 partial-sigsshould_compile%T15039b partial-sigsshould_compile$T10403 partial-sigsshould_compile$T11192 partial-sigsshould_compile%T16728a partial-sigsshould_compile)TypedSplice partial-sigsshould_compile%T15039d partial-sigsshould_compile$T11016 partial-sigsshould_compile'T13324_compile2 linear should_failLinearPartialSig polykinds/T14265 polykinds/T14172דghcTcRnCannotDeriveInstance is an error that occurs every time a typeclass instance can't be derived. The 9 will contain the specific reason this error arose.Example(s): None.Test cases: genericsT10604.T10604_no_PolyKinds deriving should_fail%drvfail009 deriving should_fail+drvfail-functor2 deriving should_fail'T10598_fail3 deriving should_fail-deriving-via-fail2 deriving should_fail,deriving-via-fail deriving should_failT16181ؓghcTcRnLazyGADTPattern is an error that occurs when a user writes a nested GADT pattern match inside a lazy (~) pattern.Test case: gadt/lazypatٓghcTcRnArrowProcGADTPattern is an error that occurs when a user writes a GADT pattern inside arrow proc notation.Test case: arrows should_fail arrowfail004.ړghcTcRnForallIdentifier is a warning (controlled with -Wforall-identifier) that occurs when a definition uses forall as an identifier.2Example: forall x = () g forall = ()2Test cases: T20609 T20609a T20609b T20609c T20609dۓghcTcRnTypeEqualityOutOfScope is a warning (controlled by -Wtype-equality-out-of-scope) that occurs when the type equality (a ~ b) is not in scope.Test case: T18862bܓghcTcRnTypeEqualityRequiresOperators is a warning (controlled by -Wtype-equality-requires-operators) that occurs when the type equality (a ~ b) is used without the TypeOperators extension.Example: {-# LANGUAGE NoTypeOperators #-} f :: (a ~ b) => a -> bTest case: T18862aݓghcTcRnIllegalTypeOperator is an error that occurs when a type operator is used without the TypeOperators extension.Example: {-# LANGUAGE NoTypeOperators #-} f :: Vec a n -> Vec a m -> Vec a (n + m)Test case: T12811ޓghcTcRnIllegalTypeOperatorDecl is an error that occurs when a type or class operator is declared without the TypeOperators extension..See Note [Type and class operator definitions]Example: {-# LANGUAGE Haskell2010 #-} {-# LANGUAGE MultiParamTypeClasses #-}module T3265 wheredata a :+: b = Left a | Right bclass a :*: b where {}Test cases: T3265, tcfail173ߓghcTcRnGADTMonoLocalBinds is a warning controlled by -Wgadt-mono-local-binds that occurs when pattern matching on a GADT when -XMonoLocalBinds is off.Example(s): NoneTest cases: T20485, T20485aghcThe TcRnNotInScope constructor is used for various not-in-scope errors. See  for more details. ghcTcRnUntickedPromotedThing is a warning (controlled with -Wunticked-promoted-constructors) that is triggered by an unticked occurrence of a promoted data constructor. Examples:data A = MkA type family F (a :: A) where { F MkA = Bool }type B = [ Int, Bool ]Test cases: T9778, T19984.ghcTcRnIllegalBuiltinSyntax is an error that occurs when built-in syntax appears in an unexpected location, e.g. as a data constructor or in a fixity declaration. Examples: infixl 5 : data P = (,)/Test cases: rnfail042, T14907b, T15124, T15233.ghcTcRnWarnDefaulting is a warning (controlled by -Wtype-defaults) that is triggered whenever a Wanted typeclass constraint is solving through the defaulting of a type variable.Example:one = show 1 -- We get Wanteds Show a0, Num a0, and default a0 to Integer.Test cases: none (which are really specific to defaulting), but see e.g. tcfail204.ghc6TcRnIncorrectNameSpace is an error that occurs when a  is used in the incorrect  NameSpace, e.g. a type constructor or class used in a term, or a term variable used in a type.Example: f x = IntTest cases: T18740a, T20884.ghcTcRnIllegalHsigDefaultMethods is an error that occurs when a binding for a class default method is provided in a Backpack signature file.Test case: bkpfail40ghcTcRnBadGenericMethod This test ensures that if you provide a "more specific" type signatures for the default method, you must also provide a binding.0Example: {-# LANGUAGE DefaultSignatures #-}class C a where meth :: a default meth :: Num a => a meth = 0Test case: testsuitetests typecheck should_failMissingDefaultMethodBinding.hsghcTcRnWarningMinimalDefIncomplete is a warning that one must specify which methods must be implemented by all instances.Example: class Cheater a where -- WARNING LINE cheater :: a {-# MINIMAL #-} -- warning!Test case: testsuitetestswarningsminimalWarnMinimal.hs:ghcTcRnDefaultMethodForPragmaLacksBinding is an error that occurs when a default method pragma is missing an accompanying binding.Test cases: testsuitetests typecheck should_failT5084.hs testsuitetests typecheck should_failT2354.hsghcTcRnIgnoreSpecialisePragmaOnDefMethod is a warning that occurs when a specialise pragma is put on a default method.Test cases: noneghcTcRnBadMethodErr is an error that happens when one attempts to provide a method in a class instance, when the class doesn't have a method by that name.Test case: testsuitetests th/T12387ghcTcRnNoExplicitAssocTypeOrDefaultDeclaration is an error that occurs when a class instance does not provide an expected associated type or default declaration.Test cases: testsuitetestsderivingshould_compileT14094 testsuitetests indexed-typesshould_compileSimple2 testsuitetests typecheckshould_compiletc254ghc:TcRnIllegalNewtype is an error that occurs when a newtype:#Does not have exactly one field, oris non-linear, or is a GADT, or+has a context in its constructor's type, or declaration occurs without the TypeOperators extension.!See Note [Type data declarations]Test case: testsuitetests type-data should_fail TDNoPragmaghc3TcRnTypeDataForbids is an error that occurs when a  type data declaration contains data4 declaration features that are forbidden in a  type data declaration.!See Note [Type data declarations]Test cases: testsuitetests type-data should_failTDDeriving testsuitetests type-data should_failTDRecordsGADT testsuitetests type-data should_failTDRecordsH98 testsuitetests type-data should_fail!TDStrictnessGADT testsuitetests type-data should_failTDStrictnessH98ghcTcRnTypedTHWithPolyType is an error that signifies the illegal use of a polytype in a typed template haskell expression.Example(s): bad :: (forall a. a -> a) -> () bad = $$( [|| _ -> () ||] )Test cases: th/T11452ghcTcRnSpliceThrewException is an error that occurrs when running a template haskell splice throws an exception. Example(s):Test cases: annotations should_failannfail12 perfcompiler.MultiLayerModulesTH_Make perfcompilerMultiLayerModulesTH_OneShot th/T10796b th/T19470 th/T19709d th/T5358 th/T5976 th/T7276a th/T8987 th/TH_exn1 th/TH_exn2 th/TH_runIOghcTcRnInvalidTopDecl is a template haskell error occurring when one of the Decs passed to  addTopDecls is not a function, value, annotation, or foreign import declaration. Example(s): Test cases:ghcTcRnNonExactName is a template haskell error for when a declaration being added is bound to a name that is not fully known. Example(s): Test cases:ghcTcRnAddInvalidCorePlugin is a template haskell error indicating that a core plugin being added has an invalid module due to being in the current package. Example(s): Test cases:ghcTcRnAddDocToNonLocalDefn is a template haskell error for documentation being added to a definition which is not in the current module. Example(s):Test cases: showIface should_failTHPutDocExternalghcTcRnFailedToLookupThInstName is a template haskell error that occurrs when looking up an instance fails. Example(s):Test cases: showIface should_failTHPutDocNonExistentghcTcRnCannotReifyInstance is a template haskell error for when an instance being reified via reifyInstances6 is not a class constraint or type family application. Example(s): Test cases:ghcTcRnCannotReifyOutOfScopeThing is a template haskell error indicating that the given name is not in scope and therefore cannot be reified. Example(s):Test cases: th/T16976fghcTcRnCannotReifyThingNotInTypeEnv is a template haskell error occurring when the given name is not in the type environment and therefore cannot be reified. Example(s): Test cases:ghcTcRnNoRolesAssociatedWithName is a template haskell error for when the user tries to reify the roles of a given name but it is not something that has roles associated with it. Example(s): Test cases:ghcTcRnCannotRepresentThing is a template haskell error indicating that a type cannot be reified because it does not have a representation in template haskell. Example(s): Test cases:ghcTcRnRunSpliceFailure is an error indicating that a template haskell splice failed to be converted into a valid expression. Example(s):Test cases: th/T10828a th/T10828b th/T12478_4 th/T15270A th/T15270B th/T16895a th/T16895b th/T16895c th/T16895d th/T16895e th/T17379a th/T17379b th/T18740d th/T2597b th/T2674 th/T3395 th/T7484 th/T7667a th/TH_implicitParamsErr1 th/TH_implicitParamsErr2 th/TH_implicitParamsErr3 th/TH_invalid_add_top_declghc8TcRnUserErrReported is an error or warning thrown using qReport from the Quasi instance of TcM. Example(s): Test cases:ghcTcRnInterfaceLookupError is an error resulting from looking up a name in an interface file. Example(s): Test cases:ghcTcRnUnsatisfiedMinimalDef is a warning that occurs when a class instance is missing methods that are required by the minimal definition.Example: class C a where foo :: a -> a instance C () -- | foo needs to be defined hereTest cases: testsuitetests typecheckprog001$typecheck.prog001 testsuitetests typecheckshould_compiletc126 testsuitetests typecheckshould_compileT7903 testsuitetests typecheckshould_compiletc116 testsuitetests typecheckshould_compiletc175 testsuitetests typecheckshould_compileHasKey testsuitetests typecheckshould_compiletc125 testsuitetests typecheckshould_compiletc078 testsuitetests typecheckshould_compiletc161 testsuitetests typecheck should_failT5051 testsuitetests typecheckshould_compileT21583 testsuitetestsbackpackshould_compilebkp47 testsuitetestsbackpack should_failbkpfail25 testsuitetestsparsershould_compileT2245 testsuitetestsparsershould_compileread014 testsuitetests indexed-typesshould_compileClass3 testsuitetests indexed-typesshould_compileSimple2 testsuitetests indexed-types should_failT7862 testsuitetestsderivingshould_compile deriving-1935 testsuitetestsderivingshould_compileT9968a testsuitetestsderivingshould_compiledrv003 testsuitetestsderivingshould_compileT4966 testsuitetestsderivingshould_compileT14094 testsuitetestsperfcompilerT15304 testsuitetestswarningsminimalWarnMinimal testsuitetests simplCoreshould_compilesimpl020 testsuitetestsdeSugarshould_compileT14546d testsuitetestsghciscriptsT5820 testsuitetestsghciscriptsghci019ghc is an error that happens when a method in a class instance is given a type signature, but the user has not enabled the  InstanceSigs extension.Test case: testsuitetests module/mod45ghc is an error that is triggered by a type family instance being declared in an hs-boot file.Test case: testsuitetests indexed-types should_fail HsBootFamghc is an error that occurs when an associated type or data family is given a top-level instance.Test case: testsuitetests indexed-types should_failT3092ghc is an error that occurs when a class instance for a class with an associated type or data family is missing a corresponding family instance declaration.Test case: testsuitetests indexed-types should_fail SimpleFail7ghc is an error that is triggered by a type or data family instance without the  TypeFamilies extension.Test case: testsuitetests indexed-types should_failBadFamInstDeclghc is an error that is triggered by attempting to give a top-level (open) type family instance for a closed type family.Test cases: testsuitetests indexed-types should_failOverlap7 testsuitetests indexed-types should_failOverlap3ghcTcRnNoRebindableSyntaxRecordDot is an error triggered by an overloaded record update without RebindableSyntax enabled. Example(s):Test cases: parser should_failRecordDotSyntaxFail5ghcTcRnNoFieldPunsRecordDot is an error triggered by the use of record field puns in an overloaded record update without enabling NamedFieldPuns./Example(s): print $ a{ foo.bar.baz.quux }Test cases: parser should_failRecordDotSyntaxFail12ghcTcRnIllegalStaticExpression is an error thrown when user creates a static pointer via TemplateHaskell without enabling the StaticPointers extension. Example(s):Test cases: th/T14204ghcTcRnIllegalStaticFormInSplice is an error when a user attempts to define a static pointer in a Template Haskell splice. Example(s):"Test cases: th/TH_StaticPointers02ghcTcRnListComprehensionDuplicateBinding is an error triggered by duplicate let-bindings in a list comprehension.2Example(s): [ () | let a = 13 | let a = 17 ]Test cases: typecheck should_fail tcfail092ghcTcRnEmptyStmtsGroup is an error triggered by an empty list of statements in a statement block. For more information, see  Example(s):  () | then ()do proc () -> doTest cases: rename should_failRnEmptyStatementGroup1ghcTcRnLastStmtNotExpr is an error caused by the last statement in a statement block not being an expression. Example(s):do x <- pure () do let x = 5Test cases: rename should_failT6060 parser should_failT3811g parser should_fail readFail028ghcTcRnUnexpectedStatementInContext is an error when a statement appears in an unexpected context (e.g. an arrow statement appears in a list comprehension). Example(s):Test cases: parser should_fail#readFail042 parser should_fail#readFail038 parser should_fail readFail043ghcTcRnIllegalTupleSection is an error triggered by usage of a tuple section without enabling the TupleSections extension.Example(s): (5,)Test cases: rename should_fail rnfail056ghcTcRnIllegalImplicitParameterBindings is an error triggered by binding an implicit parameter in an mdo block.,Example(s): mdo { let { ?x = 5 }; () }Test cases: rename should_failRnImplicitBindInMdoNotationghcTcRnSectionWithoutParentheses is an error triggered by attempting to use an operator section without parentheses.Example(s): (w x, ())Test cases: rename should_failT2490 rename should_failT5657ghc5TcRnLoopySuperclassSolve is a warning, controlled by -Wloopy-superclass-solve, that is triggered when GHC solves a constraint in a possibly-loopy way, violating the class instance termination rules described in the section "Undecidable instances and loopy superclasses" of the user's guide.Example:class Foo f class Foo f => Bar f g instance Bar f f => Bar f (h k)0Test cases: T20666, T20666{a,b}, T22891, T22912.ghc* is an "internal" type (used only inside  that wraps a  while also providing any extra info needed to correctly pretty-print this diagnostic later on.ghc&Extra context associated to the error.ghc1Extra supplementary info associated to the error.Ҕghc5Construct a basic mismatch message between two types.See pprMismatchMsg. for how such a message is displayed to users.Ӕghc7Report a mismatch error without any extra information.Ԕghc Create a "not in scope" error message for the given +.֔ghcDisplay some relevant bindings.#ghcalways a class constraintghc/ambiguous kind and type variables, respectivelyghcThe type constructor that occurs in the typeclass instance declaration.ghcThe typeclass kind.ghcThe number of typeclass arguments that GHC kept. See Note [tc_args and tycon arity] in GHC.Tc.Deriv. | Generic instances can only be derived using the stock strategy in Safe Haskell.ghc5Type constructor for which the instance is requestedghcWhether or not -XDeriveAnyClass is enabled already. | Stock deriving won't work, but perhaps DeriveAnyClass will.ghcThe { will allow us to pretty-print some diagnostics with more detail.ghcThe contextual skolem info. The boolean controls whether we want to show it in the user message. (Nice to keep track of the info in either case, for other users of the GHC API.)ghc+The implication containing a contradiction.ghcThe contradiction.ghc The limit.ghcthe wildcard name, or J for an anonymous wildcardghcfirst type variableghcsecond type variableghc function nameghc3user-written name of type variable being quantifiedghc function nameghc(type the variable unified with, if knownghcpartial type signatureghcTrue: -Wmissing-signatures overrides -Wmissing-exported-signatures, or -Wmissing-pattern-synonym-signatures overrides -Wmissing-exported-pattern-synonym-signaturesghc2whether this is an unboxed tuple or an unboxed sumȓghc&Occurrence name shared by both exportsghcName of first exportghc.Provenance for definition site of first exportghcExport decl of first exportghcName of second exportghc/Provenance for definition site of second exportghcExport decl of second exportɓghc Field updateghc Record type͓ghcRecordghcRecord selectorsghcPattern synonymghcPattern selectorsғghc6Whether the error is due to Safe Haskell being enabledדghc6The typeclass we are trying to derive an instance forghc The typeclass arguments, if any.ghc The derivation strategy, if any.ghc*Is '-XGeneralizedNewtypeDeriving' enabled?ghcThe specific reason why we couldn't derive an instance for the class.ghcwhat the problem isghcthe name that is not in scopeghcimport errors that are relevantghchints, e.g. enable DataKinds to refer to a promoted data constructorghc?what kind of thing this is (a binding, fixity declaration, ...)ghc/Wanted constraints in which defaulting occurredghc!The type variable being defaultedghcThe default typeghcwhether the error is happening in a Template Haskell tick (so we should give a Template Haskell hint)ghcThe visible kind argumentghcTarget of the kind applicationghc&classification of thing being returnedghc allowed kindghcthe return kindghcsuggested extensionghcPattern match specificsghcExpected number of argsghcActual number of argsghcTarget of the pragmasghcThe first pragmaghc Other pragmasghc of the classghcdefault methodsghc of the classghcProblematic methodghcmethodghc the pragmaghcTrue if linear types enabledghcResult of showing the exception (cannot be done safely outside IO)ghc Module nameghc+Name of the function used to run the spliceghcWanted ghcWanted ghc&Extra info associated with the messageړ“ÓēœƓǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓۓܓݓޓߓ”ÔĔŔƔǔޑߑȔڑۑܑݑבّؑԑՑ֑ɔёґӑʔΑϑБ˔ʑˑ̑͑Ǒȑɑ͔ΔДϔ‘ÑđőƑ̔єߐӔҔŐƐǐȐɐʐːِ̐͐ؐڐېܐӐԐՐ֐אΐϐАѐҐݐސՔ֔הؔÐĐԔŒƒǒȒɒ’ÒĒӒԒՒ֒גْؒڒےܒݒޒߒʒ˒̒͒ΒϒВђҒړ“ÓēœƓǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓۓܓݓޓߓ”ÔĔŔƔǔޑߑȔڑۑܑݑבّؑԑՑ֑ɔёґӑʔΑϑБ˔ʑˑ̑͑Ǒȑɑ͔ΔДϔ‘ÑđőƑ̔єߐӔҔŐƐǐȐɐʐːِ̐͐ؐڐېܐӐԐՐ֐אΐϐАѐҐݐސՔ֔הؔÐĐԔŒƒǒȒɒ’ÒĒӒԒՒ֒גْؒڒےܒݒޒߒʒ˒̒͒ΒϒВђҒ Safe-Inferred <5ghc"`where'3 clause at the same depth as implicit layout block"ghc"`|'- at the same depth as implicit layout block")ghcErrors from the Cmm parserghcUnknown Cmm primitiveghc Unknown macroghcUnknown calling conventionghcUnrecognised safetyghcUnrecognised hintghc Lexical errorghcUnknown pragmaghcLexical error in pragmaghc$Numeric escape sequence out of rangeghc)Lexical error in string/character literalghc2Unexpected end-of-file in string/character literalghcUnterminated `{-'ghcUnterminated OPTIONS pragmaghcUnterminated quasiquotationghc End of inputghcUTF-8 decoding errorghcError at given characterÎghcNegative application pattern?Ďghc*The list of type arguments for the patternǎghcExtra information for the expression GHC is currently inspecting/parsing. It can be used to generate more informative parser diagnostics and hints.ɎghcIf K8, this is an infix pattern with the bound operator nameʎghc9Did the parser likely fail due to an incomplete do block?Ύghc Is the parsed pattern recursive?юghcExtra details about a parse error, which helps us in determining which should be the hints to suggest.Ԏghc Is there a 'do' in the last 100 characters?Վghc Is there an mdo in the last 100 characters?֎ghcIs PatternSynonyms enabled?׎ghc!Did we parse a "pattern" keyword?َghcAn "unknown" message from the parser. This type constructor allows arbitrary messages to be embedded. The typical use case would be GHC plugins willing to emit custom diagnostics.ڎghc&A group of parser messages emitted in 5. See Note [Messages from GHC.Parser.Header].ێghcPsWarnBidirectionalFormatChars is a warning (controlled by the -Wwarn-bidirectional-format-characters flag) that occurs when unicode bi-directional format characters are found within in a fileThe  contains the exact position in the buffer the character occurred, and the string contains a description of the character.܎ghcPsWarnTab is a warning (controlled by the -Wwarn-tabs flag) that occurs when tabulations (tabs) are found within a file.Test case(s): parser should_fail"T12610 parsershould_compile"T9723b parsershould_compile"T9723a parsershould_compile#read043 parser should_fail$T16270 warningsshould_compileT9230ݎghcPsWarnTransitionalLayout is a warning (controlled by the -Walternative-layout-rule-transitional flag) that occurs when pipes ('|' ) or 'where'3 are at the same depth of an implicit layout block. Example(s):f :: IO () f | True = do let x = () y = () return () | True = return ()Test case(s): layout/layout006 layout/layout003 layout/layout001ގghcUnrecognised pragma. First field is the actual pragma name which might be empty. Second field is the set of valid candidate pragmas.ghc Invalid Haddock comment positionghc,Multiple Haddock comment for the same entityghc;Found binding occurrence of "*" while StarIsType is enabledghcUsing "*" for Type without StarIsType enabledghcPre qualified import with WarnPrepositiveQualifiedModule enabledghc4LambdaCase syntax used without the extension enabledghc(A lambda requires at least one parameterghc5Underscores in literals without the extension enabledghc%Invalid character in primitive stringghc Missing blockghc Lexer errorghcSuffix occurrence of @ghc Parse errorsghcCmm lexer errorghc#Unsupported boxed sum in expressionghc Unsupported boxed sum in patternghc Unexpected qualified constructorghc Tuple section in pattern contextghc*Bang-pattern without BangPattterns enabledghc%Operator applied to too few argumentsghc Import: multiple occurrences of  qualifiedghcPost qualified import without ImportQualifiedPostghc#Explicit namespace keyword without ExplicitNamespacesghc1Expecting a type constructor but found a variableghc.Illegal export form allowed by PatternSynonymsghcMalformed entity stringghcDots used in record updateghcPrecedence out of rangeghc!Invalid use of record dot syntax kghcOverloadedRecordUpdate is not enabled.ghcCan't use qualified fields when OverloadedRecordUpdate is enabled.ghc;Cannot parse data constructor in a data/newtype declarationghc;Cannot parse data constructor in a data/newtype declarationghcIllegal DataKinds quote mark in data/newtype constructor declarationghc$UNPACK applied to a data constructorghc7Unexpected kind application in data/newtype declarationghcNot a record constructorghc)Illegal unboxed string literal in patternghc3Illegal primitive floating point literal in patternghcDo-notation in patternghcIf-then-else syntax in patternghcLambda-case in patternghccase..of in patternghclet-syntax in patternghcLambda-syntax in patternghc"Arrow expression-syntax in patternghcArrow command-syntax in patternghc"Arrow command-syntax in expressionghcView-pattern in expressionghc&Type-application without space before @ghcLazy-pattern (C) without space after itghcBang-pattern (!) without space after itghc#Pragma not allowed in this positionghcQualified do block in commandghc.Invalid infix hole, expected an infix operatorghc0Unexpected semi-colons in conditional expressionghc-Unexpected semi-colons in conditional commandghc @-operator in a pattern positionghc1Unexpected lambda command in function applicationghc/Unexpected case command in function applicationghc2Unexpected case(s) command in function applicationghc-Unexpected if command in function applicationghc.Unexpected let command in function applicationghc-Unexpected do command in function applicationghc+Unexpected do block in function applicationghc,Unexpected mdo block in function applicationghc4Unexpected lambda expression in function applicationghc2Unexpected case expression in function applicationghc5Unexpected case(s) expression in function applicationghc1Unexpected let expression in function applicationghc0Unexpected if expression in function applicationghc2Unexpected proc expression in function applicationghc+Malformed head of type or class declarationghcIllegal 'where' keyword in data declarationghcIllegal datatype contextghcParse error on inputghc!Malformed ... declaration for ...ghc,Unexpected type application in a declarationghcNot a data constructorghc1Record syntax used in pattern synonym declarationghcEmpty 'where'& clause in pattern-synonym declarationghcInvalid binding name in 'where'& clause of pattern-synonym declarationghcMultiple bindings in 'where'& clause of pattern-synonym declarationghc"Declaration splice not a top-levelghc(Inferred type variables not allowed hereghc,Multiple names in standalone kind signaturesghcIllegal import bundle formghcIllegal role nameghcInvalid type signatureghcUnexpected type in declarationghcExpected a hyphenghcFound a space in a SCCghcFound two single quotesghcInvalid package nameghcInvalid rule activation markerghc1Linear function found but LinearTypes not enabledghc8Multi-way if-expression found but MultiWayIf not enabledÏghc=Explicit forall found but no extension allowing it is enabledďghc.Found qualified-do without QualifiedDo enabledŏghcCmm parser errorƏghc!Illegal traditional record syntax+TODO: distinguish errors without using SDocǏghcParse error in command+TODO: distinguish errors without using SDocȏghcParse error in patternɏghcParse error in right operator section pattern TODO: embed the proper operator, if possibleʏghcIllegal linear arrow or multiplicity annotation in GADT record syntaxҏghcPsErrUnsupportedOptionsPragma is an error that occurs when an unknown OPTIONS_GHC pragma is supplied is found.+Example(s): {-# OPTIONS_GHC foo #-} Test case(s):tests safeHaskellflags/SafeFlags28 tests safeHaskellflags/SafeFlags19 tests safeHaskellflags/SafeFlags29 testsparser!should_fail/T19923c testsparser!should_fail/T19923b testsparser%should_fail/readFail044 testsdriverT2499׏ghc Builds a Ž& with the information provided by the ǎ.ŎghcThe pattern argumentsghc Is the parsed pattern recursive?܎ghc4Number of other occurrences other than the first oneghcconditional exprghc"then" semi-colon?ghc "then" exprghc"else" semi-colon?ghc "else" exprghcconditional exprghc"then" semi-colon?ghc "then" exprghc"else" semi-colon?ghc "else" exprghc Is TH on?Ïghcis Unicode forall?͏ghcthe problematic characterghcthe character it looks likeghc,the name of the character that it looks likeŽƎŎĎÎǎʎɎȎˎ͎̎ΎЎώю׎֎ՎԎӎҎ؎͏̏ˏʏɏȏǏƏŏďϏߎގݎێَ܎ڎΏҏяЏϏӏԏՏ֏׏ԏӏΏҏяЏϏ؎͏̏ˏʏɏȏǏƏŏďϏߎގݎێَ܎ڎю׎֎ՎԎӎҎΎЎώˎ͎̎ǎʎɎȎŽƎŎĎÎՏ֏׏ Safe-Inferred 9@ghcReasons why we need ticks,ghc For profilingghcFor Haskell Program Coverageghc%For ByteCode interpreter break pointsghcFor source notesghcWhether the number of times functions are entered should be counted.ghcWhere to insert ticksghcfor Hpcghcfor GHCighcfor -prof-auto-allghcfor -prof-auto-topghcfor -prof-auto-exportedghcfor stack tracingghcTick source spanghcPath to the declarationghcIdentifiers being boundghcLabel for the tick counterghcConfiguration for compilation pass to add tick for instrumentation to binding sites.ghc"What purposes do we need ticks forghc-What kind of {-# SCC #-} to add automaticallyghc)Whether to count the entries to functionsRequires extra synchronization which can vastly degrade performance.ghc1Decide whether to add a tick to a binding or not.ghcStrip CoreTicks from an HsExprghcA let body is treated differently from addTickLHsExprEvalInner above with TickForBreakPoints, because for breakpoints we always want to tick the body, even if it is not a redex. See test break012. This gives the user the opportunity to inspect the values of the let-bound variables.ghcTickishs that only make sense when their source code location refers to the current file. This might not always be true due to LINE pragmas in the code - which would confuse at least HPC.ghc:Get the next HPC cost centre index for a given centre nameghclocation of the current moduleghcExported Ids. When we call addTicksToBinds, isExportedId doesn't work yet (the desugarer hasn't set it), so we have to work from this set.ghc Type constructors in this moduleghc top level?ghc exported?ghcsimple pat bind?ghcINLINE pragma? Safe-Inferred <Gghc5Why TemplateHaskell rejected the splice. Used in the  constructor of a .ghc/Diagnostics messages emitted during desugaring.ghcSimply wraps a generic N message.ghcDsEmptyEnumeration is a warning (controlled by the -Wempty-enumerations flag) that is emitted if an enumeration is empty. Example(s):main :: IO () main = do let enum = [5 .. 3] print enumHere enum8 would yield an empty list, because 5 is greater than 3. Test case(s): warningsshould_compileT10930 warningsshould_compileT18402 warningsshould_compileT10930b numericshould_compileT10929 numericshould_compileT7881 deSugar should_runT18172ghcDsIdentitiesFound is a warning (controlled by the -Widentities flag) that is emitted on uses of Prelude numeric conversions that are probably the identity (and hence could be omitted). Example(s):main :: IO () main = do let x = 10 print $ conv 10where conv :: Int -> Int conv x = fromIntegral x Here calling conv is essentially the identity function, and therefore can be omitted.Test case(s): deSugarshould_compileT4488ghcThe list of unbound bindersghcThe original bindersghcThe original LHSghcThe optimised LHS Safe-InferredJ2ghcThe PRType (ty, tas) is short for (piResultTys ty (reverse tas))ghc Compute the  of an   / in a pure fashion.ghc Compute the  of an   / in a pure fashion. Safe-Inferred JghcSource Statistics Safe-InferredMy ghc The type constructor for queriesghc,Should EpAnnotations be removed from output.ghc+Should source spans be removed from output.ghc*Show the full AST as the compiler sees it.ghcShow a GHC syntax tree. This parameterised because it is also used for comparing ASTs in ppr roundtripping tests, where the SrcSpan's are blanked out, to avoid comparing locations, only structureghc.Extend a generic query by a type-specific caseghc/Type extension of queries for type constructorsghc/Type extension of queries for type constructorsghcFlexible type extensionghcFlexible type extension   Safe-InferredOghcRename a module from one name to another. The identity renaming means that the module should be brought into scope.ghcAn include of another unitghc Is this a dependency signature include? If so, we don't compile this include when we instantiate this unit (as there should not be any modules brought into scope.)ghcA declaration in a package, e.g. a module or signature definition, or an include.ghc Top level unit declaration in a Backpack file.   Safe-InferredQI}ghc3Show a SDoc as a String with the default user style}ghc.Allows caller to specify the NamePprCtx to use} }} }} }} } Safe-Inferred )*6<w(ghc Pass to a • the information whether or not the '-fbuilding-cabal-package' flag is set.•ghcA message from the driver.ÕghcSimply wraps a generic N message a.ĕghcA parse error in parsing a Haskell file header during dependency analysisŕghcDriverMissingHomeModules is a warning (controlled with -Wmissing-home-modules) that arises when running GHC in --make mode when some modules needed for compilation are not included on the command line. For example, if A imports B, `ghc --make A.hs` will cause this warning, while `ghc --make A.hs B.hs` will not.Useful for cabal to ensure GHC won't pick up modules listed neither in 'exposed-modules' nor in 'other-modules'.Test case: warningsshould_compile MissingModƕghcDriverUnknown is a warning that arises when a user tries to reexport a module which isn't part of that unit.ǕghcDriverUnknownHiddenModules is a warning that arises when a user tries to hide a module which isn't part of that unit.ȕghcDriverUnusedPackages occurs when when package is requested on command line, but was never needed during compilation. Activated by -Wunused-packages.Test cases: warningsshould_compileUnusedPackagesɕghcDriverUnnecessarySourceImports (controlled with -Wunused-imports) occurs if there are {-# SOURCE #-} imports which are not necessary. See warnUnnecessarySourceImports in .Test cases: warningsshould_compileT10637ʕghc5DriverDuplicatedModuleDeclaration occurs if a module A& is declared in multiple files.Test cases: None.˕ghc(DriverModuleNotFound occurs if a module A can't be found.Test cases: None.̕ghc0DriverFileModuleNameMismatch occurs if a module A is defined in a file with a different name. The first field is the name written in the source code; the second argument is the name extracted from the filename.Test cases: modulemod178, driver/bug1677͕ghc>DriverUnexpectedSignature occurs when GHC encounters a module A= that imports a signature file which is neither in the  signatures section of a '.cabal' file nor in any package in the home modules.Example:*- MyStr.hsig is defined, but not added to  signatures in the '.cabal' file. signature MyStr where data Str- A.hs, which tries to import the signature. module A where import MyStrTest cases: driver/T12955ΕghcDriverFileNotFound occurs when the input file (e.g. given on the command line) can't be found.Test cases: None.ϕghc1DriverStaticPointersNotSupported occurs when the StaticPointers9 extension is used in an interactive GHCi context.Test cases: ghciscripts StaticPtrЕghcDriverBackpackModuleNotFound occurs when Backpack can't find a particular module during its dependency analysis. Test cases: -ѕghcDriverUserDefinedRuleIgnored is a warning that occurs when user-defined rules are ignored. This typically happens when Safe Haskell. Test cases:tests safeHaskell%safeInfered/UnsafeWarn05 tests safeHaskell%safeInfered/UnsafeWarn06 tests safeHaskell%safeInfered/UnsafeWarn07 tests safeHaskell(safeInfered/UnsafeInfered11 tests safeHaskellsafeLanguage/SafeLang03ҕghcDriverMixedSafetyImport is an error that occurs when a module is imported both as safe and unsafe. Test cases:tests safeHaskellsafeInfered/Mixed03 tests safeHaskellsafeInfered/Mixed02ӕghcDriverCannotLoadInterfaceFile is an error that occurs when we cannot load the interface file for a particular module. This can happen for example in the context of Safe Haskell, when we have to load a module to check if it can be safely imported.Test cases: None.ԕghcDriverInferredSafeImport is a warning (controlled by the Opt_WarnSafe flag) that occurs when a module is inferred safe.Test cases: None.ՕghcDriverMarkedTrustworthyButInferredSafe is a warning (controlled by the Opt_WarnTrustworthySafe flag) that occurs when a module is marked trustworthy in SafeHaskell but it has been inferred safe.Test cases: tests safeHaskell)safeInfered/TrustworthySafe02 tests safeHaskellsafeInfered/TrustworthySafe03֕ghcDriverInferredSafeImport is a warning (controlled by the Opt_WarnInferredSafeImports flag) that occurs when a safe-inferred module is imported from a safe module.Test cases: None.וghcDriverCannotImportUnsafeModule is an error that occurs when an usafe module is being imported from a safe one.Test cases: None.ؕghcDriverMissingSafeHaskellMode is a warning (controlled by the Opt_WarnMissingSafeHaskellMode flag) that occurs when a module is using SafeHaskell features but SafeHaskell mode is not enabled.Test cases: None.ٕghcDriverPackageNotTrusted is an error that occurs when a package is required to be trusted but it isn't.Test cases: tests safeHaskellcheck/Check01 tests safeHaskellcheck/Check08 tests safeHaskellcheck/Check06 tests safeHaskellcheckpkg01ImpSafeOnly09 tests safeHaskellcheckpkg01ImpSafe03 tests safeHaskellcheckpkg01ImpSafeOnly07 tests safeHaskellcheckpkg01 ImpSafeOnly08ڕghcDriverCannotImportFromUntrustedPackage is an error that occurs in the context of Safe Haskell when trying to import a module coming from an untrusted package.Test cases: tests safeHaskellcheck/Check09 tests safeHaskellcheckpkg01ImpSafe01 tests safeHaskellcheckpkg01ImpSafe04 tests safeHaskellcheckpkg01ImpSafeOnly03 tests safeHaskellcheckpkg01ImpSafeOnly05 tests safeHaskellflags/SafeFlags17 tests safeHaskellflags/SafeFlags22 tests safeHaskellflags/SafeFlags23 tests safeHaskellghci/p11 tests safeHaskellghci/p12 tests safeHaskellghci/p17 tests safeHaskellghci/p3 tests safeHaskell'safeInfered/UnsafeInfered01 tests safeHaskell'safeInfered/UnsafeInfered02 tests safeHaskell'safeInfered/UnsafeInfered02 tests safeHaskell'safeInfered/UnsafeInfered03 tests safeHaskell'safeInfered/UnsafeInfered05 tests safeHaskell'safeInfered/UnsafeInfered06 tests safeHaskell'safeInfered/UnsafeInfered09 tests safeHaskell'safeInfered/UnsafeInfered10 tests safeHaskell'safeInfered/UnsafeInfered11 tests safeHaskell$safeInfered/UnsafeWarn01 tests safeHaskell$safeInfered/UnsafeWarn03 tests safeHaskell$safeInfered/UnsafeWarn04 tests safeHaskell$safeInfered/UnsafeWarn05 tests safeHaskell"unsafeLibs/BadImport01 tests safeHaskell"unsafeLibs/BadImport06 tests safeHaskell"unsafeLibs/BadImport07 tests safeHaskell"unsafeLibs/BadImport08 tests safeHaskell"unsafeLibs/BadImport09 tests safeHaskellunsafeLibs/Dep05 tests safeHaskellunsafeLibs/Dep06 tests safeHaskellunsafeLibs/Dep07 tests safeHaskellunsafeLibs/Dep08 tests safeHaskellunsafeLibs/Dep09 tests safeHaskellunsafeLibs/Dep10ݕghcA collection of driver messagesghcThe umbrella type that encompasses all the different messages that GHC might output during the different compilation stages. See Note [GhcMessage].ghc!A message from the parsing phase.ghc(A message from typecheck/renaming phase.ghc/A message from the desugaring (HsToCore) phase.ghcA message from the driver.ghcAn "escape" hatch which can be used when we don't know the source of the message or if the message is not one of the typed ones. The N and  constraints ensure that if we know, at pattern-matching time, the originating type, we can attempt a cast and access the fully-structured error. This would be the case for a GHC plugin that offers a domain-specific error type but that doesn't want to place the burden on IDEs/application code to "know" it. The N constraint ensures that worst case scenario we can still render this into something which can be eventually converted into a N.ghcA single warning message.  INVARIANT: It must have N severity.ghc!A collection of error messages.  INVARIANT: Each  in the collection should have N severity.ghc#A collection of warning messages.  INVARIANT: Each  in the collection should have N severity.ghcCreates a new  out of any diagnostic. This function is also provided to ease the integration of #18516 by allowing diagnostics to be wrapped into the general (but structured)  type, so that the conversion can happen gradually. This function should not be needed within GHC, as it would typically be used by plugin or library authors (see comment for the  type constructor)ghc9Abstracts away the frequent pattern where we are calling  ioMsgMaybe2 on the result of 'IO (Messages TcRnMessage, a)'.ghc9Abstracts away the frequent pattern where we are calling  ioMsgMaybe0 on the result of 'IO (Messages DsMessage, a)'.ghc-ghc -<<ghc >>-ghc*Used when the lexer can't make sense of itghcend of file tokenghcThe HsDocString contains more details about what this is and how to pretty print itghc(doc options (prune, ignore-exports, etc)ghccomment starting by "--"ghccomment in {- -}ghcThe parser has consumed a (possibly empty) prefix of the input and failed.The carried parsing state can be used to resume parsing. It is the state right before failure, including the fatal parse error.  and ' must return a non-empty bag of errors.ghcThe parser has consumed a (possibly empty) prefix of the input and produced a result. Use 9 to check for accumulated warnings and non-fatal errors.8The carried parsing state can be used to resume parsing.ghcIncludes the trailing '-}' decorators drop the last two elements with the callback if you don't want them to be includedghcTest whether a  is setghc1Given exactly the information needed, set up the ghc.Set parser options for parsing OPTIONS pragmasghcCreates a parse state from a  valueghcGet a bag of the errors that have been accumulated so far. Does not take -Werror into account.ghcGet the warnings and errors accumulated so far. Does not take -Werror into account.ghcGiven a  that surrounds a HsPar or HsParTy , generate , values for the opening and closing bordering on the start and end of the spanghcContinuation that gets the rest of the input and the lexed commentghcstarting value for accumulator (reversed) - When we want to include a decorator '{-' in the commentghc%permitted language extensions enabledghcdiagnostic optionsghc"Supported Languages and Extensionsghcare safe imports on?ghckeeping Haddock comment tokensghckeep regular comment tokensghcIf this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update the internal position kept by the parser. Otherwise, those pragmas are lexed as  and  tokens. Safe-Inferred()*/19:;>ghcDisambiguate constructs that may appear when we do not know ahead of time whether we are parsing a type or a newtype/data constructor.?See Note [Ambiguous syntactic categories] for the general idea.See Note [Parsing data constructors is hard] for the specific issue this particular class is solving.ghcProcess the head of a type-level function/constructor application, i.e. the H in H a b c.ghc Disambiguate f x3 (function application or prefix data constructor).ghc Disambiguate f @t (visible kind application)ghc Disambiguate f # x (infix operator)ghc Disambiguate {-# UNPACK #-} t (unpack/nounpack pragma)ghcDisambiguate constructs that may appear when we do not know ahead of time whether we are parsing an expression, a command, or a pattern. See Note [Ambiguous syntactic categories]ghcSee Note [Body in DisambECP]ghcInfix operator representationghc Function argument representationghcReturn a command without ambiguity, or fail in a non-command context.ghcReturn an expression without ambiguity, or fail in a non-expression context.ghc"Disambiguate "... -> ..." (lambda)ghcDisambiguate "let ... in ..."ghcBring superclass constraints on InfixOp into scope. See Note [UndecidableSuperClasses for associated types]ghc%Disambiguate "f # x" (infix operator)ghcDisambiguate "case ... of ..."ghcDisambiguate "case" and "cases"ghcBring superclass constraints on FunArg into scope. See Note [UndecidableSuperClasses for associated types]ghc)Disambiguate "f x" (function application)ghc.Disambiguate "f @t" (visible type application)ghc'Disambiguate "if ... then ... else ..."ghc'Disambiguate "do { ... }" (do notation)ghc$Disambiguate "( ... )" (parentheses)ghc2Disambiguate a variable "f" or a data constructor MkF.ghc"Disambiguate a monomorphic literalghc"Disambiguate an overloaded literalghcDisambiguate a wildcardghc'Disambiguate "a :: t" (type annotation)ghc$Disambiguate "[a,b,c]" (list syntax)ghc5Disambiguate "$(...)" and "[quasi|...|]" (TH splices)ghcDisambiguate "f { a = b, ... }" syntax (record construction and record updates)ghcDisambiguate "-a" (negation)ghc-Disambiguate "(# a)" (right operator section)ghc&Disambiguate "(a -> b)" (view pattern)ghcDisambiguate "a@b" (as-pattern)ghc Disambiguate "~a" (lazy pattern)ghc Disambiguate "!a" (bang pattern)ghc,Disambiguate tuple sections and unboxed sumsghcValidate infixexp LHS to reject unwanted {-# SCC ... #-} pragmasghcDisambiguate infix operators. See Note [Ambiguous syntactic categories]ghcResult of parsing {-# UNPACK #-} or {-# NOUNPACK #-}.ghcEssentially a wrapper for a RuleBndr GhcPsghcmkClassDecl builds a RdrClassDecl, filling in the names for tycon and datacon by deriving them from the name of the class. We fill in the names for the tycon and datacon corresponding to the class, by deriving them from the name of the class itself. This saves recording the names in the interface file (which would be equally good).ghcConverts a list of Ts annotated with their  to binders without annotations. Only accepts specified variables, and errors if any of the provided binders has an & annotation.ghc Converts T annotated with its  to one without annotations. Only accepts specified variables, and errors if the provided binder has an & annotation.ghcAdd the annotation for a 'where' keyword to existing  HsLocalBindsghcThe , for a stmtlist is based on either the location or the first semicolon annotion.ghcFunction definitions are restructured here. Each is assumed to be recursive initially, and non recursive definitions are discovered by the dependency analyser.ghcReinterpret a type constructor, including type operators, as a data constructor. See Note [Parsing data constructors is hard]ghcConstruct a GADT-style data constructor from the constructor names and their type. Some interesting aspects of this function:This splits up the constructor type into its quantified type variables (if provided), context (if provided), argument types, and result type, and records whether this is a prefix or record GADT constructor. See Note [GADT abstract syntax] in  GHC.Hs.Decls for more details.ghcThis rather gruesome function is used mainly by the parser. When parsing: data T a = T | T1 Int"we parse the data constructors as types? because of parser ambiguities, so then we need to change the  type constr to a  data constrThe exact-name case can occur when parsing: data [] a = [] | a : [a]3For the exact-name case we return an original name.ghcCheck whether the given list of type parameters are all type variables (possibly with a kind signature).ghcCheck if the gadt_constrlist is empty. Only raise parse error for `data T where` to avoid affecting existing error message, see #8258.ghcYield a parse error if we have a function applied directly to a do block etc. and BlockArguments is not enabled.ghcValidate the context constraints and break up a context into a list of predicates.  (Eq a, Ord b) --> [Eq a, Ord b] Eq a --> [Eq a] (Eq a) --> [Eq a] (((Eq a))) --> [Eq a] ghcAnnotate a type with either an {-# UNPACK #-} or a {-# NOUNPACK #-} pragma.ghcCheck for monad comprehensions1If the flag MonadComprehensions is set, return a X# context, otherwise use the usual X contextghcEnsure that a literal pattern isn't of type Addr#, Float#, Double#.ghcRejects declarations such as  data T = 'MkT (note the leading tick).ghcCheck if a fixity is valid. We support bypassing the usual bound checks for some special operators.ghc#Hint about bang patterns, assuming  BangPatterns is off.ghc precedenceghc operators֏ǎȎɎʎ֏ǎȎɎʎ Safe-Inferred(9͐ ghc#16895 Ensure an infix expression's operator is a variable/constructor. Consider this example: $(uInfixE [|1|] [|id id|] [|2|])This infix expression is obviously ill-formed so we use this helper function to reject such programs outright.The constructors  permits should be in sync with  pprInfixExp> in Language.Haskell.TH.Ppr from the template-haskell library.ghccvtOpApp x op y converts op and y' and produces the operator application x op y. The produced tree of infix expressions will be left-biased, provided x is.We can see that cvtOpApp9 is correct as follows. The inductive hypothesis is that cvtOpApp x op y is left-biased, provided x7 is. It is clear that this holds for both branches (of cvtOpApp:), provided we assume it holds for the recursive calls to cvtOpApp. When we call cvtOpApp from cvtl, the first argument will always be left-biased since we have already run cvtl on it.ghccvtOpAppP x op y converts op and y' and produces the operator application x op y. The produced tree of infix patterns will be left-biased, provided x is.See the cvtOpApp+ documentation for how this function works.ghcConvert a Template Haskell  to an T%. To avoid duplicating the logic in  here, we simply reuse  and perform surgery on the T it returns to turn it into an T.ghcConstructs an application of a type to arguments passed in a list.ghccvtOpAppT x op y converts op and y' and produces the operator application x op y. The produced tree of infix types will be right-biased, provided y is.See the cvtOpApp+ documentation for how this function works.ghcConvert Maybe Kind to a type family result signature. Used with data families where naming of the result is not possible (thus only kind or no signature is possible).ghcConvert type family result signature. Used with both open and closed type families.ghc0Convert injectivity annotation of a type family.ghcIf passed an empty list of T/s, this simply returns the third argument (an T). Otherwise, return an T using the provided T and T.ghcIf passed an empty ., this simply returns the third argument (an T). Otherwise, return an T using the provided T and T.ghc lc returns J if lc is empty and K lc otherwise.This is much like , except that it returns a @ (T /). This is used specifically for constructing superclasses, datatype contexts (#20011), and contexts in GADT constructor types (#20590). We wish to avoid using K [] in the case of an empty contexts, as the pretty-printer always prints K" contexts, even if they're empty.ghcconvert constructor nameghcThe location of the returned T" if it needs an explicit forallghc#The converted type variable bindersghcThe converted rho typeghc8The complete type, quantified with a forall if necessaryghc%The original Template Haskell contextghcThe location of the returned T# if it needs an explicit contextghcThe converted contextghcThe converted tau typeghc8The complete type, qualified with a context if necessary Safe-Inferred .ghc#Extract identifier from Alex state.ghcLex  for warning messagesghc!Lex identifiers from a docstring.ghcadornment lengthghc Token lengthghc2The remaining input beginning with the found tokenghcA precise identifier parserghcA precise identifier parser Safe-Inferred'49Sghc,Represents a predicate on the column number.ColumnBound | Int -> Bool --------------+----------------- ColumnFrom n | (>=n)+The semigroup instance corresponds to (&&).ghcWarnings accumulated in HdkM.ghcThe state of HdkM.ghcAdd Haddock documentation accumulated in the parser state to a parsed HsModule.Reports badly positioned comments when -Winvalid-haddock is enabled.ghcThe inverse of  that merges partitioned items back into a flat list. Elements are put back into the order in which they appeared in the original program before partitioning, using BufPos to order them.=Precondition (unchecked): the input lists are already sorted. Safe-InferredghcInsert alignment checks (cf -falignment-sanitisation)   Safe-InferredӆghcReturn the UnitId of the home-unit. This is used to create labels.   Safe-Inferred)*1ؤghcConstruct an AddEpAnn from the annotation keyword and the location of the keyword itselfghcConstruct an AddEpAnn from the annotation keyword and the location of the keyword itself, provided the span is not zero widthghcConstruct an AddEpAnn from the annotation keyword and the Located Token. If the token has a unicode equivalent and this has been used, provide the unicode variant of the annotation.ghcIf the  is using its unicode variant return the unicode variant of the annotationghc6Synonyms for AddEpAnn versions of AnnOpen and AnnCloseghc6Synonyms for AddEpAnn versions of AnnOpen and AnnCloseghcParse a Haskell module with Haddock comments. This is done in two steps: to build the AST# to insert Haddock comments into itThis is the only parser entry point that deals with Haddock comments. The other entry points (, (, etc) do not insert them into the AST.ghcInstead of getting the *enclosed* comments, this includes the *preceding* ones. It is used at the top level to get comments between top level declarations.9 9  Safe-InferredhghcReturns True! if passed string is a statement.ghcReturns True, if passed string has an import declaration.ghcReturns True+ if passed string is an import declaration.ghcReturns True' if passed string is a declaration but  not a splice. Safe-Inferred )*1ں Safe-Inferred )*1UghcSuggests a list of M" for the '.hsig' file to the user. Safe-Inferred7ghcA source error is an error that is caused by one or more errors in the source code. A  is thrown by many functions in the compilation pipeline. Inside GHC these errors are merely printed via  log_action, but API clients may treat them differently, for example, insert them into a list box. If you want the default behaviour, use the idiom: handleSourceError printExceptionAndWarnings $ do ... api calls that may fail ...The %s error messages can be accessed via 8. This list may be empty if the compiler failed due to -Werror (Opt_WarnIsError).See printExceptionAndWarnings for more information on what to take care of when writing a custom error handler.ghcPerform the given action and call the exception handler if the action throws a . See  for more information.ghcexception handlerghcaction to perform Safe-Inferredghc#Parse the imports of a source file. Throws a  if parsing fails.ghc6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a 5 if flag parsing fails (including unsupported flags.)ghc6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a 5 if flag parsing fails (including unsupported flags.)ghc4Complain about non-dynamic flags in OPTIONS pragmas. Throws a  if the input list is non-empty claiming that the input flags are unknown.ghcParser optionsghcImplicit Prelude?ghc Parse this.ghcFilename the buffer came from. Used for reporting parse error locations.ghcThe original source filename (used for locations in the function result)ghcThe source imports and normal imports (with optional package names from -XPackageImports), and the module name.ghc Input fileghcParsed options, if any.ghc Input Bufferghc)Source filename. Used for location info.ghcwarnings and parsed options. Safe-InferredghcGiven a bag of diagnostics, turn them into an exception if any has N, or print them out otherwise.ghc Convert a PsError into a wrapped •; use it for dealing with parse errors when the driver is doing dependency analysis. Defined here to avoid module loops between GHC.Driver.Error.Types and GHC.Driver.Error.Ppr Safe-Inferredghc)Initialize StgToJS settings from DynFlags Safe-Inferred5 Safe-Inferredghc4Initialize STG pretty-printing options from DynFlags Safe-Inferred Safe-InferredC}ghc!Initialize LogFlags from DynFlags}} Safe-Inferredw Safe-Inferred Safe-Inferredghc Create a new } from DynFlags.}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-Inferred–ghcInitialise the general configuration for printing diagnostic messages For example, this configuration controls things like whether warnings are treated like errors.ÖghcInitialise the configuration for printing specific diagnostic messages–ÖĖƖŖǖ–ÖĖƖŖǖ Safe-Inferred$ghc%Extracts the flags needed for parsing Safe-Inferredghc!Initialize RuleOpts from DynFlags Safe-Inferred Safe-Inferred=ghc>Initialize the Llvm code generator configuration from DynFlags Safe-Inferreds Safe-Inferred  Safe-Inferred SghcLike +, but doesn't catch asynchronous exceptions}ghcAtomically update the reference. Does not force the evaluation of the new variable contents. For strict update, use }.}ghcStrict variant of }.}ghc2Perform a computation with a different environment}ghc1Perform a computation with an altered environment8}24 !"ef}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-InferredlghcSame as l# but simplifies the unfolding firstlghc0Used for things that absolutely must be unfoldedlghcMake an INLINE unfolding that may be used unsaturated (ug_unsat_ok = unSaturatedOk) and that is reported as having its manifest arity (the number of outer lambdas applications will resolve before doing any work).lghcMake an INLINE unfolding that will be used once the RHS has been saturated to the given arity.lghcSees if the unfolding is pretty certain to inline. If so, return a *stable* unfolding for it, that will always inline. The CoreExpr is the WW'd and simplified RHS. In contrast, the unfolding template might not have been WW'd yet.]llllllllllllllll]llllllllllllllll Safe-Inferred ^ghcSimple optimiser options^ghcUnfolding optionsghcSimplifier optionsghcDeals with preInlineUnconditionally; things that occur exactly once and are inlined without having first been simplifiedghc+Deals with cloning; includes the InScopeSetghcFast OutVarSet tracking which recursive RHSs we are analysing. See Note [Eta reduction in recursive RHSs]zghcCoercion optimiser optionszghcEta reduction on?zghc)Default options for the Simple optimiser.zghcReturns Just (bndr,rhs) if the binding is a join point: If it's a JoinId, just return it If it's not yet a JoinId but is always tail-called, make it into a JoinId and return it. In the latter case, eta-expand the RHS if necessary, to make the lambdas explicit, as is required for join pointsPrecondition: the InBndr has been occurrence-analysed, so its OccInfo is validzghcReturns 'Just ([b1..bp], dc, [t1..tk], [x1..xn]) if the argument expression is a *saturated* constructor application of the form *let b1 in .. let bp in dc t1..tk x1 .. xn>, where t1..tk are the *universally-quantified* type args of dc. Floats can also be (and most likely are) single-alternative case expressions. Why does z return floats? We may have to look through lets and cases to detect that we are in the presence of a data constructor wrapper. In this case, we need to return the lets and cases that we traversed. See Note [exprIsConApp_maybe on data constructors with wrappers]. Data constructor wrappers are unfolded late, but we really want to trigger case-of-known-constructor as early as possible. See also Note [Activation for data constructor wrappers] in GHC.Types.Id.Make.We also return the incoming InScopeSet, augmented with the binders from any [FloatBind] that we return^z^zzzz^zzzzzz^z^zzzz^zzzzzz Safe-Inferred @ghcData Constructor BoxerzghcStrict fields by defaultzghc?Disable automatic field unboxing (e.g. if we aren't optimising)zghcUnbox strict fieldszghcUnbox small strict fieldszghcUsed for imported data constructors See Note [Bangs on imported data constructors]ghcConjure a fresh local binder.ghc/Unpack/Strictness decisions from source module.This function should only ever be invoked for data constructor fields, and never on the field of a newtype constructor. See Note [HsImplBangs for newtypes].ghcWrappers+Workers and representation following UnpackStrictness decisionsghcEvery alternative of an unboxed sum has exactly one field, and we use unboxed tuples when we need more than one field. This generates an unboxed tuple when necessary, to be used in unboxed sum alts.ghc%a string which will form part of the 's nameghcthe type of the *z@zzzz@zzz@zzzzzzzzzzzzzzzzzz8zzzzzzzzzzzz*z@zzzz@zzz@zzzzzzzzzzzzzzzzzz8zzzzzzzzzzzz Safe-Inferredҫҫ Safe-Inferred Safe-Inferred(Y!ghc8What part (2) of Note [Worker/wrapper for CPR] collects. A 2 capturing whether the split does anything useful.-The list of transit variables (see the Note).The result builder expression for the wrapper. The original case binder if not useful.0The result unpacking expression for the worker.  if not useful.ghc Returned by 9. See also Note [Detecting recursive data constructors].ghcThe algorithm detected a loopghcThe algorithm detected no loop, went out of fuel or hit an .hs-boot fileghc'Is the worker/wrapper split profitable?ghcDescribes the outer shape of an argument to be unboxed or left as-is Depending on how s is instantiated (e.g., Z or [).ghc/We ran out of strictness info. Leave untouched.ghcThe argument is used strictly or the returned product was constructed, so unbox it.ghc'The argument/field was absent. Drop it.ghcThe information needed to build a pattern for a DataCon to be unboxed. The pattern can be generated from  and  via j. The coercion  is for newtype wrappers. If we get DataConPatContext dc tys co for some type ty and *dataConRepInstPat ... dc tys = (exs, flds), thendc exs flds :: T tys@ co :: T tys ~ tys will be Z or [.ghc)Environment of type/data family instancesghc"Options for the "Simple optimiser"ghcWhether to enable "Constructed Product Result" analysis. (Originally from DOI: 10.1017/S0956796803004751)ghc&Used for absent argument error messageghcGenerate workers even if the only effect is some args get passed unlifted. See Note [WW for calling convention]ghcGiven a function definition data T = MkT Int Bool Char f :: (a, b) -> Int -> T f = \x y -> E mkWwBodies _ f7 ['x::(a,b)','y::Int'] '(a,b)' ['1P(L,L)', '1P(L)'] '1' returnsThe wrapper body context for the call to the worker function, lacking only the  for the worker function: W[_] :: Id -> CoreExpr W[work_fn] = \x y -> -- args of the wrapper (cloned_arg_vars) case x of (a, b) -> -- unbox wrapper args (wrap_fn_str) case y of I# n -> -- case a b n of -- call to the worker fun (call_work) (# i, b, c #) -> MkT i b c -- rebox result (wrap_fn_cpr)The worker body context that wraps around its hole reboxing defns for x and y, as well as returning CPR transit variables of the unboxed MkT result in an unboxed tuple: w[_] :: CoreExpr -> CoreExpr w[fn_rhs] = \a b n -> -- args of the worker (work_lam_args) let { y = I# n; x = (a, b) } in -- reboxing wrapper args (work_fn_str) case x y of -- call to the original RHS (call_rhs) MkT i b c -> (# i, b, c #) -- return CPR transit vars (work_fn_cpr)NB: The wrap_rhs hole is to be filled with the original wrapper RHS x y -> E". This is so that we can also use w to transform stable unfoldings, the lambda args of which may be different than x and y.Id details for the worker function like demands on arguments and its join arity.All without looking at E (except for beta reduction, see Note [Join points and beta-redexes]), which allows us to apply the same split to function body and its unfolding(s) alike.ghc Version of ] that does beta reduction on-the-fly. PRECONDITION: The arg expressions are not free in any of the lambdas binders.ghc'Whether the worker needs an additional `Void#` arg as per Note [Protecting the last value argument] or Note [Preserving float barriers].ghc Inserts a `Void#` arg as the last argument. Why last? See Note [Worker/wrapper needs to add void arg last]ghc0Do we want to create workers just for unlifting?ghcWW split not profitableghcWW split profitableghc Unwraps the  decision encoded in the given Z and returns a - as well the nested demands on fields of the # to unbox.ghc*Unboxing strategy for constructed results.ghcTries to find a suitable absent filler to bind the given absent identifier to. See Note [Absent fillers].If mkAbsentFiller _ id == Just e, then e, is an absent filler with the same type as id/. Otherwise, no suitable filler could be found.ghcExactly S3, but lacks the (ASSERT'ed) precondition that the # may not have existentials. The lack of cloning the existentials this function "dubious"; only use it where type variables aren't substituted for! Why may the data con bind existentials? See Note [Which types are unboxed?]ghcisRecDataCon _ fuel dc, where tc = dataConTyCon dc returnsDefinitelyRecursive if the analysis found that tc" is reachable through one of dc's arg_tys.NonRecursiveOrUnsure if the analysis found that tc& is not reachable through one of dc$'s fields (so surely non-recursive).NonRecursiveOrUnsure when fuel /= Infinity and fuel expansions of nested data TyCons were not enough to prove non-recursiveness, nor arrive at an occurrence of tc thus proving recursiveness. (So not sure if non-recursive.)NonRecursiveOrUnsure when we hit an abstract TyCon (one without visible DataCons), such as those imported from .hs-boot files. Similarly for stuck type and data families.If fuel = Infinity and there are no boot files involved, then the result is never Nothing. and the analysis is a depth-first search. If fuel = > f, then the analysis behaves like a depth-limited DFS and returns Nothing! if the search was inconclusive.See Note [Detecting recursive data constructors] for which recursive DataCons we want to flag.ghcEntrypoint to CPR WW. See Note [Worker!wrapper for CPR] for an overview.ghc*Part (1) of Note [Worker/wrapper for CPR].ghc3See if we want to unbox the result and hand off to .ghcImplements the main bits of part (2) of Note [Worker/wrapper for CPR]ghc5Implements part (3) of Note [Worker/wrapper for CPR].8If `move_transit_vars [a,b] = (unbox, tup)` then * a and b are the *transit vars* to be returned from the worker to the wrapper * `unbox scrut alt = (case  scrut of (# a, b #) ->  alt)` * `tup = (# a, b #)` There is a special case for when there's 1 transit var, see Note [No unboxed tuple for single, unlifted transit var].ghcThe multiplicity of a case binder unboxing a constructed result. See Note [Linear types and CPR]ghcThe original functionghc"Manifest args of original functionghcResult type of the original function, after being stripped of argsghcStrictness of original functionghcInfo about function resultghcType of the argumentghcHow the arg was used   Safe-Inferred&ghcAn environment storing [$s for local Ids. Puts binders with \ in a space-saving IntSet+. See Note [Efficient Top sigs in SigEnv].ghcAll these Ids have \ . Like a VarSet, but more efficient.ghc#Ids that have something other than \.ghc1Current approximation of signatures for local idsghcTrue only on every first iteration in a fixed-point iteration. See Note [Initialising strictness] in GHC.Core.Opt.DmdAnalghcNeeded when expanding type families and synonyms of product types.ghcMemoised result of ghcThe abstract semantic function O_O : Expr -> Env -> A from "Constructed Product Result Analysis for Haskell"ghcThe abstract semantic function O_O : Expr -> Env -> A from "Constructed Product Result Analysis for Haskell"ghc5Precise, hand-written CPR transformers for select IdsghcGet a (possibly nested) [ for an application of a #& worker, given a saturated number of [s for its field expressions. Implements the Nested part of Note [Nested CPR].ghc$See Note [Trimming to mAX_CPR_SIZE].ghcProcess the RHS of the binding for a sensible arity, add the CPR signature to the Id, and augment the environment with the signature as well.ghcReturns an expandable unfolding (See Note [exprIsExpandable] in GHC.Core.Utils8) that has So effectively is a constructor application.ghc2Extend an environment with the (Id, CPR sig) pairsghc;Extend an environment with the CPR sigs attached to the idsghc7Extend an environment with the same CPR sig for all idsghc A version of  for a binder of which we don't see the RHS needed to compute a [ (e.g. lambdas and DataAlt field binders). In this case, we can still look at their demand to attach CPR signatures anticipating the unboxing done by worker/wrapper. See Note [CPR for binders that will be unboxed].ghc Produces a [? according to how a strict argument will be unboxed. Examples:A head-strict demand 1!L would translate to 1A product demand  1!P(1!L,L) would translate to 1(1,)A product demand  1!P(1L,L) would translate to 1(,)3, because the first field will not be unboxed.ghcexpression to be denoted by a [ghcthe updated expression and its [ghcexpression to be denoted by a [ghcthe updated expression and its [ghcCPR type of the scrutineeghccurrent alternativeghcThe analysis environmentghc The functionghcinfo about incoming value argumentsghc"The demand type of the application Safe-Inferred)/ghcSee Note [Thunk splitting].splitThunk converts the *non-recursive* binding x = e into x = let x' = e in case x' of I# y -> let x' = I# y in x' See comments above. Is it not beautifully short? Moreover, it works just as well when there are several binders, and if the binders are lifted E.g. x = e --> x = let x' = e in case x' of (a,b) -> let x' = (a,b) in x' Here, x' is a localised version of x, in case x is a top-level Id with an External Name, because Lint rejects local binders with External Names; see Note [About the NameSorts] in GHC.Types.Name.How can we do thunk-splitting on a top-level binder? See Note [Thunk splitting for top-level binders]. Safe-Inferred..ghcliberate case optionsghcCurrent level The level is incremented when (and only when) going inside the RHS of a (sufficiently small) recursive function.ghcBinds all non-top-level in-scope Ids (top-level and imported things have a level of zero)ghcBinds *only* recursively defined ids, to their own binding group, and *only* in their own RHSsghcEach of these Ids was scrutinised by an enclosing case expression, at a level deeper than its binding level.The first LibCaseLevel is the *binding level* of the scrutinised Id, The second is the level *at which it was scrutinised*. (see Note [Avoiding fruitless liberate-case]) The former is a bit redundant, since you could always look it up in lc_lvl_env, but it's just cached here-The order is insignificant; it's a bag reallyThere's one element per scrutinisation; in principle the same Id may appear multiple times, although that'd be unusual: case x of { (a,b) -> ....(case x of ...) .. }ghc#Options for the liberate case pass.ghc?Bomb-out size for deciding if potential liberatees are too big.ghcUnfolding options Safe-Inferred.ghcInitialize configuration for the liberate case Core optomization pass. Safe-InferredLghcAnalysis optionsghcTrue on first iteration only. See Note [Initialising strictness]ghcMemoised result of ghc:An environment in which all demands are weak according to Z2. See Note [Lazy and unleashable free variables].ghcOptions for the demand analysisghcValue of `-fdicts-strict` (on by default). When set, all functons are implicitly strict in dictionary args.ghcGoverns whether the analysis should update boxity signatures. See Note [Don't change boxity without worker/wrapper].ghcValue of `-fdmd-unbox-width`. See Note [Unboxed demand on function bodies returning small products]ghcValue of `-fmax-worker-args`. Don't unbox anything if we end up with more than this many args.ghcOutputs a new copy of the Core program in which binders have been annotated with demand and strictness information. Note: use seqBinds on the result to avoid leaks due to lazyness (cf Note [Stamp out space leaks in demand analysis])ghcWe attach useful (e.g. not Z) a3 to top-level bindings that satisfy this function.Basically, we want to know how top-level *functions* are *used* (e.g. called). The information will always be lazy. Any other top-level bindings are boring.;See also Note [Why care for top-level demand annotations?].ghcAnalyse a binding group and its "body", e.g. where it is in scope.It calls a function that knows how to analyse this "body" given an  with updated demand signatures for the binding group (reflecting their  idDmdSigInfo) and expects to receive a Z in return, which it uses to annotate the binding group with their a.ghc-Annotates uninteresting top level functions () with Z!, the rest with the given demand.ghcUpdate the demand signature, but be careful not to change boxity info if  is True or if the signature is bottom. See Note [Don't change boxity without worker/wrapper] and Note [Boxity for bottoming functions].ghcLet bindings can be processed in two ways: Down (RHS before body) or Up (body before RHS). This function handles the up variant.It is very simple. For let x = rhs in body * Demand-analyse body2 in the current environment * Find the demand, rhs_dmd placed on x by body * Demand-analyse rhs in rhs_dmdThis is used for a non-recursive local let without manifest lambdas (see ).This is the LetUp rule in the paper @Higher-Order Cardinality Analysis@.ghcLet bindings can be processed in two ways: Down (RHS before body) or Up (body before RHS). This function handles the down variant.,It computes a demand signature (by means of +) and uses that at call sites in the body.It is used for toplevel definitions, recursive definitions and local non-recursive definitions that have manifest lambdas (cf. ). Local non-recursive definitions without a lambda are handled with LetUp.This is the LetDown rule in the paper @Higher-Order Cardinality Analysis@.ghcMimic the effect of , turning non-trivial argument expressions/RHSs into a proper let-bound thunk (lifted) or a case (with unlifted scrutinee).ghcA simple, syntactic analysis of whether an expression MAY throw a precise exception when evaluated. It's always sound to return L<. See Note [Which scrutinees may throw precise exceptions].ghc Recognises types that are * State# RealWorld * Unboxed tuples with a State# RealWorld+ field modulo coercions. This will detect D actions (even post Nested CPR! See T13380e) and user-written variants thereof by their type.ghc dmdAnalRhsSig analyses the given RHS to compute a demand signature for the LetDown rule. It works as follows:0assuming the weakest possible body sub-demand, Llooking at the definition"determining a strictness signatureSince it assumed a body sub-demand of L, the resulting signature is applicable at any call site.ghcThe result type after applying a many arguments. Returns J% when the type doesn't have exactly a many arrows.ghc.If given the (local, non-recursive) let-bound ,  determines whether we should process the binding up (body before rhs) or down (rhs before body).We use LetDown if there is a chance to get a useful strictness signature to unleash at call sites. LetDown is generally more precise than LetUp if we can correctly guess how it will be used in the body, that is, for which incoming demand the strictness signature should be computed, which allows us to unleash higher-order demands on arguments at call sites. This is mostly the case whenThe binding takes any arguments before performing meaningful work (cf. a;), in which case we are interested to see how it uses them.The binding is a join point, hence acting like a function, not a value. As a big plus, we know *precisely* how it will be used in the body; since it's always tail-called, we can directly unleash the incoming demand of the let binding on its RHS when computing a strictness signature. See [Demand analysis for join points].Thus, if the binding is not a join point and its arity is 0, we have a thunk and use LetUp, implying that we have no usable demand signature available when we analyse the let body.;Since thunk evaluation is memoised, we want to unleash its Z of free vars at most once, regardless of how many times it was forced in the body. This makes a real difference wrt. usage demands. The other reason is being able to unleash a more precise product demand on its RHS once we know how the thunk was used in the let body.=Characteristic examples, always assuming a single evaluation:let x = 2*y in x + x => LetUp. Compared to LetDown, we find out that the expression uses y at most once.let x = (a,b) in fst x6 => LetUp. Compared to LetDown, we find out that b is absent.let f x = x*2 in f y => LetDown. Compared to LetUp, we find out that the expression uses y strictly, because we have f4's demand signature available at the call site.>join exit = 2*y in if a then exit else if b then exit else 3*y => LetDown. Compared to LetUp, we find out that the expression uses y' strictly, because we can unleash exit's signature at each call site.For a more convincing example with join points, see Note [Demand analysis for join points].ghc9How many registers does this type take after unarisation?ghc Unset the  flag if any of the given bindings is a DFun binding. Part of the mechanism that detects Note [Do not strictify a DFun's parameter dictionaries].ghcExtend an environment with the strictness sigs attached to the Idsghc7Demand put on the "body" (important for join points)ghcHow to analyse the "body", e.g. where the binding is in scopeghcThe analysis environmentghc The variableghc!The evaluation context of the varghcThe demand type unleashed by the variable in this context. The returned DmdEnv includes the demand on this function plus demand on its free variables See Note [What are demand signatures?] in GHC.Types.DemandghcType of the let-bound IdghcHow the Id is used~ Safe-Inferred v%ghc%< is an abstract type that supports the following operations:Pretty printingIn a C file, does it need to be declared before use? (i.e. is it guaranteed to be already in scope in the places we need to refer to it?)If it needs to be declared, what type (code or data) should it be declared to have?.Is it visible outside this object file or not?#Is it "dynamic" (see details below)Eq and Ord, so that we can make sets of CLabels (currently only used in outputting C as far as I can tell, to avoid generating more than one declaration for any given label).3Converting an info table label into an entry label.CLabel usage is a bit messy in GHC as they are used in a number of different contexts:!By the C-- AST to identify labelsBy the unregisterised C code generator ("PprC") for naming functions (hence the name %)9By the native and LLVM code generators to identify labelsFor extra fun, each of these uses a slightly different subset of constructors (e.g.  and / are used only in the NCG and LLVM backends).In general, we use  to represent Haskell things early in the pipeline. However, later optimization passes will often represent blocks they create with  where there is no obvious  to hang off the label.mghcStyle of label pretty-printing.When we produce C sources or headers, we have to take into account that C compilers transform C labels when they convert them into symbols. For example, they can add prefixes (e.g., "_" on Darwin) or suffixes (size for stdcalls on Windows). So we provide two ways to pretty-print CLabels: C style or Asm style.mghc+C label style (used by C and LLVM backends)mghc%Asm label style (used by NCG backend)mghcInfo Table Provenance Entry See Note [Mapping Info Tables to Source Positions]ghcWhat type of Cmm label we're dealing with. Determines the suffix appended to the name when a CLabel.CmmLabel is pretty printed.ghc'misc rts info tables, suffix _infoghc(misc rts entry points, suffix _entryghc'misc rts ret info tables, suffix _infoghc&misc rts return points, suffix _retghc'misc rts data bits, eg CHARLIKE_closureghc misc rts codeghcclosures eg CHARLIKE_closureghc)a prim call to some hand written Cmm codeghcSelector thunksghc AP thunksghc_fast versions of generic applymghc=Which module is the info table from, and which number was it.ghcLabel for closureghc*Info tables for closures; always read-onlyghc Entry pointghcSlow entry pointghc)Like InfoTable but not externally visibleghc%Like Entry but not externally visibleghc7Label of place to keep Ticky-ticky hit info for this IdghcConstructor entry point, when `-fdistinct-info-tables` is enabled then each usage of a constructor will be given a unique number and a fresh info table will be created in the module where the constructor is used. The argument is used to keep track of which info table a usage of a constructor should use. When the argument is J then it uses the info table which is defined in the module where the datatype is declared, this is the usual case. When it is (Just (m, k)) it will use the kth info table defined in module m. The point of this inefficiency is so that you can work out where allocations of data constructors are coming from when you are debugging.ghcCorresponding info tableghc!Table of closures for Enum tyconsghc5Content of a string literal. See Note [Bytes label].ghcLike LocalInfoTable but for a proc-point block instead of a closure entry-point. See Note [Proc-point local block entry-points].ghcUsed for dynamic allocationsghc,Used to track dynamic hits of tag inference.mghc'Record where a foreign label is stored.mghcLabel is in a named packagemghcLabel is in some external, system package that doesn't also contain compiled Haskell code, and is not associated with any .hi files. We don't have to worry about Haskell code being inlined from external packages. It is safe to treat the RTS package as "external".mghcLabel is in the package currently being compiled. This is only used for creating hacky tmp labels during code generation. Don't use it in any code that might be inlined across a package boundary (ie, core code) else the information will be wrong relative to the destination module.mghc Indicate if  GHC.CmmToC has to generate an extern declaration for the label (e.g. "extern StgWordArray(foo)"). The type is fixed to StgWordArray.Symbols from the RTS don't need "extern" declarations because they are exposed via "rtsinclude&Stg.h" with the appropriate type. See n.The fixed StgWordArray type led to "conflicting types" issues with user provided Cmm files (not in the RTS) that declare data of another type (#15467 and test for #17920). Hence the Cmm parser considers that labels in data sections don't need the "extern" declaration (just add one explicitly if you need it).See  https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/backends/ppr-c#prototypes/ for why extern declaration are needed at all.ghcA label related to the definition of a particular Id or Con in a .hs file.ghcA label from a .cmm file that is not associated with a .hs level Id.ghcA label with a baked-in / algorithmically generated name that definitely comes from the RTS. The code for it must compile into libHSrts.a / libHSrts.so If it doesn't have an algorithmically generated name then use a CmmLabel instead and give it an appropriate UnitId argument.ghcA label associated with a block. These aren't visible outside of the compilation unit in which they are defined. These are generally used to name blocks produced by Cmm-to-Cmm passes and the native code generator, where we don't have a 4 to associate the label to and therefore can't use .ghcA C (or otherwise foreign) label.ghcLocal temporary label used for native (or LLVM) code generation; must not appear outside of these contexts. Use primarily for debug informationghcA label "derived" from another % by the addition of a suffix. Must not occur outside of the NCG or LLVM code generators.ghcA per-module metadata label.ghcThese labels are generated and used inside the NCG only. They are special variants of a label used for dynamic linking see module GHC.CmmToAsm.PIC for details.ghcThis label is generated and used inside the NCG only. It is used as a base for PIC calculations on some platforms. It takes the form of a local numeric assembler label '1'; and is pretty-printed as 1b, referring to the previous definition of 1: in the assembler source file.ghcA label before an info table to prevent excessive dead-stripping on darwinghc"Per-module table of tick locationsghcStatic reference tableghc"A bitmap (function or case return)mghcFor debugging problems with the CLabel representation. We can't make a Show instance for CLabel because lots of its components don't have instances. The regular Outputable instance only shows the label name, and not its other info.mghcDecides between external and local labels based on the names externality.nghcMake a foreign labelnghc-Update the label size field in a ForeignLabelnghc+Whether label is a top-level string literalnghc8Whether label is a non-haskell label (defined in C code)nghcWhether label is a static closure label (can come from haskell or cmm)nghc Whether label is a .rodata labelnghc2Whether label is points to some kind of info tablenghc4Whether label points to an info table defined in Cmmnghc1Whether label is points to constructor info tablenghc,Get the label size field from a ForeignLabelnghcA standard string unpacking thunk. See Note [unpack_cstring closures] in StgStdThunks.cmm.nghcA standard string unpacking thunk. See Note [unpack_cstring closures] in StgStdThunks.cmm.nghc*A label indicating the end of a procedure.nghcConstruct a label for a DWARF Debug Information Entity (DIE) describing another symbol.nghc7If a label is a local block label then return just its K , otherwise J.nghcCheck whether a label corresponds to a C function that has a prototype in a system header somewhere, or is built-in to the C compiler. For these labels we avoid generating our own C prototypes.nghcIs a CLabel visible outside this object file or not? From the point of view of the code generator, a name is externally visible if it has to be declared as exported in the .o file's symbol table; that is, made non-static.ghcWork out the general type of data at the address of this label whether it be code, data, or static GC object.nghcIs a %. defined in the current module being compiled?Sometimes we can optimise references within a compilation unit in ways that we couldn't for inter-module references. This provides a conservative estimate of whether a % lives in the current module.nghcDoes a % need dynamic linkage?When referring to data in code, we need to know whether that data resides in a DLL or not. [Win32 only.]  labelDynamic returns True if the label is located in a DLL, be it a data reference or not.nghc;Generate a label for a procedure internal to a module (if Opt_ExposeAllSymbols/ is enabled). See Note [Internal proc labels].nghcDon't depend on this if you need determinism. No determinism in the ncg backend, so we use the unique for Ord. Even if it pains me slightly.ghcencodes the suffix of the labelghc"what package the label belongs to.ghc.does the label need an "extern .." declarationghc)identifier giving the prefix of the labelghcencodes the suffix of the labelghcname of the imported label.ghc possible '9n' suffix for stdcall functions When generating C, the 'n' suffix is omitted, but when generating assembler we must add it to the label.ghc%what package the foreign label is in.ghcsuffixnghcthe current moduleghcthe internal proc label%mmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnmmmmmmmmmmmmmmmmmmmmmnnnmmmmmmmmmmnnnnnnmmmmmmmnnnnnnnnnnnnnnnnnmmnnnnnnnnnnmmmm%nnnnn%mmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnmmmmmmmmmmmmmmmmmmmmmnnnmmmmmmmmmmnnnnnnmmmmmmmnnnnnnnnnnnnnnnnnmmnnnnnnnnnnmmmm%nnnnn Safe-Inferred{nghcA map storing all the different uses of a specific data constructor and the approximate source position that usage arose from. The > is an incrementing identifier which distinguishes each usage of a constructor in a module. It is paired with the source position the constructor was used at, if possible and a string which names the source location. This is the same information as is the payload for the 5 constructor.nghc A map from a ? to the best approximate source position that name arose from.nghcPosition and information about an info table. For return frames these are the contents of a . nnnnnnnnn nnnnnnnnn Safe-Inferred~ghc3Try to find the best source position surrounding a k. The heuristic strips ticks from the current expression until it finds one which is from the module currently being compiled. This is the same method that the DWARF information uses to give locations to info tables.2It is usually a better alternative than using the - which is carefully propagated downwards by . It's "quick" because it works only using immediate context rather than looking at the parent context like ͫΫϫЫѫͫΫϫЫѫ Safe-Inferred~ghc4Initialize STG pretty-printing options from DynFlags Safe-Inferred 19lghc3If the argument expression is (potential chain of) ], return the head of the app chain, and collect ticks/args along the chain.   Safe-Inferred Safe-Inferredghc-Create HPC initialization C code for a moduleEach module compiled with -fhpc declares an initialisation function of the form `hpc_init_ module?()`, which is emitted into the _stub.c file and annotated with  attribute9((constructor)) so that it gets executed at startup time.The function's purpose is to call hs_hpc_module to register this module with the RTS, and it looks something like this: static void hpc_init_Main(void) __attribute__((constructor)); static void hpc_init_Main(void) { extern StgWord64 _hpc_tickboxes_Main_hpc[]; hs_hpc_module("Main",8,1150288664,_hpc_tickboxes_Main_hpc); } Safe-InferredKKnnnKKnnn Safe-Inferred °ghcCommon things that we can do with instructions, on all architectures. These are used by the shared parts of the native code generator, specifically the register allocators.ðghcGet the registers that are being used by this instruction. regUsage doesn't need to do any trickery for jumps and such. Just state precisely the regs read and written by that insn. The consequences of control flow transfers, as far as register allocation goes, are taken care of by the register allocator.İghcApply a given mapping to all the register references in this instruction.ŰghcChecks whether this instruction is a jump/branch instruction. One that can change the flow of control in a way that the register allocator needs to worry about.ưghcGive the possible destinations of this jump instruction. Must be defined for all jumpish instructions.ǰghcChange the destination of this jump instruction. Used in the linear allocator when adding fixup blocks for join points.Ȱghc5An instruction to spill a register into a spill slot.ɰghc6An instruction to reload a register from a spill slot.ʰghc?See if this instruction is telling us the current C stack delta˰ghcCheck whether this instruction is some meta thing inserted into the instruction stream for other purposes.Not something that has to be treated as a real machine instruction and have its registers allocated. eg, comments, delta, ldata, etc.̰ghcCopy the value in a register to another one. Must work for all register classes.ͰghcTake the source and destination from this reg -> reg move instruction or Nothing if it's not oneΰghcMake an unconditional jump instruction. For architectures with branch delay slots, its ok to put a NOP after the jump. Don't fill the delay slot with an instruction that references regs or you'll confuse the linear allocator.ѰghcPretty-print an instructionӰghcHolds a list of source and destination registers used by a particular instruction.Machine registers that are pre-allocated to stgRegs are filtered out, because they are uninteresting from a register allocation standpoint. (We wouldn't want them to end up on the free list!)As far as we are concerned, the fixed registers simply don't exist (for allocation purposes, anyway).װghcNo regs read or written to.Ȱghcthe reg to spillghcthe current stack deltaghcspill slot to useghc instructionsɰghcthe reg to reload.ghcthe current stack deltaghcthe spill slot to useghc instructions̰ghcsource registerghcdestination register°ҰѰΰɰȰǰİưͰʰ̰ϰаðŰ˰Ӱ԰հְװ°ҰѰΰɰȰǰİưͰʰ̰ϰаðŰ˰Ӱ԰հְװ Safe-Inferred TqghcSets of registersqghcA stack area is either the stack slot where a variable is spilled or the stack space where function arguments and results are passed.qghcReturns an alignment in bytes of a CmmExpr when it's a statically known integer constant, otherwise returns an alignment of 1 byte. The caller is responsible for using with a sensible CmmExpr argument.qqqqqqqqqqq;;;;;qqqqqqqqqqqqq;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qqqqqqqqqqqqqqqqqqqqqqqqqqq<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<===================;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<;;;;;;;;;;;;=====================================================::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::qqqqqqqqqqq;;;;;qqqqqqqqqqqqq;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qqqqqqqqqqqqqqqqqqqqqqqqqqq Safe-Inferredcrrrrrrrrrrrr Safe-Inferredrrrrrrrrrrrr Safe-Inferredrrrrrrrrrr Safe-Inferred:rrrrrrrrrr Safe-Inferredrrrrrrrrrr Safe-Inferredrrrrrrrrrr Safe-Inferred rrrrrrrrrr Safe-InferredNrrrrrrrrrr Safe-Inferredrrrrrrrrrr Safe-Inferredrrrrrrrrrr Safe-InferredrghcReturns L if this global register is stored in a caller-saves machine register.rghcHere is where the STG register map is defined for each target arch. The order matters (for the llvm backend anyway)! We must make sure to maintain the order here with the order used in the LLVM calling conventions. Note that also, this isn't all registers, just the ones that are currently possibly mapped to real registers.rrrssrrrss Safe-Inferred)*6ghcTick scope identifier, allowing us to reason about what annotations in a Cmm block should scope over. We especially take care to allow optimisations to reorganise blocks without losing tick association in the process.ghcThe global scope is the "root" of the scope graph. Every scope is a sub-scope of the global scope. It doesn't make sense to add ticks to this scope. On the other hand, this means that setting this scope on a block means no ticks apply to it.ghcConstructs a new sub-scope to an existing scope. This allows us to translate Core-style scoping rules (see  tickishScoped2) into the Cmm world. Suppose the following code:tick 1# case ... of A -> tick 2 ... B -> tick 3 ...We want the top-level tick annotation to apply to blocks generated for the A and B alternatives. We can achieve that by generating tick 1 into a block with scope a, while the code for alternatives A and B gets generated into sub-scopes a/b and a/c respectively.ghcA combined scope scopes over everything that the two given scopes cover. It is therefore a sub-scope of either scope. This is required for optimisations. Consider common block elimination: A -> tick 2, case ... of C -> [common] B -> tick 3 case ... of D -> [common]We will generate code for the C and D alternatives, and figure out afterwards that it's actually common code. Scoping rules dictate that the resulting common block needs to be covered by both tick 2 and tick 3, therefore we need to construct a scope that is a child to *both* scope. Now we can do that - if we assign the scopes ac and bd to the common-ed up blocks, the new block could have a combined tick scope ac+bd, which both tick 2 and tick 3 apply to.ghcA convention maps a list of values (function arguments or return values) to registers or stack locations.ghc top-level Haskell functions use NativeDirectCall, which maps arguments to registers starting with R2, according to how many registers are available on the platform. This convention ignores R1, because for a top-level function call the function closure is implicit, and doesn't need to be passed.ghcnon-top-level Haskell functions, which pass the address of the function closure in R1 (regardless of whether R1 is a real register or not), and the rest of the arguments in registers or on the stack.ghca native return. The convention for returns depends on how many values are returned: for just one value returned, the appropriate register is used (R1, F1, etc.). regardless of whether it is a real register or not. For multiple values returned, they are mapped to registers or the stack.ghc/Slow entry points: all args pushed on the stackghcEntry to the garbage collector: uses the node reg! (TODO: I don't think we need this --SDM)ghcOutput all scope paths.ghcReturns the head uniques of the scopes. This is based on the assumption that the Unique of SubScope identifies the underlying super-scope. Used for efficient equality and comparison, see below.ghcChecks whether two tick scopes are sub-scopes of each other. True if the two scopes are equal.ghcCombine two tick scopes. The new scope should be sub-scope of both parameters. We simplify automatically if one tick scope is a sub-scope of the other already.II Safe-Inferred== Safe-Inferred)*X ڰٰ۰ܰݰް߰ ڰٰ۰ܰݰް߰ Safe-Inferred)*19 ˜ghc%Static data, after SRTs are generatedĘghc8a literal value, size given by cmmLitRep of the literal.Řghc uninitialised data, N bytes longƘghc1string of 8-bit values only, not zero terminated.ǘghc+an embedded binary file and its byte lengthۘghc!Info table as a haskell data typeghcCmmTopInfo is attached to each CmmDecl (see defn of CmmGroup), and contains the extra info (beyond the executable code) that belongs to that CmmDecl.ghcA top-level chunk, abstracted over the type of the contents of the basic blocks (Cmm or instructions are the likely instantiations).ghcRaw1 cmm group (TODO (osa): not sure what that means)ghcCmm group with SRTsghcCmm group before SRT generationghc?Should a data in this section be considered constant at runtimeghcThe branch block id is that of the first block in the branch, which is that branch's entry pointȘɘΘИ֘ϘјҘӘԘ՘ט˜ØĘŘƘǘʘ˘̘ۘ͘ܘݘޘߘ_______ؘژ٘_Iqqqqqqqq;;;qqqqqqqqqqqq;;;;;;;;;;;;;;;;;;;;;;;;;;;;qqqqqqqqq<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<===================;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<;;;;;;;;;;;;:::::::::::::::;qqqqqq;;q;;;;;;;;;;;;;qqqqqqqqqqqqqqq=====================================================:::::::::::::::::::::::::::::::::::::::::::::::::::::::ȘɘΘИ֘ϘјҘӘԘ՘ט˜ØĘŘƘǘʘ˘̘ۘ͘ܘݘޘߘ_______ؘژ٘_ Safe-Inferred:ghc (), it's imperfect but works with wasm-ld.ghcDefined function bodies.ghcDefined data sections.ghc&ctors in the current compilation unit.ghcRepresentation of WebAssembly control flow. Normally written as  WasmControl s e pre post  Type parameter s is the type of (unspecified) statements. It might be instantiated with an open Cmm block or with a sequence of Wasm instructions. Parameter e( is the type of expressions. Parameter pre represents the values that are expected on the WebAssembly stack when the code runs, and post2 represents the state of the stack on completion.ghcThe w type variable in the Wasm IR stands for "platform word type", so  on wasm32, and  on wasm64. This way, we can make the codegen logic work on both wasm32/wasm64 in a type-safe manner.˲ghcMost are Cmm functions, but may also contain synthesized function of other types, sigh.ghc No need to remember the symbols.ghcWe need to remember the symbols. Determinism is achieved by sorting symbols before writing the assembly.ӲghcNeither Cmm or Wasm type system takes integer signedness into account, therefore we always round up a q9 to the right width and handle it as an untyped integer.޲ghcWebAssembly doesn't really have proper read-only memory regions yet. Neverthless we add the .rodata logic here, wasm-ld will aggregate all .rodata sections into a single one, which adds possibility for runtime checks later, either via a customized runtime, or via code instrumentation. See https://github.com/llvm/llvm-project/blob/b296aed8ae239c20ebdd7969e978f8d2a3b9c178/lld/wasm/Writer.cpp#L856ghcRepresents whether a symbol is a data symbol or a function symbol. Unlike linkers for other targets, wasm-ld does panic at link-time if it finds symbol kind inconsistency between the definition site and other use sites.Currently we solely rely on isCFunctionLabel to determine a symbol's kind, but it does take extra effort to make it work. The main source of inconsistency arises from hand-written Cmm sources, where it's possible to refer to external entities like xxx_info and  xxx_closure without explicit import CLOSURE declarations. The Cmm parser will implicitly assume those are foreign function labels, and then this will break the WebAssembly backend. #22368 provides more context on this issue.9tl;dr for any GHC contributor that accidentally triggers wasm-ld errors when hacking Cmm: whatever data symbols are used in new code, just add the corresponding import CLOSURE+ declarations at the top of that Cmm file.ghc,Not defined in the current compilation unit. ([ undefined binding=global vis=default ]ghc0Defined, not visible to other compilation units. [ binding=local vis=default ]ghc,Defined, visible to other compilation units.Adds .hidden & .globl# directives in the output assembly. [ binding=global vis=hidden ]ghc,For simplicity, we record other metadata in / by need, instead of carrying them along with .ghcThe type of a WebAssembly function, loop, block, or conditional. This type says what values the code expects to pop off the stack and what values it promises to push. The WebAssembly standard requires that this type appear explicitly in the code.ghcList of WebAssembly types used to describe the sequence of WebAssembly values that a block of code may expect on the stack or leave on the stack.ghc+Singleton type useful for programming with  at the type level.ghcWebAssembly type of a WebAssembly value that WebAssembly code could either expect on the evaluation stack or leave on the evaluation stack.޲߲ӲԲղֲײزٲڲ۲ܲݲβϲвѲҲͲ̲Ȳɲʲ˲ŲƲDz²òIJ޲߲ӲԲղֲײزٲڲ۲ܲݲβϲвѲҲͲ̲Ȳɲʲ˲ŲƲDz²òIJ Safe-Inferred)*1гghcModule : GHC.Wasm.ControlFlow Description : Representation of control-flow portion of the WebAssembly instruction set Safe-Inferred҃ghcReturns the info table associated with the CmmDecl's entry point, if any.ghcReturn the list of BlockIds in a CmmDecl that are entry points for this proc (i.e. they may be jumped to from outside this proc). Safe-Inferredҿ   Safe-Inferredghc#Get bytes of a Float representationghc$Get bytes of a Double representationghcEmit a ".string" directiveghcEmit a ".incbin" directive+A NULL byte is added after the binary data. Safe-InferredghcLlvm cast operations.ghcInteger truncateghcInteger extend (zero fill)ghcInteger extend (sign fill)ghcFloat truncateghc Float extendghcFloat to unsigned IntegerghcFloat to signed IntegerghcUnsigned Integer to FloatghcSigned Int to FloatghcPointer to IntegerghcInteger to Pointerghc6Cast between types where no bit manipulation is neededghcLlvm compare operations.ghcEqual (Signed and Unsigned)ghcNot equal (Signed and Unsigned)ghcUnsigned greater thanghcUnsigned greater than or equalghcUnsigned less thanghcUnsigned less than or equalghcSigned greater thanghcSigned greater than or equalghcSigned less thanghcSigned less than or equalghc Float equalghcFloat not equalghcFloat greater thanghcFloat greater than or equalghcFloat less thanghcFloat less than or equal³ghc)Llvm binary operators machine operations.óghc1add two integer, floating point or vector values.ijghcsubtract two ...ųghc multiply ..Ƴghc$unsigned integer or vector division.dzghcsigned integer ..ȳghc*unsigned integer or vector remainder (mod)ɳghc signed ...ʳghc(add two floating point or vector values.˳ghcsubtract two ...̳ghc multiply ...ͳghc divide ...γghc remainder ...ϳghc Left shiftгghc3Logical shift right Shift right, filling with zeroѳghcArithmetic shift right The most significant bits of the result will be equal to the sign bit of the left operand.ҳghcAND bitwise logical operation.ӳghcOR bitwise logical operation.ԳghcXOR bitwise logical operation.ճghcLinkage type of a symbol.The description of the constructors is copied from the Llvm Assembly Language Reference Manual  -http://www.llvm.org/docs/LangRef.html#linkage5, because they correspond to the Llvm linkage types.ֳghcGlobal values with internal linkage are only directly accessible by objects in the current module. In particular, linking code into a module with an internal global value may cause the internal to be renamed as necessary to avoid collisions. Because the symbol is internal to the module, all references can be updated. This corresponds to the notion of the static keyword in C.׳ghc Globals with linkonce linkage are merged with other globals of the same name when linkage occurs. This is typically used to implement inline functions, templates, or other code which must be generated in each translation unit that uses it. Unreferenced linkonce globals are allowed to be discarded.سghcweak linkage is exactly the same as linkonce linkage, except that unreferenced weak globals may not be discarded. This is used for globals that may be emitted in multiple translation units, but that are not guaranteed to be emitted into every translation unit that uses them. One example of this are common globals in C, such as int X; at global scope.ٳghc appending linkage may only be applied to global variables of pointer to array type. When two global variables with appending linkage are linked together, the two global arrays are appended together. This is the Llvm, typesafe, equivalent of having the system linker append together sections/ with identical names when .o files are linked.ڳghcThe semantics of this linkage follow the ELF model: the symbol is weak until linked, if not linked, the symbol becomes null instead of being an undefined reference.۳ghcThe symbol participates in linkage and can be used to resolve external symbol references.ܳghc Alias for ۳3 but with explicit textual form in LLVM assembly.ݳghcSymbol is private to the module and should not appear in the symbol table޳ghcFunctions can have a fixed amount of parameters, or a variable amount.ghc1Different calling conventions a function can use.ghcThe C calling convention. This calling convention (the default if no other calling convention is specified) matches the target C calling conventions. This calling convention supports varargs function calls and tolerates some mismatch in the declared prototype and implemented declaration of the function (as does normal C).ghcThis calling convention attempts to make calls as fast as possible (e.g. by passing things in registers). This calling convention allows the target to use whatever tricks it wants to produce fast code for the target, without having to conform to an externally specified ABI (Application Binary Interface). Implementations of this convention should allow arbitrary tail call optimization to be supported. This calling convention does not support varargs and requires the prototype of al callees to exactly match the prototype of the function definition.ghcThis calling convention attempts to make code in the caller as efficient as possible under the assumption that the call is not commonly executed. As such, these calls often preserve all registers so that the call does not break any live ranges in the caller side. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition.ghcThe GHC-specific  registerised calling convention.ghcAny calling convention may be specified by number, allowing target-specific calling conventions to be used. Target specific calling conventions start at 64.ghc X86 Specific  convention. LLVM includes a specific alias for it rather than just using CC_Ncc.ghc#Different types to call a function.ghc(Normal call, allocate a new stack frame.ghc7Tail call, perform the call in the current stack frame.ghcLlvm Function Attributes.Function attributes are set to communicate additional information about a function. Function attributes are considered to be part of the function, not of the function type, so functions with different parameter attributes can have the same function type. Functions can have multiple attributes.Descriptions taken from )http://llvm.org/docs/LangRef.html#fnattrsghcThis attribute indicates that the inliner should attempt to inline this function into callers whenever possible, ignoring any active inlining size threshold for this caller.ghcThis attribute indicates that the source code contained a hint that inlining this function is desirable (such as the "inline" keyword in C/C++). It is just a hint; it imposes no requirements on the inliner.ghcThis attribute indicates that the inliner should never inline this function in any situation. This attribute may not be used together with the alwaysinline attribute.ghcThis attribute suggests that optimization passes and code generator passes make choices that keep the code size of this function low, and otherwise do optimizations specifically to reduce code size.ghcThis function attribute indicates that the function never returns normally. This produces undefined behavior at runtime if the function ever does dynamically return.ghcThis function attribute indicates that the function never returns with an unwind or exceptional control flow. If the function does unwind, its runtime behavior is undefined.ghcThis attribute indicates that the function computes its result (or decides to unwind an exception) based strictly on its arguments, without dereferencing any pointer arguments or otherwise accessing any mutable state (e.g. memory, control registers, etc) visible to caller functions. It does not write through any pointer arguments (including byval arguments) and never changes any state visible to callers. This means that it cannot unwind exceptions by calling the C++ exception throwing methods, but could use the unwind instruction.ghcThis attribute indicates that the function does not write through any pointer arguments (including byval arguments) or otherwise modify any state (e.g. memory, control registers, etc) visible to caller functions. It may dereference pointer arguments and read state that may be set in the caller. A readonly function always returns the same value (or unwinds an exception identically) when called with the same set of arguments and global state. It cannot unwind an exception by calling the C++ exception throwing methods, but may use the unwind instruction.ghcThis attribute indicates that the function should emit a stack smashing protector. It is in the form of a "canary"@a random value placed on the stack before the local variables that's checked upon return from the function to see if it has been overwritten. A heuristic is used to determine if a function needs stack protectors or not.If a function that has an ssp attribute is inlined into a function that doesn't have an ssp attribute, then the resulting function will have an ssp attribute.ghcThis attribute indicates that the function should always emit a stack smashing protector. This overrides the ssp function attribute.If a function that has an sspreq attribute is inlined into a function that doesn't have an sspreq attribute or which has an ssp attribute, then the resulting function will have an sspreq attribute.ghcThis attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.ghc>This attributes disables implicit floating point instructions.ghcThis attribute disables prologue / epilogue emission for the function. This can have very system-specific consequences.ghcLLVM Parameter Attributes.Parameter attributes are used to communicate additional information about the result or parameters of a functionghcThis indicates to the code generator that the parameter or return value should be zero-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).ghcThis indicates to the code generator that the parameter or return value should be sign-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).ghcThis indicates that this parameter or return value should be treated in a special target-dependent fashion during while emitting code for a function call or return (usually, by putting it in a register as opposed to memory).ghcThis indicates that the pointer parameter should really be passed by value to the function.ghcThis indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.ghcThis indicates that the pointer does not alias any global or any other parameter.ghcThis indicates that the callee does not make any copies of the pointer that outlive the callee itselfghcThis indicates that the pointer parameter can be excised using the trampoline intrinsics.ghcAn LLVM Functionghc!Unique identifier of the functionghcLinkageType of the functionghc&The calling convention of the functionghcType of the returned valueghc'Indicates if this function uses varargsghcParameter types and attributesghc(Function align value, must be power of 2ghcLlvm Static Data.These represent the possible global level variables and constants.ghcA comment in a static sectionghc#A static variant of a literal valueghcFor uninitialised dataghcDefines a static ghcA static arrayghcA static structure typeghcA static structure typeghcA pointer to other dataghcTruncateghcPointer to Pointer conversionghcPointer to Integer conversionghcConstant addition operationghcConstant subtraction operationghcLlvm Literal Data.(These can be used inline in expressions.ghc'Refers to an integer constant (i64 42).ghcFloating point literalghc.Literal NULL, only applicable to pointer typesghcVector literalghc>Undefined value, random bit pattern. Useful for optimisations.ghcLLVM VariablesghcVariables with a global scope.ghc,Variables local to a function or parameters.ghcNamed local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).ghcA constant variableghcMutable global variableghcConstant global variableghcAlias of another variableghcAn LLVM section definition. If Nothing then let LLVM decide the sectionghc Llvm Typesghc&An integer with a given width in bits.ghc32 bit floating pointghc64 bit floating pointghc 80 bit (x86 only) floating pointghc128 bit floating pointghcA pointer to a ghc An array of ghc A vector of ghcA  can represent a label (address)ghc Void typeghcPacked structure typeghcUnpacked structure typeghc A type aliasghc LLVM Metadataghc3Function type, used to create pointers to functionsghc A type aliasghcA String in LLVMghc4A global mutable variable. Maybe defined or externalghcReturns the variable of the ghcReturn the value of the Ŵghc Return the  of the ƴghc Return the  of a Ǵghc Return the  of the ȴghc Return the ճ for a ɴghc0Add a pointer indirection to the supplied type.  and  cannot be lifted.ʴghcLift a variable to  type.˴ghc:Remove the pointer indirection of the supplied type. Only  constructors can be lowered.̴ghcLower a variable of  type.ʹghcTest if the given  is an integerδghcTest if the given  is a floating point typeϴghcTest if the given  is an  constructдghcTest if the given  is an  constructѴghc Test if a  is global.ҴghcWidth in bits of an , returns 0 if not applicableڴghc"The target architectures word size۴ghc"The target architectures word sizeܴghcConvert a Haskell Double to an LLVM hex encoded floating point form. In Llvm float literals can be printed in a big-endian hexadecimal format, regardless of underlying architecture.See Note [LLVM Float Types].³Գӳҳѳгϳγͳ̳˳ʳɳȳdzƳųijóճݳ۳ڳٳ׳ֳܳس޳߳´ôĴŴƴǴȴɴʴ˴̴ʹδϴдѴҴӴԴմִ״شٴڴ۴ܴݴ޴ߴ´ôĴŴƴǴȴɴʴ˴̴ʹδϴдѴҴӴԴմִ״شٴڴ۴޳߳ճݳ۳ڳٳ׳ֳܳس³Գӳҳѳгϳγͳ̳˳ʳɳȳdzƳųijóܴݴ޴ߴ Safe-Inferred?ghcMetadata declarations. Metadata can only be declared in global scope.ghcNamed metadata. Only used for communicating module information to LLVM. ('!name = !{ [!] }' form).ghcMetadata node declaration. ('!0 = metadata !{ }' form).ghcAssociates some metadata with a specific label for attaching to an instruction.ghcLLVM metadata expressionsghc)A reference to an un-named metadata node.   Safe-Inferred2;ghcLlvm ExpressionsghcAllocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocatedghcPerform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operandghcPerform a compare operation on the operands left and right * op: operator * left: left operand * right: right operandghcExtract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vectorghcExtract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.ghcInsert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalarghcAllocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocatedghcLoad the value at location ptrghc(Atomic load of the value at location ptrghcNavigate in a structure, selecting elements * inbound: Is the pointer inbounds? (computed pointer doesn't overflow) * ptr: Location of the structure * indexes: A list of indexes to select the correct value.ghcCast the variable from to the to type. This is an abstraction of three cast operators in Llvm, inttoptr, ptrtoint and bitcast. * cast: Cast type * from: Variable to cast * to: type to cast toghcAtomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirementghcCompare-and-exchange operation * addr: Address to modify * old: Expected value * new: New value * suc_ord: Ordering required in success case * fail_ord: Ordering required in failure case, can be no stronger than suc_ord Result is an i1, true if store was successful.ghcCall a function. The result is the value of the expression. * tailJumps: CallType to signal if the function should be tail called * fnptrval: An LLVM value containing a pointer to a function to be invoked. Can be indirect. Should be LMFunction type. * args: Concrete arguments for the parameters * attrs: A list of function attributes for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid here.ghcCall a function as above but potentially taking metadata as arguments. * tailJumps: CallType to signal if the function should be tail called * fnptrval: An LLVM value containing a pointer to a function to be invoked. Can be indirect. Should be LMFunction type. * args: Arguments that may include metadata. * attrs: A list of function attributes for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid here.ghcMerge variables from different basic blocks which are predecessors of this basic block in a new variable of type tp. * tp: type of the merged variable, must match the types of the predecessor variables. * predecessors: A list of variables and the basic block that they originate from.ghcInline assembly expression. Syntax is very similar to the style used by GCC. * assembly: Actual inline assembly code. * constraints: Operand constraints. * return ty: Return type of function. * vars: Any variables involved in the assembly code. * sideeffect: Does the expression have side effects not visible from the constraints list. * alignstack: Should the stack be conservatively aligned before this expression is executed.ghc/A LLVM expression with metadata attached to it.ghcLlvm StatementsghcAssign an expression to a variable: * dest: Variable to assign to * source: Source expressionghcMemory fence operationghc!Always branch to the target labelghcBranch to label targetTrue if cond is true otherwise to label targetFalse * cond: condition that will be tested, must be of type i1 * targetTrue: label to branch to if cond is true * targetFalse: label to branch to if cond is falseghcComment Plain comment.ghcSet a label on this position. * name: Identifier of this label, unique for this moduleghcStore variable value in pointer ptr. If value is of type t then ptr must be of type t*. * value: Variable/Constant to store. * ptr: Location to store the value inghcMultiway branch * scrutinee: Variable or constant which must be of integer type that is determines which arm is chosen. * def: The default label if there is no match in target. * target: A list of (value,label) where the value is an integer constant and label the corresponding label to jump to if the scrutinee matches the value.ghcReturn a result. * result: The variable or constant to returnghcAn instruction for the optimizer that the code following is not reachableghcRaise an expression to a statement (if don't want result or want to use Llvm unnamed values.ghcA nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].ghc.A LLVM statement with metadata attached to it.ghc'LLVM atomic operations. Please see the  atomicrmw instruction in the LLVM documentation for a complete description.ghcLLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.ghc(Some partial order of operations exists.ghc?A single total order for operations at a single address exists.ghc"Acquire synchronization operation.ghc"Release synchronization operation.ghc,Acquire + Release synchronization operation.ghc&Full sequential Consistency operation.õghcAn LLVM Functionŵghc(The signature of this declared function.ƵghcThe functions argumentsǵghcThe function attributes.ȵghc%The section to put the function into,ɵghc Prefix dataʵghcThe body of the functions.˵ghc6An LLVM Module. This is a top level container in LLVM.͵ghc/Comments to include at the start of the module.εghcLLVM Alias type definitions.ϵghcLLVM meta data.еghc*Global variables to include in the module.ѵghcLLVM Functions used in this module but defined in other modules.ҵghc&LLVM Functions defined in this module.ԵghcA block of LLVM code.ֵghcThe code label for this block׵ghcA list of LlvmStatement's representing the code for this block. This list must end with a control flow statement.صghc Block labelsµõɵȵǵƵŵʵĵ˵ҵѵеϵε͵̵ӵԵ׵ֵյصصԵ׵ֵյӵ˵ҵѵеϵε͵̵õɵȵǵƵŵʵĵµ Safe-Inferred;ߵghcPrint out a whole LLVM module.ghcPrint out a multi-line comment, can be inside a function or on its ownghc;Print out a comment, can be inside a function or on its ownghc7Print out a list of global mutable variable definitionsghc.Print out a global mutable variable definitionghc&Print out a list of LLVM type aliases.ghcPrint out an LLVM type alias.ghc"Print out a list of LLVM metadata.ghc&Print out an LLVM metadata definition.ghc)Print out a list of function definitions.ghc Print out a function definition.ghc'Print out a function definition header.ghc)Print out a list of function declaration.ghcPrint out a function declaration. Declarations define the function type but don't define the actual body of the function.ghc Print out a list of LLVM blocks.ghcPrint out an LLVM block. It must be part of a function definition.ghcPrint out an LLVM block label.ghcPrint out an LLVM statement.ghcPrint out an LLVM expression.ghcShould always be a function pointer. So a global var of function type (since globals are always pointers) or a local var of pointer function type.ghc)Return the variable name or value of the * in Llvm IR textual representation (e.g. @x, %y or 42).ghc)Return the variable name or value of the * in a plain textual representation (e.g. x, y or 42).ghcPrint a literal value. No type.ghc Blank line.ghcExclamation point.ߵߵ Safe-Inferred;˵̵͵εϵеѵҵõĵʵŵƵǵȵɵµӵԵյֵ׵ص޳߳ճسֳܳ׳ٳڳ۳ݳ³óijųƳdzȳɳʳ˳̳ͳγϳгѳҳӳԳԴմִ״شٴڴ۴ѴƴŴȴǴʴ̴ɴ˴ʹδϴдҴߵ˵̵͵εϵеѵҵõĵʵŵƵǵȵɵµӵԵյֵ׵ص޳߳ճسֳܳ׳ٳڳ۳ݳ³óijųƳdzȳɳʳ˳̳ͳγϳгѳҳӳԳԴմִ״شٴڴ۴ѴƴŴȴǴʴ̴ɴ˴ʹδϴдҴߵ Safe-InferredIP ghc;Get the LlvmVar function variable storing the real registerghc;Get the LlvmVar function argument storing the real registerghc>A list of STG Registers that should always be considered aliveghc'STG Type Based Alias Analysis hierarchyghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghcThe TBAA metadata identifierghcGet the correct TBAA metadata information for this register type   Safe-InferredJghc%Get the integer format of this width.ghc#Get the float format of this width.ghc-Check if a format represent an integer value.ghc4Check if a format represents a floating point value.ghcConvert a Cmm type to a Format.ghcGet the Width of a Format. Safe-InferredKp Safe-InferredLcghcregSqueeze_class reg Calculate the maximum number of register colors that could be denied to a node of this class due to having this reg as a neighbour.00 Safe-InferredM¶öĶ¶öĶ Safe-InferredNǶghcLanguage ID used for Haskell.ghc.Mapping of registers to DWARF register numbersghc2Virtual register number to use for return address.Ƕȶɶʶ˶̶Ͷζ϶жѶҶӶԶնֶ׶ضٶڶ۶ܶݶ޶߶Ƕ˶ζѶҶɶж̶ʶȶ϶ͶӶնԶֶ׶ضٶڶ۶ܶݶ޶߶ Safe-Inferred 1d"ghcCombination of target node id and information about the branch we are looking at.ghcList of back edgesghcBlockId -> LoopLevel mappingghc*(backEdge, loopBody), body includes headerghcInformation about edgesghc%Unknown, but not heap or stack check.ghcHeap or stack checkghcCan we trace back a edge to a specific Cmm Node or has it been introduced during assembly codegen. We use this to maintain some information which would otherwise be lost during the Cmm <-> asm transition. See also Note [Inverting conditions]ghcA control flow graph where edges have been annotated with a weight. Implemented as IntMap (IntMap ) We must uphold the invariant that for each edge A -> B we must have: A entry B in the outer map. A entry B in the map we get when looking up A. Maintaining this invariant is useful as any failed lookup now indicates an actual error in code which might go unnoticed for a while otherwise.ghcConvenience function, generate edge info based on weight not originating from cmm.ghcAdjust the weight between the blocks using the given function. If there is no such edge returns the original map.ghcSet the weight between the blocks to the given weight. If there is no such edge returns the original map.ghc!Is this block part of this graph?ghcCheck if the nodes in the cfg and the set of blocks are the same. In a case of a mismatch we panic and show the difference.ghcFilter the CFG with a custom function f. Parameters are `f from to edgeInfo`ghcSometimes we insert a block which should unconditionally be executed after a given block. This function updates the CFG for these cases. So we get A -> B => A -> A' -> B -> C => -> Cghc5Adds a new edge, overwrites existing edges if presentghcAdds a edge with the given weight to the cfg If there already existed an edge it is overwritten. `addWeightEdge from to weight cfg`ghc4Destinations from bid ordered by weight (descending)ghc1Get successors of a given node with edge weights.ghc/Returns a unordered list of all edges with infoghc5Returns a unordered list of all edges without weightsghc4Get successors of a given node without edge weights.ghc8Invariant: The edge **must** exist already in the graph.÷ghcInsert a block in the control flow between two other blocks. We pass a list of tuples (A,B,C) where * A -> C: Old edge * A -> B -> C : New Arc, where B is the new block. It's possible that a block has two jumps to the same block in the assembly code. However we still only store a single edge for these cases. We assign the old edge info to the edge A -> B and assign B -> C the weight of an unconditional jump.ķghcGenerate weights for a Cmm proc based on some simple heuristics.ghcModify branch weights based on educated guess on patterns GHC tends to produce and how they affect performance.6Most importantly we penalize jumps across info tables.ghc5Convert block-local branch weights to global weights.ǷghcDetermine loop membership of blocks based on SCC analysis This is faster but only gives yes/no answers.ɷghcDetermine loop membership of blocks based on Dominator analysis. This is slower but gives loop levels instead of just loop membership. However it only detects natural loops. Irreducible control flow is not recognized even if it loops. But that is rare enough that we don't have to care about that special case.ʷghcWe take in a CFG which has on its edges weights which are relative only to other edges originating from the same node.We return a CFG for which each edge represents a GLOBAL weight. This means edge weights are comparable across the whole graph.For irreducible control flow results might be imprecise, otherwise they are reliable.The algorithm is based on the Paper "Static Branch Prediction and Program Profile Analysis" by Y Wu, JR Larus The only big change is that we go over the nodes in the body of loops in reverse post order. Which is required for diamond control flow to work probably.We also apply a few prediction heuristics (based on the same paper)The returned result represents frequences. For blocks it's the expected number of executions and for edges is the number of traversals.ghcUpdate branch weights based on certain heuristics. See Note [Static Branch Prediction] TODO: This should be combined with optimizeCFGϷghcEdges are sorted ascending pointwise by weight, source and destinationзghcCareful! Since we assume there is at most one edge from A to B the Eq instance does not consider weight..÷Ƿȷɷŷķ·Ʒʷ.÷Ƿȷɷŷķ·Ʒʷ Safe-Inferred9tm ܷghc(A basic block with liveness information.ݷghcStash regs live on entry to each basic block in the info part of the cmm code.߷ghcLiveness information. The regs which die are ones which are no longer live in the *next* instruction in this sequence. (NB. if the instruction is a jump, these registers might still be live at the jump target(s) - you have to check the liveness at the destination block to find out).ghc?registers born in this instruction (written to for first time).ghc=registers that died because they were read for the last time.ghc=registers that died because they were clobbered by something.ghc)An instruction with liveness information.ghcThe register allocator also wants to use SPILL/RELOAD meta instructions, so we'll keep those here.ghcA real machine instructionghcspill this reg to a stack slotghc!reload this reg from a stack slotghc5A top level thing which carries liveness information.ghc$Map from some kind of register to a.While we give the type for keys as Reg which is the common case sometimes we end up using VirtualReq or naked Uniques. See Note [UniqFM and the register allocator]ghc7map a function across all the basic blocks in this codeghcmap a function across all the basic blocks in this code (monadic version)ghcmap a function across all the basic blocks in this code (monadic version)ghcSlurp out the list of register conflicts and reg-reg moves from this top level thing. Slurping of conflicts and moves is wrapped up together so we don't have to make two passes over the same code when we want to build the graph.ghcFor spill/reloads+SPILL v1, slot1 ... RELOAD slot1, v2If we can arrange that v1 and v2 are allocated to the same hreg it's more likely the spill/reload instrs can be cleaned and replaced by a nop reg-reg move.ghc4Strip away liveness information, yielding NatCmmDeclghcPretty-print a ghcMap over instruction type in ghcStrip away liveness information from a basic block, and make real spill instructions out of SPILL, RELOAD pseudos along the way.ghcErase Delta instructions.ghcPatch the registers in this code according to this register mapping. also erase reg -> reg moves when the reg is the same. also erase reg -> reg moves when the destination dies in this instr.ghcPatch registers in this LiveInstr, including the liveness information.ghcConvert a NatCmmDecl to a LiveCmmDecl, with liveness informationghcCheck ordering of Blocks The computeLiveness function requires SCCs to be in reverse dependent order. If they're not the liveness information will be wrong, and we'll get a bad allocation. Better to check for this precondition explicitly or some other poor sucker will waste a day staring at bad assembly code..ghcIf we've compute liveness info for this code already we have to reverse the SCCs in each top to get them back to the right order so we can do it again.ghcComputing livenessOn entry, the SCCs must be in "reverse" order: later blocks may transfer control to earlier ones only, else .The SCCs returned are in the *opposite* order, which is exactly what we want for the next pass.ghc:Annotate a basic block with register liveness information.ghcCalculate liveness going forwards, filling in when regs are bornghcCalculate liveness going backwards, filling in when regs die, and what regs are live across each instructionghcSCCs of blocks that we're about to run the liveness determinator on.ghc$BlockIds that fail the test (if any)%߷ݷ޷ܷ%߷ݷ޷ܷ Safe-Inferred%&~ghcThe register allocator stateghcthe current mapping from basic blocks to the register assignments at the beginning of that block.ghcfree machine registersghc assignment of temps to locationsghccurrent stack deltaghcfree stack slots for spillingghc?unique supply for generating names for join point fixup blocks.ghcRecord why things were spilled, for -ddrop-asm-stats. Just keep a list here instead of a map of regs -> reasons. We don't want to slow down the allocator if we're not going to emit the stats.ghc#Native code generator configurationghc<(from,fixup,to) : We inserted fixup code between from and toghc>Used to carry interesting stats out of the register allocator.ghc<(from,fixup,to) : We inserted fixup code between from and toghcReasons why instructions might be inserted by the spiller. Used when generating stats for -ddrop-asm-stats.ghcvreg was spilled to a slot so we could use its current hreg for another vregghc-vreg was moved because its hreg was clobberedghc!vreg was loaded from a spill slotghc,reg-reg move inserted during join to targetsghc,reg-mem move inserted during join to targetsghcWhere a vreg is currently stored A temporary can be marked as living in both a register and memory (InBoth), for example if it was recently loaded from a spill location. This makes it cheap to spill (no save instruction required), but we have to be careful to turn this into InReg if the value in the register is changed.ghcvreg is in a registerghcvreg is held in a stack slotghc0vreg is held in both a register and a stack slotghcUsed to store the register assignment on entry to a basic block. We use this to handle join points, where multiple branch instructions target a particular label. We have to insert fixup code to make the register assignments from the different sources match up.ghc1Find the register mapping for a specific BlockId.ghc?Lookup which register a virtual register was first assigned to.ghcAn initial empty ghc/Add new register mappings for a specific block.ghc'Get the reg numbers stored in this Loc. Safe-Inferred\ghcBuild a map of how many times each reg was alloced, clobbered, loaded etc.ghc+Count reg-reg moves remaining in this code.ghcPretty print some RegAllocStats Safe-Inferred 9ghc"The register allocator monad type.ghcSmart constructor for , as described in Note [The one-shot state monad trick] in GHC.Utils.Monad.ghc'Get native code generator configurationghc blocks which reload from this slot) used to decide if whether slot spilled to will ever be reloaded from on this path.ghc6Spills and reloads cleaned each pass (latest at front)ghc>Spills and reloads that have been cleaned in this pass so far.ghcCleaner monad.ghcThe identification number of a spill slot. A value is stored in a spill slot when we don't have a free register to hold it.øghc;Clean out unneeded spill/reloads from this top level thing.ghcDo one pass of cleaning.ghcClean out unneeded reload instructions, while walking forward over the code.ghc'Clean out unneeded reload instructions.Walking forwards across the code On a reload, if we know a reg already has the same value as a slot then we don't need to do the reload.ghc?Try and rewrite a reload instruction to something more pleasingghcClean out unneeded spill instructions, while walking backwards over the code.If there were no reloads from a slot between a spill and the last one then the slot was never read and we don't need the spill.SPILL r0 -> s1 RELOAD s1 -> r2 SPILL r3 -> s1 <--- don't need this spill SPILL r4 -> s1 RELOAD s1 -> r5Maintain a set of "slots which were spilled to but not reloaded from yet"Walking backwards across the code: a) On a reload from a slot, remove it from the set.a) On a spill from a slot If the slot is in set then we can erase the spill, because it won't be reloaded from until after the next spill.otherwise keep the spill and add the slot to the setTODO: This is mostly inter-block we should really be updating the noReloads set as we cross jumps also..TODO: generate noReloads from liveSlotsOnEntryghcCombine the associations from all the inward control flow edges.ghcSee if we have a reg with the same value as this slot in the association table.ghc$Construct the initial cleaner state.ghc(Remember the associations before a jump.ghcCheck if this is a reg store.ghcAn empty associationghcAdd an association between these two things. addAssoc :: Uniquable a => a -> a -> Assoc a -> Assoc aghc"Delete all associations to a node.ghc*Delete a single association edge (a -> b).ghc)Check if these two things are associated.ghcFind the refl. trans. closure of the association from this point.ghcIntersect two associations.ghc!Iteration number for the cleaner.ghc!Liveness annotated code to clean.ghc!the block that we're currently inghctwo store locations are associated if they have the same valueghcaccghc$instrs to clean (in backwards order)ghc$cleaned instrs (in forward order)ghc!Slots live on entry to each blockghc3Slots that have been spilled, but not reloaded fromghcaccghc#Instrs to clean (in forwards order)ghc$Cleaned instrs (in backwards order)øø Safe-InferredƸghc Reg moves, if the first reg dies at the same time the second reg is born then the mov only serves to join live ranges. The two regs can be renamed to be the same and the move instruction safely erased.ghcAdd a v1 = v2 register renaming to the map. The register with the lowest lexical name is set as the canonical version.ghcDetermine the canonical name for a register by following v1 = v2 renamings in this map.͸ghc?Slurp out mov instructions that only serve to join live ranges.During a mov, if the source reg dies and the destination reg is born then we can rename the two regs to the same thing and eliminate the move.̸͸̸͸ Safe-Inferred)* θghcMap of ϸϸghc1Records the expected cost to spill some register.иghcAn empty map of spill costs.ѸghcAdd two spill cost infos.ҸghcAdd two spill cost records.Ӹghc7Slurp out information used for determining spill costs.For each vreg, the number of times it was written to, read from, and the number of instructions it was live on entry to (lifetime)ghc-Take all the virtual registers from this set.Ըghc&Choose a node to spill from this graphghc Chaitins spill cost function is:cost = sum loadCost * freq (u) + sum storeCost * freq (d) u <- uses (v) d <- defs (v)There are no loops in our code at the moment, so we can set the freq's to 1.If we don't have live range splitting then Chaitins function performs badly if we have lots of nested live ranges and very few registers.v1 v2 v3 def v1 . use v1 . def v2 . . def v3 . . . use v1 . . . use v3 . . . use v2 . . use v1 .defs uses degree cost v1: 1 3 3 1.5 v2: 1 2 3 1.0 v3: 1 1 3 0.666v3 has the lowest cost, but if we only have 2 hardregs and we insert spill code for v3 then this isn't going to improve the colorability of the graph.When compiling SHA1, which as very long basic blocks and some vregs with very long live ranges the allocator seems to try and spill from the inside out and eventually run out of stack slots.Without live range splitting, its's better to spill from the outside in so set the cost of very long live ranges to zeroոghc+Extract a map of register lifetimes from a θ.ghcDetermine the degree (number of neighbors) of this node which have the same class.ָghcShow a spill cost record, including the degree from the graph and final calculated spill cost. ϸҸָθиѸӸԸո ϸҸָθиѸӸԸո Safe-InferredghcregSqueeze_class reg Calculate the maximum number of register colors that could be denied to a node of this class due to having this reg as a neighbour.׸߸޸ݸܸ۸ڸٸظ׸߸޸ݸܸ۸ڸٸظ Safe-Inferred Safe-Inferred 9 ghc9Holds interesting statistics from the register allocator.ghcInitial code, with liveness.ghcThe initial, uncolored graph.ghc/Information to help choose which regs to spill.ghcTarget platformghc(Code we tried to allocate registers for.ghcThe regs that were coalesced.ghcSpiller stats.ghc#Code with spill instructions added.ghcCoalesced and colored graph.ghcCode with coalescings applied.ghc"Code with vregs replaced by hregs.ghc-Code with unneeded spill/reloads cleaned out.ghc Final code.ghc0Spill/reload/reg-reg moves present in this code.ghc;Do all the different analysis on this list of RegAllocStatsghcDump a table of how many spill loads / stores were inserted for each vreg.ghcDump a table of how long vregs tend to live for in the initial code.ghcDump a table of how many conflicts vregs tend to have in the initial code.ghcFor every vreg, dump how many conflicts it has, and its lifetime. Good for making a scatter plot.ghc Count spillreloadreg-reg moves. Lets us see how well the register allocator has done.ghcglobal register conflict graph Safe-Inferred ghc5The maximum number of build/spill cycles we'll allow.It should only take 3 or 4 cycles for the allocator to converge. If it takes any longer than this it's probably in an infinite loop, so it's better just to bail out and report a bug.ghc7The top level of the graph coloring register allocator.ghc;Perform solver iterations for the graph coloring allocator.We extract a register conflict graph from the provided cmm code, and try to colour it. If that works then we use the solution rewrite the code with real hregs. If coloring doesn't work we add spill code and try to colour it again. After  iterations we give up.ghcBuild a graph from the liveness and coalesce information in this code.ghcAdd some conflict edges to the graph. Conflicts between virtual and real regs are recorded as exclusions.ghcAdd some coalescence edges to the graph Coalescences between virtual and real regs are recorded as preferences.ghcPatch registers in code using the reg -> reg mapping in this graph.ghc#registers we can use for allocationghcset of available spill slots.ghccurrent number of spill slotsghc)code annotated with liveness information.ghc CFG of basic blocks if availableghccode with registers allocated, additional stacks required and stats for each stage of allocationghc4Number of solver iterations we've already performed.ghcFunction for calculating whether a register is trivially colourable.ghc$Free registers that we can allocate.ghc!Free stack slots that we can use.ghcNumber of spill slots in useghc!Current regalloc stats to add to.ghc$Liveness annotated code to allocate. Safe-Inferred=ghcArmv6 | Armv7-A | Armv8-A AArch64 | | SIMD extension | NEON | NEON | |===========================================================================| | - Operates on 32-bit | - Separate reg. bank, | - Separate reg. bank, | | GP ARM registers | 32x64-bit NEON regs | 32x128-bit NEON regs | | - 8-bit16-bit integer | - 8163264-bit int | - 81632/64-bit int | | | - Single precision fp | - Single precision fp | | | | - Double precision fp | | | | - Single/Double fp are | | | | IEEE compliant | | - 2x16-bit/4x8-bit ops | - Up to 16x8-bit ops | - Up to 16x8-bit ops | | per instruction | per instruction | per instruction | '---------------------------------------------------------------------------' Safe-Inferredǹghc,SXTW Operand Operand | SXTX Operand Operandɹghc;ADC Operand Operand Operand -- rd = rn + rm + C | ADCS ...ʹghcADDS Operand Operand Operand -- rd = rn + rm | ADR ... | ADRP ...̹ghcMADD ... | MNEG ...Ϲghc6NEGS ... | NGC ... | NGCS ... | SBC ... | SBCS ...йghc&SMADDL ... | SMNEGL ... | SMSUBL ...ӹghcSUBS ...ԹghcUMADDL ... -- Xd = Xa + Wn  Wm | UMNEGL ... -- Xd = - Wn  Wm | UMSUBL ... -- Xd = Xa - Wn  Wm | UMULH ... -- Xd = (Xn  Xm)_127:64 | UMULL ... -- Xd = Wn  Wmghc,MOVN Operand Operand | MOVZ Operand OperandghcTODO: verify this!ghcAll registers are 8 byte wide.ghcThe number of bytes that the stack pointer should be aligned to.ghc reg move instruction or Nothing if it's not oneghc'Make an unconditional jump instruction.ٺghcGet the registers that are being used by this instruction. regUsage doesn't need to do any trickery for jumps and such. Just state precisely the regs read and written by that insn. The consequences of control flow transfers, as far as register allocation goes, are taken care of by the register allocator.RegUsage = RU [ readregs] [ writeregs]ٹ߹޹ݹܹ۹ڹعƹŹĹù׹ֹչԹӹҹϹѹй͹̹˹ʹɹ¹ȹǹιºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٹ߹޹ݹܹ۹ڹعƹŹĹù׹ֹչԹӹҹϹѹй͹̹˹ʹɹ¹ȹǹιºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غ Safe-Inferreḍ Safe-Inferredghc7Print appropriate alignment for the given section type.ghcPrint section header and appropriate alignment for that section.This one will emit the header:.section .text .balign 8ghcOutput the ELF .size directive. Safe-Inferred )*ղ ghcWe make a top-level decl for the string, and return a label pointing to itghcWe make a top-level decl for the embedded binary file, and return a label pointing to itghcBuild a data-segment data blockghcUseful for creating an index into an array, with a statically known offset. The type is the element type; used for making the multiplierghcUseful for creating an index into an array, with an unknown offset.ghc*Load a naturally-aligned non-pointer word.ghc$Load a naturally-aligned GC pointer.ghcReturns True if the two STG registers overlap on the specified platform, in the sense that writing to one will clobber the other. This includes the case that the two registers are the same STG register. See Note [Overlapping global registers] for details.ghcReturns True if the STG register is used by the expression, in the sense that a store to the register might affect the value of the expression.We must check for overlapping registers and not just equal registers here, otherwise CmmSink may incorrectly reorder assignments that conflict due to overlap. See #10521 and Note [Overlapping global registers].ghclike (, but the entry block always comes firstghcLike , but we strive to ensure that we order blocks so that the false case of a conditional jumps to the next block in the output list of blocks. This matches the way OldCmm blocks were output since in OldCmm the false case was a fallthrough, whereas in Cmm conditional branches have both true and false successors. Block ordering can make a big difference in performance in the LLVM backend. Note that we rely crucially on the order of successors returned for CmmCondBranch by the NonLocal instance for CmmNode defined in  GHC.Cmm.Node. -GBMghc1Extract all tick annotations from the given block Safe-Inferred %&ܿ ghcNo args, not a functionϻghcUsed in places where some invariant ensures that all these Ids are non-void; e.g. constructor field binders in case expressions. See Note [Post-unarisation invariants] in GHC.Stg.Unarise.ѻghcUsed in places where some invariant ensures that all these arguments are non-void; e.g. constructor arguments. See Note [Post-unarisation invariants] in GHC.Stg.Unarise.һghc$Assumes that there is precisely one @ of the type. This assumption holds after unarise. See Note [Post-unarisation invariants]ӻghcAssumes that Ids have one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]ԻghcAssumes that arguments have one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]ջghcAssumes that the argument has one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]ghcReturn the tag in the low order bits of a variable bound to this LambdaFormghc Convert from  to ۘ.ghc'Get the info table label for a *thunk*.ghcthunkEntryLabel is a local help function, not exported. It's used from getCallMethod.ƻ߻һAAӻԻջǻȻͻλлϻѻ__ٻػڻۻܻݻֻ׻޻ɻʻ˻»ûĻŻ̻ƻ߻һAAӻԻջǻȻͻλлϻѻ__ٻػڻۻܻݻֻ׻޻ɻʻ˻»ûĻŻ̻ Safe-Inferredw Safe-Inferred)*1ghcCompute the argument with the given set of ids treated as requiring capture as free variables.ghcCompute the argument with the given id treated as requiring capture as free variables in closures.ghcOriginal argumentsghc&var args to be evaluated ahead of timeghcFunction that reconstructs the expressions when passed the list of evaluated arguments. Safe-Inferred)*/1ghcThis constraint encodes the fact that no matter what pass we use the Let/Closure extension points are the same as these for 'InferTaggedBinders.ghcId we are binding to. Safe-Inferred)*YghcWe map STG registers onto appropriate CmmExprs. Either they map to real machine registers or stored as offsets from BaseReg. Given a GlobalReg, get_GlobalReg_addr always produces the register table address for it.ghcFixup global registers so that they assign to locations within the RegTable if they aren't pinned for the current target. Safe-Inferred 9B;ghcThe Llvm monad. Wraps LlvmEnv state as well as the IO monadghc LLVM versionghcConfiguration for LLVM code genghcLoggerghc Output bufferghcMask for creating unique valuesghcSupply of fresh metadata IDsghcGlobal metadata nodesghc"Global functions so far, with typeghc;Globals that we had to alias, see [Llvm Forward References]ghc'Pointers to be added to llvm.used (see cmmUsedLlvmGens)ghc!Local variables so far, with typeghc9Non-constant registers (alloca'd in the function prelude)ghcAn unresolved Label.Labels are unresolved when we haven't yet determined if they are defined in the module we are currently compiling, or an external one.ghc.Top level LLVM Data (globals and type aliases)ghcUnresolved code. Of the form: (data label, data type, unresolved data)ghc#Global registers live on proc entryghc)Translate a basic CmmType to an LlvmType.ghc*Translate a Cmm Float Width to a LlvmType.ghc(Translate a Cmm Bit Width to a LlvmType.ghcGHC Call Convention for LLVMghc#Llvm Function type for Cmm functionghcLlvm Function signatureghcAlignment to use for functionsghc Alignment to use for into tablesghcSection to use for a functionghcA Function's argumentsghc=Return a list of "padding" registers for LLVM function calls.When we generate LLVM function signatures, we can't just make any register alive on function entry. Instead, we need to insert fake arguments of the same register class until we are sure that one of them is mapped to the register we want alive. E.g. to ensure that F5 is alive, we may need to insert fake arguments mapped to F1, F2, F3 and F4.Invariant: Cmm FPR regs with number "n" maps to real registers with number "n" If the calling convention uses registers in a different order or if the invariant doesn't hold, this code probably won't be correct.ghcLlvm standard fun attributesghcConvert a list of types to a list of function parameters (each with no parameter attributes)ghc Pointer widthghcGet target platformghcLifting of IO actions. Not exported, as we want to encapsulate IO.ghcGet initial Llvm environment.ghcGet environment (internal)ghcModify environment (internal)ghc9Clear variables from the environment for a subcomputationghc3Insert variables or functions into the environment.ghc3Insert variables or functions into the environment.ghc1Lookup variables or functions in the environment.ghc1Lookup variables or functions in the environment.ghc(Set a register as allocated on the stackghc2Check whether a register is allocated on the stackghc1Allocate a new global unnamed metadata identifierghc/Get the LLVM version we are generating code forghcDumps the document if the corresponding flag has been set by the userghc.Prints the given contents to the output handleghcMarks a variable as "used"ghc,Return all variables marked as "used" so farghcSaves that at some point we didn't know the type of the label and generated a reference to a type variable insteadghc%Sets metadata node for a given uniqueghc#Gets metadata node for given uniqueghcHere we pre-initialise some functions that are used internally by GHC so as to make sure they have the most general type in the case that user code also uses these functions but with a different type than GHC internally. (Main offender is treating return type as void) instead of 'void *'). Fixes trac #5486.ghcPretty print a %.ghcCreate/get a pointer to a global value. Might return an alias if the value in question hasn't been defined yet. We especially make no guarantees on the type of the returned pointer.ghcDerive the definition label. It has an identified structure type.ghc7Generate definitions for aliases forward-referenced by  getGlobalPtr.Must be called at a point where we are sure that no new global definitions will be generated anymore!ghc!Is a variable one of the special $llvm globals?ghc=Here we take a global variable definition, rename it with a $def, suffix, and generate the appropriate alias.// Safe-Inferred )* :ghcA more convenient way of accumulating LLVM statements and declarations.ghcValues which can be passed to 6 to configure its behaviour in certain circumstances.Currently just used for determining if a comparison should return a boolean (i1) or a word. See Note [Literals and branch conditions].ghcAn expression conversion return data: * LlvmVar: The var holding the result of the expression * LlvmStatements: Any statements needed to evaluate the expression * LlvmCmmDecl: Any global data needed for this expressionghc)Top-level of the LLVM proc Code generatorghcGenerate code for a list of blocks that make up a complete procedure. The first block in the list is expected to be the entry point.ghcGenerate code for one blockghc.Convert a list of CmmNode's to LlvmStatement'sghc.Convert a CmmStmt to a list of LlvmStatement'sghcWrapper function to declare an instrinct function by function typeghc= 3.0ghc Insert a , unless the target platform is in the provided list of exceptions (where no code will be emitted instead).ghc Foreign CallsghcGenerate a call to an LLVM intrinsic that performs arithmetic operation with overflow bit (i.e., returns a struct containing the actual result of the operation and an overflow bit). This function will also extract the overflow bit and zero-extend it (all the corresponding Cmm PrimOps represent the overflow "bit" as a usual Int# or Word#).ghcA helper function for genCallWithOverflow that handles generating the call to the LLVM intrinsic and extracting the result from the struct to LlvmVars.ghc(Create a function pointer from a target.ghc(Create a function pointer from a target.ghcConversion of call arguments.ghcConversion of call arguments.ghc6Cast a collection of LLVM variables to specific types.ghc6Cast a collection of LLVM variables to specific types.ghcCast an LLVM variable to a specific type, panicking if it can't be done.ghc:Decide what C function to use to implement a CallishMachOpghcTail function callsghcCmmAssign operationWe use stack allocated variables for CmmReg. The optimiser will replace these with registers when possible.ghcCmmStore operationghcCmmStore operation This is a special case for storing to a global register pointer offset such as I32[Sp+8].ghcCmmStore operation Generic case. Uses casts and pointer arithmetic if needed.ghcUnconditional branchghcConditional branchghcGenerate call to llvm.expect.x intrinsic. Assigning result to a new var.ghc Switch branchghc'i1 type expected (condition scrutinee).ghcWord type expected (usual).ghcConvert a CmmExpr to a list of LlvmStatements with the result of the expression being stored in the returned LlvmVar.ghcHandle CmmMachOp expressionsghcHandle CmmMachOp expressions This is a specialised method that handles Global register manipulations like 'Sp - 16', using the getelementptr instruction.ghcHandle CmmMachOp expressions This handles all the cases not handle by the specialised genMachOp_fast.ghcHandle CmmLoad expression.ghcHandle CmmLoad expression. This is a special case for loading from a global register pointer offset such as I32[Sp+8].ghcHandle Cmm load expression. Generic case. Uses casts and pointer arithmetic if needed.ghcHandle CmmReg expression. This will return a pointer to the stack location of the register. Throws an error if it isn't allocated on the stack.ghcReturn the value of a given register, as well as its type. Might need to be load from stack.ghc$Allocate a local CmmReg on the stackghcGenerate code for a literalghc=Find CmmRegs that get assigned and allocate them on the stackAny register that gets written needs to be allocated on the stack. This avoids having to map a CmmReg to an equivalent SSA form and avoids having to deal with Phi node insertion. This is also the approach recommended by LLVM developers.On the other hand, this is unnecessarily verbose if the register in question is never written. Therefore we skip it where we can to save a few lines in the output and hopefully speed compilation up a bit.ghcFunction epilogue. Load STG variables to use as argument for call. STG Liveness optimisation done here.ghc/Get a function pointer to the CLabel specified.This is for Haskell functions, function type is assumed, so doesn't work with foreign functions.ghcCreate a new local varghc0Execute an expression, assigning result to a varghcExpand CmmRegOffghc0Convert a block id into a appropriate Llvm labelghcCreate Llvm int Literalghc1Convert int type to a LLvmVar of word or i32 sizeghcError functionsghc Returns TBAA meta data by uniqueghc)Returns TBAA meta data for given registerghc'Return element of single-element list; % if list is not a single-element listghcPrimOpghcWidth of the operands.ghcActual arguments.ghc"LLVM types of the returned struct. Safe-Inferred)* ghcTraverses the , making sure that # are suitable for code generation. Safe-Inferred  Safe-Inferred  Safe-InferredghcThe string appended to a variable name to create its structure type aliasghc The LLVM visibility of the labelghc4Pass a CmmStatic section to an equivalent Llvm code.ghcProduce an initializer or finalizer array declaration. See Note [Initializers and finalizers in Cmm] in GHC.Cmm.InitFini for details.ghc-Format the section type part of a Cmm Sectionghc-Format a Cmm Section into a LLVM section nameghcHandle static dataghc(Generate Llvm code for a static literal.Will either generate the code or leave it unresolved if it is a % which isn't yet known. Safe-InferredghcPretty print LLVM data codeghcPretty print LLVM codeghcThe section we are putting info tables and their entry code into, should be unique since we process the assembly pattern matching this. Safe-Inferred "(Vghc$Top-level of the LLVM Code generatorghc8Do LLVM code generation on all these Cmms data sections.ghcComplete LLVM code generation phase for a single top-level chunk of Cmm.ghcGenerate meta data nodesghc'Marks variables as used where necessary???? Safe-Inferred()*9ghcThe result type of most operations is determined by the operands. However, there are a few exceptions: particularly operations which might get promoted to a signed result. For these we explicitly cast the result.ghcProduce a list of word sized literals encoding the given list of qs.ghcPrint in C hex format Examples:5114 :: W32 ===> ((StgWord32)0x13faU) (-5114) :: W32 ===> ((StgWord32)(-0x13faU))We use casts to support types smaller than `unsigned int`; C literal suffixes support longer but not shorter types.ghcConstruct a constructor/finalizer function. Instead of emitting a initializer/finalizer array we rather just emit a single function, annotated with the appropriate C attribute, which then calls each of the initializers. Safe-Inferred4ghcIs the SRT offset field inline in the info table on this platform?See the section "Referring to an SRT from the info table" in Note [SRTs] in GHC.Cmm.Info.BuildghcValue of the srt field of an info table when using an StgLargeSRTghcWrap a q in an alignment check when -falignment-sanitisation is enabled.ghc:Takes a closure pointer and returns the info table pointerghcTakes an info pointer (the first word of a closure) and returns its entry codeghcTakes a closure pointer, and return the *zero-indexed* constructor tag obtained from the info table This lives in the SRT field of the info table (constructors don't need SRTs).ghcTakes a closure pointer, and return the closure type obtained from the info tableghcTakes an info pointer (the first word of a closure) and returns a pointer to the first word of the standard-form info table, excluding the entry-code word (if present)ghcTakes an info table pointer (from infoTable) and returns the constr tag field of the info table (same as the srt_bitmap field)ghcTakes an info table pointer (from infoTable) and returns the srt_bitmap field of the info tableghcTakes an info table pointer (from infoTable) and returns the closure type field of the info table.ghcTakes the info pointer of a function, and returns a pointer to the first word of the StgFunInfoExtra struct in the info table.ghcTakes the info pointer of a function, returns the function's arityghcByte offset of the SRT bitmap half-word which is in the *higher-addressed* part of the type_litghc)Byte offset of the closure type half-wordghcReturns: 1. The bitmap (literal value or label) 2. Large bitmap CmmData if needed Safe-Inferred%ghcGet the registers that are being used by this instruction. regUsage doesn't need to do any trickery for jumps and such. Just state precisely the regs read and written by that insn. The consequences of control flow transfers, as far as register allocation goes, are taken care of by the register allocator.ghcApply a given mapping to all the register references in this instruction.ghcChecks whether this instruction is a jump/branch instruction. One that can change the flow of control in a way that the register allocator needs to worry about.ghcChecks whether this instruction is a jump/branch instruction. One that can change the flow of control in a way that the register allocator needs to worry about.ghcChange the destination of this jump instruction. Used in the linear allocator when adding fixup blocks for join points.ghc5An instruction to spill a register into a spill slot.ghcThe size of a minimal stackframe header including minimal parameter save area.ghcThe maximum number of bytes required to spill a register. PPC32 has 32-bit GPRs and 64-bit FPRs, while PPC64 has 64-bit GPRs and 64-bit FPRs. So the maximum is 8 regardless of platforms unlike x86. Note that AltiVec's vector registers are 128-bit wide so we must not use this to spill them.ghc reg move instruction or Nothing if it's not one Safe-Inferred(L Safe-Inferred),ghcOutput the ELF .size directive.ghc7Print appropriate alignment for the given section type.ghcProcedure name Safe-Inferred)*0ghc(Expressions, used for unwind informationghc literal valueghcregister plus offsetghcpointer dereferencingghcMaps registers to expressions that yield their "old" values further up the stack. Most interesting for the stack pointer Sp, but might be useful to document saved registers, too. Note that a register's value will be J= when the register's previous value cannot be reconstructed.ghcA label associated with an ghcIntermediate data structure holding debug-relevant context information about a block.ghcDebug information about a block of code. Ticks scope over nested blocks.ghcEntry label of containing procghc Hoopl labelghc Output labelghcHas an info table?ghc9The parent of this proc. See Note [Splitting DebugBlocks]ghcTicks defined in this blockghcBest source tick covering blockghc+Output position relative to other blocks. Nothing# means the block was optimized outghc Nested blocksghcExtract debug data from a group of procedures. We will prefer source notes that come from the given module (presumably the module that we are currently compiling).ghc1Build a map of blocks sorted by their tick scopesThis involves a pre-order traversal, as we want blocks in rough control flow order (so ticks have a chance to be sorted in the right order).ghcSets position and unwind table fields in the debug block tree according to native generated code.ghc9Converts debug blocks into a label map for easier lookupsüghcConversion of Cmm expressions to unwind expressions. We check for unsupported operator usages and simplify the expression as far as possible.ü¼ü¼ Safe-Inferred: ۼghcN.B. when used with the  , the source operand is interpreted to be a 32-bit sign-extended value. True 64-bit operands need to be moved with MOVABS , which we currently don't use.ݼghcThe format argument is the size of operand 1 (the number of bits we keep) We always zero *all* high bits, even though this isn't how the actual instruction works. The code generator also seems to rely on this behaviour and it's faster to execute on many cpus as well so for now I'm just documenting the fact.ghcX86 call instructionghcReturns which registers are read and written as a (read, written) pair.ghc8Is this register interesting for the register allocator?ghcApplies the supplied function to all registers in instructions. Typically used to change virtual registers to real registers.ghcMake a spill instruction.ghc Make a spill reload instruction.ghc?See if this instruction is telling us the current C stack deltaghc Make a reg-reg move instruction.ghcCheck whether an instruction represents a reg-reg move. The register allocator attempts to eliminate reg->reg moves whenever it can, by assigning the src and dest temporaries to the same real register.ghc)Make an unconditional branch instruction.ghcOn most OSes the kernel will place a guard page after the current stack page. If you allocate larger than a page worth you may jump over this guard page. Not only is this a security issue, but on certain OSes such as Windows a new page won't be allocated if you don't hit the guard. This will cause a segfault or access fault.This function defines if the current allocation amount requires a probe. On Windows (for now) we emit a call to _chkstk for this. For other OSes this is not yet implemented. See  https://docs.microsoft.com/en-us/windows/desktop/DevNotes/-win32-chkstk& The Windows stack looks like this:SP GUARD PAGE  UNMAPPED In essence each allocation larger than a page size needs to be chunked and a probe emitted after each page allocation. You have to hit the guard page so the kernel can map in the next page, otherwise you'll segfault. See Note [Windows stack allocations].ghc Jump targetghc,Arguments (required for register allocation)Լռڼۼּ׼ؼټܼݼ޼߼˼̼μͼϼмѼҼӼȼɼʼԼռڼۼּ׼ؼټܼݼ޼߼˼̼μͼϼмѼҼӼȼɼʼ Safe-Inferred>ghcOutput an internal proc label. See Note [Internal proc labels] in CLabel.ghcOutput the ELF .size directive.ghcPrint section header and appropriate alignment for that section.ghc7Print appropriate alignment for the given section type.ghcProcedure nameghc Block name Safe-Inferred> Safe-InferredE;ghcFor a jump instruction at the end of a block, generate fixup code so its vregs are in the correct regs for its destination.ghc.Construct a graph of register/spill movements.1Cyclic components seem to occur only very rarely.We cut some corners by not handling memory-to-memory moves. This shouldn't happen because every temporary gets its own stack slot.ghcExpand out the destination, so InBoth destinations turn into a combination of InReg and InMem.ghcGenerate fixup code for a particular component in the move graph This component tells us what values need to be moved to what destinations. We have eliminated any possibility of single-node cycles in expandNode above.ghc(Move a vreg between these two locations.ghcmaps the unique of the blockid to the set of vregs that are known to be live on the entry to each block.ghcid of the current blockghc,branch instr on the end of the source block.ghcmaps the unique of the blockid to the set of vregs that are known to be live on the entry to each block.ghcacc blocks of fixup code.ghcid of the current blockghc,branch instr on the end of the source block.ghc&branch destinations still to consider.ghcsource of moveghcdestination of moveghccurrent C stack delta.ghc%unique of the vreg that we're moving.ghcsource location.ghcdestination location.ghcmove instruction. Safe-Inferred/M# ghcConstraints on the instruction instances used by the linear allocator.ghcDo register allocation on some basic blocks. But be careful to allocate a block in an SCC only if it has an entry in the block map or it is the first block.ghc*Do register allocation on this basic blockghcLoad the freeregs and current reg assignment into the RegM state for the basic block with this BlockId.ghc-Do allocation for a sequence of instructions.ghc'Do allocation for a single instruction.ghcMark all these real regs as allocated, and kick out their vreg assignments.ghcGiven a virtual reg find a preferred real register. The preferred register is simply the first one the variable was assigned to (if any). This way when we allocate for a loop variables are likely to end up in the same registers at the end and start of the loop, avoiding redundant reg-reg moves. Note: I tried returning a list of past assignments, but that turned out to barely matter.ghc:Calculate a new location after a register has been loaded.ghc=Load up a spilled temporary if we need to (read from memory).ghc entry pointsghc&live regs on entry to each basic blockghc$instructions annotated with "deaths"ghc entry pointsghc&live regs on entry to each basic blockghc$instructions annotated with "deaths"ghc&live regs on entry to each basic blockghc"block to do register allocation onghcblock with registers allocatedghc2map of what vregs are live on entry to each block.ghc'id of the current block, for debugging.ghc.liveness annotated instructions in this block.ghc2map of what vregs are love on entry to each block.ghc/accumulator for instructions already processed.ghc*the id of the current block, for debuggingghc9the instr to have its regs allocated, with liveness info.# Safe-Inferred (9SghcTwo 32-bit regs used as a single virtual 64-bit register and the code to set them appropriatelyghc8Two 32-bit regs used as a single virtual 64-bit registerghcHaving a CFG with additional information is essential for some operations. However we can't reconstruct all information once we generated instructions. So instead we update the CFG as we go.˽ghc  is only for printing internal labels. See Note [Internal proc labels] in CLabel.ϽghcThe list of block ids records the redirected jumps to allow us to update the CFG.ѽghcgiven the instruction sequence of a block, produce a list of the block's 2s See Note [What is this unwinding business?] in GHC.Cmm.DebugBlock= and Note [Unwinding information in the NCG] in this module.ҽghcTurn the sequence of jcc l1; jmp l2 into jncc l2;  when possible.׽ghcGet CFG edge weightsܽghc%Record that we added a block between from and old.ݽghcPlace  after block' and change any edges block -> X to  -> Xghc Return a virtual 64-bit registerghc7Convert a 64-bit LocalReg into two virtual 32-bit regs.9Used to handle 64-bit "registers" on 32-bit architecturesghc'Get native code generator configurationghcHelper to check whether the data resides in a DLL or not, see  labelDynamicghcSays what we have to add to our 'PIC base register' in order to get the address of a label.   Safe-Inferred )*gwghc+Memory addressing modes passed up the tree.ghcRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in.ghc#Condition codes passed up the tree.ghcs are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal yields the insns in the correct order.ghcConvert ڼ instructions into ټ) instructions to capture changes in the sp: register. See Note [What is this unwinding business?] in GHC.Cmm.DebugBlock for details.ghcbid refers to the current block and is used to update the CFG if new blocks are inserted in the control flow. See Note [Keeping track of the current block] for more details.ghcGrab the Reg for a CmmRegghcCheck whether an integer will fit in 32 bits. A CmmInt is intended to be truncated to the appropriate number of bits, so here we truncate it to Int64. This is important because e.g. -1 as a CmmInt might be either -1 or 18446744073709551615.ghc(Convert a BlockId to some CmmStatic dataghcThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.ghc Convert a q' representing a memory address into an .An  is a datatype representing a valid address form for the target (e.g. "Base + Index + disp" or immediate) and the code to compute it.ghcLike , but on 32-bit use simple register addressing (i.e. no index register). This stops us from running out of registers on x86 when using instructions such as cmpxchg, which can use up to three virtual registers and one fixed register.ghcGiven a , produce a new  with an instruction block which will check the value for alignment. Used for -falignment-sanitisation.ghc%We return the instructions generated.ghcSee Note [Evaluate C-call arguments before placing in destination registers]ghc1Generate C call to the given function in ghc-primghc-Generate C call to the given function in libcghc0Generate C call to the given function in the RTSghcGenerate a real C call to the given address with the given conventionghcThis works on the invariant that all jumps in the given blocks are required. Starting from there we try to make a few more jumps redundant by reordering them. We depend on the information in the CFG to do so so without a given CFG we do nothing.ghcCount trailing zeroesghcCount trailing zeroes#64-bit width on 32-bit architectureghcCount trailing zeroes!Generic case (width <= word size)ghc Copy memoryUnroll memcpy calls if the number of bytes to copy isn't too large (cf ncgInlineThresholdMemcpy). Otherwise, call C's memcpy.ghcSet memory to the given byteUnroll memset calls if the number of bytes to copy isn't too large (cf ncgInlineThresholdMemset). Otherwise, call C's memset.ghc7Basic block these statement will start to be placed in.ghc Cmm StatementghcResulting instructionghc6Basic block this statement will start to be placed in.ghcInstructions, and bid of new block if successive statements are placed in a different basic block.ghcfunction to callghcwhere to put the resultghcarguments (of mixed type)ghcThe block we are inghcThe block we are inghcMachOpghcwhere to put the resultghcarguments (of mixed type)ghcthe block we are inghcMachOpghcwhere to put the resultghcarguments (of mixed type)ghcaddress of the function to callghccalling conventionghcwhere to put the resultghcarguments (of mixed type)ghcaddress of function to callghccalling conventionghcwhere to put the resultghcarguments (of mixed type)ghcCFG if presentghcBlocks with info tablesghcList of basic blocks Safe-Inferredgghc-Instruction instance for x86 instruction set. Safe-Inferred)*kghcRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in.ghcs are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal yields the insns in the correct order.ghcs are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal (pre-order?) yields the insns in the correct order.ghcGrab the Reg for a CmmRegghc(Convert a BlockId to some CmmStatic dataghcCompute an expression into a register, but we don't mind which one it is. Safe-Inferredl%ghc Instruction instance for powerpc Safe-Inferred 1qghcA non empty ordered sequence of basic blocks. It is suitable for serialization in this order.We use OrdList instead of [] to allow fast append on both sides when combining chains.ghcMaps blocks near the end of a chain to it's chain AND the other blocks near the end. [A,B,C,D,E] Gives entries like (B -> ([A,B], [A,B,C,D,E])) where [A,B] are blocks in the end region of a chain. This is cheaper then recomputing the ends multiple times.ghcLook at X number of blocks in two chains to determine if they are "neighbours".ghcGiven the Chain A -> B -> C -> D and we break at C we get the two Chains (A -> B, C -> D) as result.ghcFor a given list of chains and edges try to combine chains with strong edges between them.ghcPlace basic blocks based on the given CFG. See Note [Chain based CFG serialization]ghcRemove redundant jumps between blocks when we can rely on fall through.ghcEdges to considerghcCurrent chains of blocksghcResulting list of block chains, and a set of edges which were used to fuse chains and as such no longer need to be considered.ghc)Keys indicate an info table on the block.ghc&Control flow graph and some meta data.ghc"List of basic blocks to be placed.ghcBlocks placed in sequence.ghcCFG if we have one.ghcFunction to serialize Safe-InferredrghcInitialize the native code generator configuration from the DynFlags Safe-Inferred P'ghcUnwind instructions for a block. Will become part of the containing FDE.ghcthese unwind points must occur in the same order as they occur in the blockghcUnwind instructions for an individual procedure. Corresponds to a "Frame Description Entry" (FDE) in DWARF.ghc%List of blocks. Order must match asm!ghcInformation about unwind instructions for a procedure. This corresponds to a "Common Information Entry" (CIE) in DWARF.ghcA DWARF address range. This is used by the debugger to quickly locate which compilation unit a given address belongs to. This type assumes a non-segmented address-space.ghc;Abbreviation codes used for encoding above records in the  .debug_info section.ghc)Pseudo, used for marking the end of listsghcIndividual dwarf records. Each one will be encoded as an entry in the  .debug_info section.ghc)label of DIE belonging to the parent tickghc1Generate assembly for the given abbreviation codeghcAbbreviation declaration. This explains the binary encoding we use for representing 1. Be aware that this must be updated along with .ghc Generate assembly for DWARF dataghc+Print a CLabel name in a ".stringz "LABEL""ghcPrints assembler data corresponding to DWARF info records. Note that the binary format of this is parameterized in  abbrevDecls and has to be kept in synch.ghc'Close a DWARF info record with childrenghc4Print assembler directives corresponding to a DWARF .debug_aranges address table entry.ghcHeader for the  .debug_frame section. Here we emit the "Common Information Entry" record that establishes general call frame parameters and the default stack layout.ghcWrites a "Frame Description Entry" for a procedure. This consists mainly of referencing the CIE and writing state machine instructions to describe how the frame base (CFA) changes.ghcGenerates unwind information for a block. We only generate instructions where unwind information actually changes. This small optimisations saves a lot of space, as subsequent blocks often have the same unwind information.ghc+Get DWARF register ID for a given GlobalRegghcGenerate code for setting the unwind information for a register, optimized using its known old value in the table. Note that Sp/ is special: We see it as synonym for the CFA.ghc'Print the register number of the given ;' as an unsigned LEB128 encoded number.ghcGenerates a DWARF expression for the given unwind expression. If spIsCFA is true, we see Sp0 as the frame base CFA where it gets mentioned.ghcGenerate code for re-setting the unwind information for a register to  undefinedghc)Align assembly at (machine) word boundaryghc1Assembly for a single byte of constant DWARF dataghc(Assembly for a two-byte constant integerghc"Assembly for a constant DWARF flagghc*Assembly for 4 bytes of dynamic DWARF dataghc+Assembly for 4 bytes of constant DWARF dataghcAssembly for a DWARF word of dynamic data. This means 32 bit, as we are generating 32 bit DWARF.ghcAssembly for a machine word of dynamic data. Depends on the architecture we are currently generating code for.ghcPrints a number in "little endian base 128" format. The idea is to optimize for small numbers by stopping once all further bytes would be 0. The highest bit in every byte signals whether there are further bytes to read.ghcSame as  pprLEBWord, but for a signed numberghcGenerates a dynamic null-terminated string. If required the caller needs to make sure that the string is escaped properly.ghc>Generate a string constant. We take care to escape the string.ghc%Escape a single non-unicode characterghcGenerate an offset into another section. This is tricky because this is handled differently depending on platform: Mac Os expects us to calculate the offset using assembler arithmetic. Linux expects us to just reference the target directly, and will figure out on their own that we actually need an offset. Finally, Windows has a special directive to refer to relative offsets. Fun.ghc4the register to produce an unwinding table entry forghc&the old and new values of the register.. Safe-Inferred6 ghc Generate DWARF/debug informationghcBuild an address range entry for one proc. With split sections, each proc needs its own entry, since they may get scattered in the final binary. Without split sections, we could make a single arange based on the first/last proc.ghcHeader for a compilation unit, establishing global format parametersghcCompilation unit footer, mainly establishing size of debug sectionsghcSplits the blocks by procedures. In the result all nested blocks will come from the same procedure as the top-level block. See Note [Splitting DebugBlocks] for details.ghc/Generate DWARF info for a procedure debug blockghcGenerate DWARF info for a blockghcGenerates the data for the debug frame section, which encodes the desired stack unwind behaviour for the debuggerghc8Generates unwind information for a procedure debug block Safe-Inferred ")* ghcRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in.ghcs are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal yields the insns in the correct order.ghc Utilitiesghcbid refers to the current block and is used to update the CFG if new blocks are inserted in the control flow. See Note [Keeping track of the current block] for more details.ghcSometimes we need to change the Format of a register. Primarily during conversion.ghcGrab the Reg for a CmmRegghcConvert a BlockId to some CmmStatic data TODO: Add JumpTable Logic, see Ticket 19912 jumpTableEntry :: NCGConfig -> Maybe BlockId -> CmmStatic jumpTableEntry config Nothing = CmmStaticLit (CmmInt 0 (ncgWordWidth config)) jumpTableEntry _ (Just blockid) = CmmStaticLit (CmmLabel blockLabel) where blockLabel = blockLbl blockidThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.ghcThe register width to be used for an operation on the given width operand.ghc3Is a given number encodable as a bitmask immediate? https://stackoverflow.com/questions/30904718/range-of-immediate-values-in-armv8-a64-assemblyghcInstructions to sign-extend the value in the given register from width w up to width w'.ghcInstructions to truncate the value in the given register from width w down to width w'.ghc7Basic block these statement will start to be placed in.ghc Cmm StatementghcResulting instructionghc6Basic block this statement will start to be placed in.ghcInstructions, and bid of new block if successive statements are placed in a different basic block.ghcwidth of loaded value Safe-Inferredghc Instruction instance for aarch64 Safe-Inferred)*1 ghc abstracted over n (the node type)ghc?Function for rewriting and analysis combined. To be used with  rewriteCmm.Currently set to work with UniqSM monad, but we could probably abstract that away (if we do that, we might want to specialize the fixpoint algorithms to the particular monads through SPECIALIZE).ghc abstracted over n (the node type)ghc*The result of joining OldFact and NewFact.ghc!Result is different than OldFact.ghcResult is the same as OldFact.ghcSort the blocks into the right order for analysis. This means reverse postorder for a forward analysis. For the backward one, we simply reverse that (see Note [Backward vs forward analysis]).ghcConstruct a mapping from a Label to the block indexes that should be re-analyzed if the facts at that Label change.Note that we're considering here the entry point of the block, so if the facts change at the entry: * for a backward analysis we need to re-analyze all the predecessors, but * for a forward analysis, we only need to re-analyze the current block (and that will in turn propagate facts into its successors).ghcAfter some new facts have been generated by analysing a block, we fold this function over them to generate (a) a list of block indices to (re-)analyse, and (b) the new FactBase.ghcReturns the result of joining the facts from all the successors of the provided node or block.ghc(Returns the joined facts for each label.ghcFolds backward over all nodes of an open-open block. Strict in the accumulator.ghcFolds backward over all the nodes of an open-open block and allows rewriting them. The accumulator is both the block of nodes and f> (usually dataflow facts). Strict in both accumulated parts.KKKK Safe-Inferred )*ghc>Specialization that only retains the keys for local variables.Local variables are mostly glorified Ints, and some parts of the compiler really don't care about anything but the Int part. So we can avoid some overhead by computing a IntSet instead of a Set LocalReg which (unsurprisingly) is quite a bit faster.ghc:A mapping from block labels to the variables live on entryghc&The variables live on entry to a blockghcThe dataflow latticeghc'Calculated liveness info for a CmmGraphghcOn entry to the procedure, there had better not be any LocalReg's live-in. If you see this error it most likely means you are trying to use a variable without it being defined in the given scope.¾ghcThe dataflow latticeghcOn entry to the procedure, there had better not be any LocalReg's live-in.þ¾ľþ¾ľ Safe-Inferred)*ghcconflicts (r,e) node is False if and only if the assignment r = e' can be safely commuted past statement node.žž Safe-Inferred %)*   Safe-Inferred )*9\ghc2Check for obviously out-of-bounds shift operationsghcAs noted in Note [Register parameter passing], the arguments and ; of a foreign call mustn't mention caller-saved registers. Safe-Inferred)* ƾghcThe result of dominator analysis. Also includes a reverse postorder numbering, which is needed for dominator analysis and for other (downstream) analyses.Invariant: Dominators, graph, and RP numberings include only *reachable* blocks.˾ghc+Reverse postorder number of a node in a CFG̾ghcDominator setsNode X dominates node Y if and only if every path from the entry to Y includes X. Node Y technically dominates itself, but it is never included in the *representation* of its dominator set.A dominator set is represented as a linked list in which each node points to its *immediate* dominator, which is its parent in the dominator tree. In many circumstances the immediate dominator will be the only dominator of interest.Ͼghc!Label of the immediate dominator.оghc0Set of nodes dominating the immediate dominator.ѾghcUse to tell if the given label is in the given dominator set. Which is to say, does the bloc with with given label _properly_ and _non-vacuously_ dominate the node whose dominator set this is?Takes linear time in the height of the dominator tree, but uses space efficiently.ҾghcIntersect two dominator sets to produce a third dominator set. This function takes time linear in the size of the sets. As such it is inefficient and should be used only for things like visualizations or linters.ӾghcCall this function with a  to get back the results of a dominator analysis of that graph (as well as a reverse postorder numbering). The result also includes the subgraph of the original graph that contains only the reachable blocks.ԾghcUtility functionsCall Ծ to get the mapping from K to  that is embedded in every .վghcUse վ on the result of the dominator analysis to get a mapping from the K of each reachable block to the reverse postorder number of that block.־ghcUse ־ on the result of the dominator analysis to get a mapping from the K of each reachable block to the dominator set (and the immediate dominator) of that block. The implementation is space-efficient: intersecting dominator sets share the representation of their intersection.ghc2Turn a function into an array. Inspired by SML's ̾;ξϾоƾǾȾɾʾ˾ӾԾվ־׾ѾҾ̾;ξϾоƾǾȾɾʾ˾ӾԾվ־׾ѾҾ Safe-Inferred 1ghcThe syntactic constructs in which Wasm code may be contained. A list of these constructs represents an evaluation context, which is used to determined what level of br$ instruction reaches a given label.ghc1Carries the label that follows `if...end`, if anyghcModule : GHC.Wasm.ControlFlow.FromCmm Description : Translation of (reducible) Cmm control flow to WebAssemblyCode in this module can translate any _reducible_ Cmm control-flow graph to the structured control flow that is required by WebAssembly. The algorithm is subtle and is described in detail in a draft paper to be found at  .https://www.cs.tufts.edu/~nr/pubs/relooper.pdf.Abstracts the kind of control flow we understand how to convert. A block can be left in one of four ways:Unconditionally%Conditionally on a predicate of type e=To a location determined by the value of a scrutinee of type e Not at all.޾ghc;Convert a Cmm CFG to WebAssembly's structured control flow.ghcA CmmSwitch scrutinee may have any width, but a br_table operand must be exactly word sized, hence the extension here. (#22871)޾ghcneeded for offset calculationghctranslator for expressionsghc!translator for straight-line codeghcCFG to be translated޾޾4 Safe-Inferred"%&)*1Ʊ;ghc*Pop the results into locals after a ccall.ghcMake a global definition for the string, and return its label Safe-Inferred %&ghc0lower bound (inclusive), upper bound (exclusive)ghcaddToMem rep ptr n adds n to the integer pointed-to by ptr.ghcaddToMemE rep ptr n adds n to the integer pointed-to by ptr.ghcEmit a data-segment data blockghcEmit a read-only data blockghcEmit code to add an entry to a now-overwritten pointer to the update remembered set.ghcA bare bones InfoProvEnt for things which don't have a good source locationghc:Convert source information collected about identifiers in  to entries suitable for placing into the info table provenance table.The initial stats given to this function will (or should) only contain stats for stack info tables skipped during generateCgIPEStub. As the fold progresses, counts of tables per closure type will be accumulated.ghcUse signed comparisonsghc&value of pointer which was overwrittenghc the thunk>ӿr>ӿr Safe-Inferred[ghcCheck all arguments marked as cbv for the presence of a tag *at runtime*.ghcCheck all required-tagged arguments of a constructor are tagged *at compile time*.ghcCall barf if we failed to predict a tag correctly. This is immensely useful when debugging issues in tag inference as it will result in a program abort when we encounter an invalid call/heap object, rather than leaving it be and segfaulting arbitrary or producing invalid results. We check if either: * A tag is present * Or the object is a 25 (for which zero is the proper tag)ghcJump to the first block if the argument closure is subject to tagging requirements. Otherwise jump to the 2nd one. Safe-Inferredghc;Emit top-level tables for HPC and return code to initialise Safe-Inferred )*ghc5Collect all of the memory locations loaded from by a q.ghc$Generate TSAN instrumentation for a ; occurrence.ghcMirrors __tsan_memory_order https://github.com/llvm-mirror/compiler-rt/blob/master/include/sanitizer/tsan_interface_atomic.h#L32ghcthe applied operationghcresultsghc argumentsghcK* a block of instrumentation, if applicableghcfunctionghcresultsghc argumentsghc function nameghcformalsghc argumentsghcsuccess orderingghcfailure orderingghcaddressghcexpected valueghc new valueghcresult destination Safe-Inferred"ghc:FVS, StgArg because for thunks these can also be literals.ghcArgsghc(Number of arguments for a ticky counter.Ticky currently treats args to constructor allocations differently than those for functions/LNE bindings.ghcRegister a ticky counter.It's important that this does not race with other entries of the same closure, lest the ticky_entry_ctrs list may become cyclic. However, we also need to make sure that this is reasonably efficient. Consequently, we first perform a normal load of the counter's "registered" flag to check whether registration is necessary. If so, then we do a compare-and-swap to lock the counter for registration and use an atomic-exchange to add the counter to the list. if ( f_ct.registeredp == 0 ) { if (cas(f_ct.registeredp, 0, 1) == 0) { old_head = xchg(ticky_entry_ctrs, f_ct); f_ct.link = old_head; } } ghcPredicted a pointer would be tagged correctly (GHC will crash if not so no miss case)ghc2Pass a boolean expr indicating if tag was present.ghcCalled when for `case v of ...` we can avoid entering v based on tag inference information.ghcFVsghcArgsghcstaticghc updateableghc Free varsghc updateableghcFree vars + functionghclbl for the counterghcarityghcfun descghcarg descghc json descghcinfo table lblghc!size of the full header, in bytesghcsize of the payload, in bytes   Safe-Inferred Safe-Inferred9ghcUsed to tell the various mkVirtHeapOffsets functions what kind of header the object has. This will be accounted for in the offsets of the fields returned.ghc$Return multiple values to the sequelIf the sequel is Return  return (x,y)If the sequel is AssignTo [p,q]  p=x; q=y;ghcemitCall conv fun args# makes a call to the entry-code of fun$, using the call/return convention conv , passing args3, and returning the results to the current sequel.ghc*emitCallWithExtraStack conv fun args stack$ makes a call to the entry-code of fun#, using the call/return convention conv , passing args0, pushing some extra stack frames described by stack2, and returning the results to the current sequel.ghc takes a list of function arguments and prepares them for pushing on the stack for "extra" arguments to a function which requires fewer arguments than we currently have.ghc1Just like mkVirtHeapOffsets, but for constructorsghcJust like mkVirtConstrOffsets, but used when we don't have the actual arguments. Useful when e.g. generating info tables; we just need to know sizes of pointer and non-pointer fields."" Safe-Inferred 1C ghc%The type used in binder positions in ks.ghcLet(-no-escape)-bound thing with a flag indicating whether it occurs as an argument or in a nullary application (see GHC.Stg.Lift.Analysis#arg_occs).ghcEvery other kind of binderghcCaptures details of the syntax tree relevant to the cost model, such as closures, multi-shot lambdas and case expressions.ghcGets the bound  out a .ghcReturns J for s and K the flag indicating occurrences as argument or in a nullary applications otherwise.ghcTags every binder with its  and let bindings with their s.ghcTags binders of an k with its  and let bindings with their s. Additionally, returns its  and the set of binder occurrences in argument and nullary application position (cf. GHC.Stg.Lift.Analysis#arg_occs).ghcHow many times will the lambda body of the RHS bound to the given identifier be evaluated, relative to its defining context? This function computes the answer in form of a Z.ghcCombines several heuristics to decide whether to lambda-lift a given let-binding to top-level. See GHC.Stg.Lift.Analysis#when for details.ghc?The size in words of a function closure closing over the given s, including the header.ghcThe number of words a single  adds to a closure's size. Note that this can't handle unboxed tuples (which may still be present in let-no-escapes, even after Unarise), in which case  will crash.ghc"closureGrowth expander sizer f fvs> computes the closure growth in words as a result of lifting f to top-level. If there was any growing closure under a multi-shot lambda, the result will be " . Also see GHC.Stg.Lift.Analysis#clogro.ghc free vars ghchow often the RHS was entered ghcIs the binding a let-no-escape?ghcLet bodyghc Binding groupghc9RHS skeletons, argument occurrences and annotated bindingghcIs the binding a let-no-escape?ghcLet body skeletonghc Argument occurrences in the bodyghc Binding groupghcLet skeleton, argument occurrences, scope skeleton of binding and the annotated bindingghcAn expander function, turning &s into &s. See .ghc Just abs_ids  =) This binding is beneficial to lift and abs_ids* are the variables it would abstract overghc:Expands outer free ids that were lifted to their free varsghc/Computes the closure footprint of an identifierghc0Binding group for which lifting is to be decidedghcFree vars of the whole binding group prior to lifting it. These must be available at call sites if we decide to lift the binding group.ghc(Abstraction of the scope of the functionghcClosure growth. "; indicates there was growth under a (multi-shot) lambda.kkkkkkkk Safe-Inferred=ghc=Lambda lifts bindings to top-level deemed worth lifting (see ).(Mostly) textbook instance of the lambda lifting transformation, selecting which bindings to lambda lift by consulting .ghcJust former_fvs  =( this RHS was lifted and we have to add  former_fvs. as lambda binders, discarding all free vars.ʥ˥̥ͥΥϥʥ˥̥ͥΥϥ Safe-Inferred %&qghc6All the information about the breakpoints for a moduleqghcThe array of flags, one per breakpoint, indicating which breakpoints are enabled.qghc3An array giving the source span of each breakpoint.qghcAn array giving the names of the free variables at each breakpoint.qghcAn array giving the names of the declarations enclosing each breakpoint. See Note [Field modBreaks_decls]qghc1Array pointing to cost centre for each breakpointqghc6info about each breakpoint from the bytecode generatorqghcC CostCentre typeqghcBreakpoint indexqghcInformation about a breakpoint that we know at code-generation time In order to be used, this needs to be hydrated relative to the current HscEnv by hydrateCgBreakInfo. Everything here can be fully forced and that's critical for preventing space leaks (see #22530)qghc)Type variables in scope at the breakpointqghcA reference to a top-level string literal; see Note [Generating code for top-level string literal bindings] in GHC.StgToByteCode.qghcOnly used internally in the assembler in an intermediate representation; should never appear in a fully-assembled UnlinkedBCO. Also see Note [Allocating string literals] in GHC.ByteCode.Asm.rghcConstruct an empty ModBreaksrrrrrrrrrrrrrrrrrrrrrrrrrrrrqqqqqqqqqqqqqqqqqqqrrrrqrqqqqqqqqqqqqqqrqrrrrrrrrrrrrrrrrrrrrrrrrrrrrqqqqqqqqqqqqqqqqqqqrrrrqrqqqqqqqqqqqqqqrq Safe-Inferred&|ghcAn entry to be inserted into a module's static pointer table. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.|ghc3Objects which have yet to be linked by the compiler|ghcAn object file (.o)|ghcStatic archive file (.a)|ghc3Dynamically linked library file (.so, .dll, .dylib)|ghcSerialised core which we can turn into BCOs (or object files), or used by some other backend See Note [Interface Files with Core Definitions]|ghcA list of BCOs, but hidden behind extra indirection to avoid being too strict.|ghcA byte-code object, lives only in memory. Also carries some static pointer table entries which should be loaded along with the BCOs. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.|ghcInformation we can use to dynamically link modules into the compiler|ghcTime at which this linkable was built (i.e. when the bytecodes were produced, or the mod date on the files)|ghcThe linkable module itself|ghc3Those files and chunks of code we have yet to link.4INVARIANT: A valid linkable always has at least one | item.|ghc>Current global mapping from closure Names to their true values|ghcThe current global mapping from RdrNames of DataCons to info table addresses. When a new Unlinked is linked into the running image, or an existing module in the image is replaced, the itbl_env must be updated appropriately.|ghcLike | and |, but for top-level 'Addr#' literals, see Note [Generating code for top-level string literal bindings] in GHC.StgToByteCode.|ghc6Current global mapping from Names to their true values|ghc7The currently loaded interpreted modules (home package)|ghc8And the currently-loaded compiled modules (home package)|ghcThe currently-loaded packages; always object code haskell libraries, system libraries, transitive dependencies|ghcWe need to remember the name of previous temporary DLL/.so libraries so we can link them (see #10322)}ghc6Is this an actual file on disk we can link in somehow?}ghc1Is this a bytecode linkable with no file on disk?}ghcRetrieve the filename of the linkable if possible. Panic if it is a byte-code object}ghcRetrieve the compiled byte-code if possible. Panic if it is a file-based linkable;|||||||||||||||||||||||||||||||||||||||}}}}}}}|||||||||||||;|||||||||||||||||||||||||||||||||||||||}}}}}}}||||||||||||| Safe-Inferred2%ghcA restricted form of  for code generation purposesghcModule being compiledghcAlgebraic data types (including ones that started life as classes); generate constructors and info tables. Includes newtypes, just for the benefit of External CoreghcThe tidied main bindings, including previously-implicit bindings for record and class selectors, and data constructor wrappers. But *not* data constructor workers; reason: we regard them as part of the code-gen of tyconsghcForeign export stubsghc>Dependent packages, used to generate #includes for C code genghc%Program coverage tick box informationghcModule breakpointsghcStatic pointer table entries for static forms defined in the module. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTableghcA ModGuts is carried through the compiler, accumulating stuff as it goes There is only one ModGuts at any time, the one for the module being compiled right now. Once it is compiled, a ModIface and  ModDetails, are extracted and the ModGuts is discarded.ghcModule being compiledghcWhether it's an hs-boot moduleghc$For error messages from inner passesghcWhat it exportsghc*What it depends on, directly or otherwiseghc$What was used? Used for interfaces.ghcDid we run a TH splice?ghcTop-level lexical environmentghcFixities declared in this module. Used for creating interface files.ghc=TyCons declared in this module (includes TyCons for classes)ghc'Class instances declared in this moduleghc(Family instances declared in this moduleghc(Pattern synonyms declared in this moduleghcBefore the core pipeline starts, contains See Note [Overall plumbing for rules] in GHC.Core.RulesghcBindings for this moduleghc'Foreign exports declared in this moduleghc(Files to be compiled with the C compilerghcWarnings declared in the moduleghc#Annotations declared in this moduleghcComplete Matchesghc!Coverage tick boxes in the moduleghcBreakpoints for the moduleghc Class instance environment for  home-package% modules (including this one); c.f.  tcg_inst_envghc&Type-family instance environment for  home-package% modules (including this one); c.f. tcg_fam_inst_envghcSafe Haskell modeghcDo we need to trust our own package for Safe Haskell? See Note [Trust Own Package] in GHC.Rename.NamesghcDocumentation.++ Safe-Inferred:ghc?A full rule environment which we can apply rules from. Like a , but it also includes the set of visible orphans we use to filter out orphan rules which are not visible (even though we can see them...) See Note [Orphans] in GHC.CoreghcGathers a collection of \s. Maps (the name of) an  to its rulesghc Used to make \ for an 1 defined in the module being compiled. See also \‹ghcFind the "top" free names of several expressions. Such names are either: The function finally being applied to in an application chain (if that name is a GlobalId: see GHC.Types.Var#globalvslocal), orThe TyCon if the expression is a This is used for the fast-match-check for rules; if the top names don't match, the rest can'tghcruleCantMatch tpl actual returns True only if actual definitely can't match tpl by instantiating tpl. It's only a one-way match; unlike instance matching we don't consider unification.Notice that [_$_] )ruleCantMatch [Nothing] [Just n2] = False Reason: a template variable can be instantiated by a constant Also: )ruleCantMatch [Just n1] [Nothing] = False Reason: a local variable v in the actuals might [_$_]ȋghcGather all the rules for locally bound identifiers from the supplied bindingsӋghcThe main rule matching function. Attempts to apply all (active) supplied rules to this instance of an application in a given context, returning the rule applied and the resulting expression if successful.ԋghcReport partial matches for rules beginning with the specified string for the purposes of error reportingghc0Target; can have more elements than the templateԋghc Rule optionsghcRule activation testghc Rule patternghcRules for an IdghcBindings to check inghcResulting check messageӋ͋ы΋Ћϋɋʋˋ̋ԋċŋƋNjȋҋË‹Ӌ͋ы΋Ћϋɋʋˋ̋ԋċŋƋNjȋҋË‹ Safe-Inferred=ghc!Max #ticks in this simplifier runghcThe action to retrieve an up-to-date EPS RuleEnv See Note [Overall plumbing for rules]ghcMake a join id with given type and arity but without call-by-value annotations.ghcSize of the bindings, used to limit the number of ticks we allowQQQQQQQQQQ Safe-Inferred? ghcA substitution result.ÙghcName(s) of the phaseęghcWhether RULES are enabledřghcWhether inlining is enabledƙghc Whether eta-expansion is enabledǙghc!Do we swizzle casts past lambdas?șghcUnfolding optionsəghcWhether case-of-case is enabledʙghcWhether pre-inlining is enabled˙ghcWhether to enable floating outљghcCoercion optimiser optionsٙghcFast OutVarSet tracking which recursive RHSs we are analysing. See Note [Eta reduction in recursive RHSs] in GHC.Core.Opt.Arity.͙əϙЙǙ̙ƙ˙řÙљ™ʙΙęșҙәԙՙ֙יؙٙڙۙܙݙޙߙ͙əϙЙǙ̙ƙ˙řÙљ™ʙΙęșҙәԙՙ֙יؙٙڙۙܙݙޙߙ Safe-InferredF=ghc;Helps us find information about modules in the home packageghc7Information about modules in the package being compiledghcThe basic loaded interface file: every loaded module has one of these, even if it is imported from another packageghc1Extra information that has been created from the / for the module, typically during typecheckingghcThe actual artifact we would like to link to access things in this module. See Note [Home module build products] might be empty: If this is an .hs-boot moduleTemporarily during compilation if we pruned away the old linkable because it was out of date.When re-linking a module (), we construct the  by building a new { from the old  (only).njghc$Constructs an empty HomePackageTable ŒÌČŌƌnjȌʌˌ̌͌ΌόЌьҌɌՌӌԌ֌ ŒÌČŌƌnjȌʌˌ̌͌ΌόЌьҌɌՌӌԌ֌ Safe-InferredJ" ghc(Action to perform in backend compilationghc+Update the boot and signature file results.ghcRecompile this module.ghc#Information for the code generator.ghc Module infoghcPartial interfaceghcOld interface hash for this compilation, if an old interface file exists. Pass to hscMaybeWriteIface when writing the interface to avoid updating the existing interface when the interface isn't changed.ghc-Status of a module in incremental compilationghc*Nothing to do because code already exists.ghcRecompilation of module, or update of interface is required. Optionally pass the old interface hash to avoid updating the existing interface when it has not changed.   Safe-Inferred"J Safe-Inferred "-KghcCode generator for JavaScriptghc?Generate the ingredients for the linkable units for this moduleghc+variable prefix for the nth block in moduleghcOutput file nameghcthe linkable units Safe-InferredK Safe-InferredO}ghcExternal interpreter instance}ghcValues that need to be freed before the next command is sent. Threads can append values to this list asynchronously (by modifying the IServ state MVar).}ghc5Configuration needed to spawn an external interpreter}ghcExternal program to run}ghcCommand-line options}ghcUse Profiling way}ghcUse Dynamic way}ghcHook}ghc!Trace action executed after spawn}ghc State of an external interpreter}ghcNot spawned yet}ghcRunning}ghcExternal interpreterThe external interpreter is spawned lazily (on first use) to avoid slowing down sessions that don't require it. The contents of the MVar reflects the state of the interpreter (running or not).}ghcExternal interpreter}ghcInternal interpreter}ghc Interpreter}ghc)Interpreter instance (internal, external)}ghcInterpreter loader}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-Inferred(S7ghcTarget platformghcGenerate CStub or notghcIds for `unpackCString[Utf8]#`ghc StaticPtrInfo dataconghc StaticPtr dataconghc!Replaces all bindings of the form 'b = /\ ... -> makeStatic location valuewith b = /\ ... -> StaticPtr key (StaticPtrInfo "pkg key" "module" location) value3where a distinct key is generated for each binding.It also yields the C stub that inserts these bindings into the static pointer table.ghcsptModuleInitCode module fps. is a C stub to insert the static entries of module into the static pointer table.fps is a list associating each binding corresponding to a static entry with its fingerprint.   Safe-InferredS%zzzzzzBzzBzBBzBzzBzBzzzzzzzzzzzzzzzzz%zzzzzzBzzBzBBzBzzBzBzzzzzzzzzzzzzzzzz Safe-InferredTghc:A local block label (e.g. identifying a case alternative). Safe-InferredWghcBuild a PrimOp Idghc narrowN x3e.g. narrow16 (x .&. 0xFFFF) ==> narrow16 xghcMatch (op (op v e) e) or (op e (op v e)) or (op (op e v) e) or (op e (op e v)) and return the innermost (op v e) or (op e v).ghc+Match BigNat#, Integer and Natural literalsghcMatch numeric literalsghc8Match the application of a DataCon to a numeric literal.Can be used to match e.g.: IS 123# IP bigNatLiteral W# 123##ghc$Left identity rule for PrimOps like IntAddC and WordAddC, where, in addition to the result, we have to indicate that no carry/overflow occurred.ghc%Right identity rule for PrimOps like IntSubC and WordSubC, where, in addition to the result, we have to indicate that no carry/overflow occurred.ghcIdentity rule for PrimOps like IntAddC and WordAddC, where, in addition to the result, we have to indicate that no carry/overflow occurred.ghcCreate a numeric literal~ghcMatch the scrutinee of a case and potentially return a new scrutinee and a function to apply to each literal alternative.j~~j~~ Safe-Inferredoghc:Accumulated statistics about what we are putting into the !. "In" means stuff that is just read from interface files, "Out" means actually sucked in and type-checkedghcInformation about other packages that we have slurped in by reading their interface filesghcIn OneShot mode (only), home-package modules accumulate in the external package state, and are sucked in lazily. For these home-pkg modules (only) we need to record which are boot modules. We set this field after loading all the explicitly-imported interfaces, but before doing anything elseThe   part is not necessary, but it's useful for debug prints, and it's convenient because this field comes direct from ghcThe s for modules in external packages whose interfaces we have opened. The declarations in these interface files are held in the  eps_decls, ,  and  eps_rules$ fields of this record, not in the , fields of the interface we have sucked in.What is in the PIT is: The ModuleFingerprint info Its exportsFixitiesDeprecations and warningsghc Cache for #. Ordinarily, we can rely on the  for this information, EXCEPT that when we do dependency analysis, we need to look at the  Dependencies of our imports to determine what their precise free holes are (moduleFreeHolesPrecise). We don't want to repeatedly reread in the interface for every import, so cache it here. When the PIT gets filled in we can drop these entries.ghcResult of typechecking all the external package interface files we have sucked in. The domain of the mapping is external-package modulesghc The total z3 accumulated from all the external-package modulesghc The total d3 accumulated from all the external-package modulesghc The total RuleEnv3 accumulated from all the external-package modulesghc The total 93 accumulated from all the external-package modulesghc The total ^3 accumulated from all the external-package modulesghcThe family instances accumulated from external packages, keyed off the module that declared themghc7Statistics about what was loaded from external packagesghcInformation about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.ghcHelps us find information about modules in the imported packagesghc%Constructs an empty PackageIfaceTableghc&Add stats for one newly-read interface$$ Safe-Inferred 9:;y ߌghcExternal unitsghc0Stack of unit databases for the target platform.+This field is populated with the result of {.J4 means the databases have never been read from disk.Usually we don't reload the databases from disk if they are cached, even if the database flags changed!ghcThe dynamic flag settingsghcThe home package table describes already-compiled home-package modules,  excluding the module we are compiling right now. (In one-shot mode the current module is the only home-package module, so homeUnitEnv_hpt is empty. All other modules count as "external-package" modules. However, even in GHCi mode, hi-boot interfaces are demand-loaded into the external-package table.) is not mutable because we only demand-load external packages; the home package is eagerly loaded, module by module, by the compilation manager.0The HPT may contain modules compiled earlier by --make but not actually below the current module in the dependency graph.4(This changes a previous invariant: changed Jan 05.)ghc Home-unitghcInformation about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.ghcPlatformghc2GHC name/version (used for dynamic library suffix)ghc Get home-unit+Unsafe because the home-unit may not be setghcLookup > for every preload unit from the UnitState, for every unit used to instantiate the home unit, and for every unit explicitly passed in the given list of UnitId.ghcLookup > for every preload unit from the UnitState and for every unit used to instantiate the home unit.ghc+Test if the module comes from the home unitghc*Rename a unit id in the internal unit env. oldUnit newUnit UnitEnv, it is assumed that the oldUnit. exists in the map, otherwise we panic. The t3 associated with the home unit will have its field  set to newUnit.܌݌ތߌ،ٌڌی܌݌ތߌ،ٌڌی Safe-Inferred}ghcCreates some functions that work out the best ways to format names for the user according to a set of heuristics.ghcCreates a function for formatting modules based on two heuristics: (1) if the module is the current module, don't qualify, and (2) if there is only one exposed package which exports this module, don't qualify.ghcCreates a function for formatting packages based on two heuristics: (1) don't qualify if the package in question is "main", and (2) only qualify with a unit id if the package ID would be ambiguous.ghcA function which only qualifies package names if necessary; but qualifies all other identifiers. Safe-Inferred %&ghc/Number of parallel jobs doing BCO serializationghc3Run a command in the interpreter's context. With -fexternal-interpreter, the command is serialized and sent to an external iserv process, and the response is deserialized (hence the Binary constraint). With -fno-external-interpreter' we execute the command directly here.ghcGrab a lock on the } and do something with it. Overloaded because this is used from TcM as well as IO.ghcExecute an action of type IO [a] , returning s for each of the results.ghcExecute an action of type IO ()ghcExecute an action of type  IO StringghcExecute an action of type String -> IO StringghcAllocate and store the given bytes in memory, returning a pointer to the memory in the remote process.ghc4Create a set of BCOs that may be mutually recursive.ghcSend a Seq message to the iserv process to force a value #2950ghcProcess the result of a Seq or ResumeSeq message. #2950ghcloadDLL loads a dynamic library using the OS's native linker (i.e. dlopen() on Unix, LoadLibrary() on Windows). It takes either an absolute pathname to the file, or a relative filename (e.g. "libfoo.so" or "foo.dll"). In the latter case, loadDLL searches the standard locations for the appropriate library.Returns:0Nothing => success Just err_msg => failureghcSend a 0 and receive the response from the iserv processghc#Read a value from the iserv processghc!Send a value to the iserv processghcSpawn an external interpreterghcStop the interpreterghc Creates a & that will automatically release the ! when it is no longer referenced.ghc Convert a  to the value it references directly. This only works when the interpreter is running in the same process as the compiler, so it fails when -fexternal-interpreter is on.ghc Convert an  to the value it references directly. This only works when the interpreter is running in the same process as the compiler, so it fails when -fexternal-interpreter is on.ghcInterpreter uses Profiling wayghcInterpreter uses Dynamic way}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-Inferred5 Safe-InferredWghc9Initialise coercion optimiser configuration from DynFlagsghc7Initialise Simple optimiser configuration from DynFlagsghc!Extract BCO options from DynFlagsghc+Extract GHCi options from DynFlags and step Safe-Inferred Safe-Inferred  Safe-Inferred- Safe-Inferred %&9ghcFinds external references. Remember to remove the names defined by this group of BCOs themselves Safe-Inferred?ghcBring the exports of a particular module (filtered by an import decl) into scopeghcBring into scope the entire top-level envt of of this module, including the things imported into it.ghcInteractive context, recording information about the state of the context in which statements are executed in a GHCi session.ghcThe t: used to evaluate interactive expressions and statements.ghcEach GHCi stmt or declaration brings some new things into scope. We give them names like interactive:Ghci9.T, where the ic_index is the '9'. The ic_mod_index is incremented whenever we add something to ic_tythings See Note [The interactive package]ghcThe GHCi top-level scope (icReaderEnv) is extended with these importsThis field is only stored here so that the client can retrieve it with GHC.getContext. GHC itself doesn't use it, but does reset it to empty sometimes (such as before a GHC.load). The context is set with GHC.setContext.ghcTyThings defined by the user, in reverse order of definition (ie most recent at the front). Also used in GHC.Tc.Module.runTcInteractive to fill the type checker environment. See Note [ic_tythings]ghcEssentially the cached +.The GlobalRdrEnv contains everything in scope at the command line, both imported and everything in ic_tythings, with the correct shadowing.The IcGlobalRdrEnv contains extra data to allow efficient recalculation when the set of imports change. See Note [icReaderEnv recalculation]ghcAll instances and family instances created during this session. These are grabbed en masse after each update to be sure that proper overlapping is retained. That is, rather than re-check the overlapping each time we update the context, we just take the results from the instance code that already does that.ghc#Fixities declared in let statementsghc$The current default types, set by a  'default' declarationghc The stack of breakpoint contextsghc#The monad that GHCi is executing inghcThe function that is used for printing results of expressions in ghci and -e mode.ghcvirtual CWD of the programghcCache of loaded plugins. We store them here to avoid having to load them every time we switch to the interactive context.ghc'Constructs an empty InteractiveContext.ōghcThis function returns the list of visible TyThings (useful for e.g. showBindings).It picks only those TyThings that are not shadowed by later definitions on the interpreter, to not clutter :showBindings with shadowed ids, which would show up as Ghci9.foo.Some TyThings define many names; we include them if _any_ name is still available unqualified.ƍghcGet the NamePprCtx function based on the flags and this InteractiveContextǍghcextendInteractiveContext is called with new TyThings recently defined to update the InteractiveContext to include them. By putting new things first, unqualified use will pick the most recently defined thing with a given name, while still keeping the old names in scope in their qualified form (Ghci1.foo).ghcAdd TyThings to the GlobalRdrEnv, earlier ones in the list shadowing later ones, and shadowing existing entries in the GlobalRdrEnv.ǍȍɍˍʍÍčōƍǍȍɍˍʍÍčōƍ Safe-Inferred͍͍ Safe-Inferred%ghcFind all the link options in these and the preload packages, returning (package hs lib options, extra library options, other flags)ghc Either the  or  as appropriate for the way. Safe-Inferredghc On macOS we rely on the linkers -dead_strip_dylibs flag to remove unused libraries from the dynamic library. We do this to reduce the number of load commands that end up in the dylib, and has been limited to 32K (32768) since macOS Sierra (10.14).-dead_strip_dylibs does not dead strip -rpath entries, as such passing -l and -rpath to the linker will result in the unnecessary libraries not being included in the load commands, however the -rpath entries are all forced to be included. This can lead to 100s of -rpath entries being included when only a handful of libraries end up being truly linked.Thus after building the library, we run a fixup phase where we inject the -rpath for each found library (in the given library search paths) into the dynamic library through  -add_rpath.#See Note [Dynamic linking on macOS] Safe-InferredghcReturn the "link info" stringSee Note [LinkInfo section]   Safe-Inferred}ghc Luite Stegeman Sylvain Henry Josh Meredith  experimental Safe-Inferred "}ghc)ModuleCode after link with other modules.It contains less information than ModuleCode because they have been commoned up into global "metadata" for the whole link.ghcrendered exportsghcCompiled moduleghcrendered exportsghc!number of bytes linked per moduleghcnumber of bytes for metadataghc/link and write result to disk (jsexe directory)ghc8Link modules and pretty-print them into the given HandleghcRender linker statsghcCombine rts.js, lib.js, out.js to all.js that can be run directly with node.js or SpiderMonkey jsshellghcwrite the index.html file that loads the program if it does not exitghcwrite the runmain.js file that will be run with defer so that it runs after index.html is loadedghc-get all dependencies for a given set of rootsghc'collect dependencies for a set of rootsghcA helper function to read system dependencies that are hardcodedghc8dependencies for the RTS, these need to be always linkedghcExport the functions in baseghcExport the Prim functionsghcGiven a UnitId, a module name, and a set of symbols in the module, package these into an  ExportedFun.ghc4read all dependency data from the to-be-linked filesghc(Load dependencies for the Linker from ArghcPredicate to check that an entry in Ar is a JS source and to return it without its headerghc-Predicate to check that a file is a JS sourceghc+Get JS source with its header (if it's one)ghcread dependencies from an object that might have already been into memory pulls in all Deps from an archiveghcEmbed a JS file into a .o fileThe JS file is merely copied into a .o file with an additional header ("//Javascript") in order to be recognized later on.JS files may contain option pragmas of the form: //#OPTIONS: For now, only the CPP option is supported. If the CPP option is set, we append some common CPP definitions to the file and call cpp on it.ghcLink module codes.Performs link time optimizations and produces one JStat per module plus some commoned up initialization code.ghc/Only keep a single StaticInfo with a given nameghcInitialize a global object.>All global objects have to be declared (staticInfoDecl) first.ghcdeclare and do first-pass init of a global object (create JS object for heap objects) ghcoutput file/directoryghcinclude path for home packageghcpackages to linkghcthe object files we're linkingghcextra js files to include ghcfunctions from the objects to use as roots (include all their deps) ghcextra symbols to link inghclinked code per moduleghcadditional JS filesghcoutput directoryghcoutput directoryghcSettingsghcOutput directoryghc loaded depsghcdon't link these blocksghc start hereghcand also link theseghcDependency mapghc#packages, code linked in this orderghcAll dependencidesghc Packages that are already LinkedghcNew units and functions to linkghcDiffghcobject files to link Safe-Inferredghcfilename of executableghcextra objects to embed, maybe Safe-Inferredghc7Some platforms require that we explicitly link against libm if any math-y things are used (which we assume to include all programs). See #14022. Safe-InferredghcLinking a static lib will not really link anything. It will merely produce a static archive of all dependent static libraries. The resulting library will still need to be linked with any remaining link flags. Safe-Inferred^ghcHscEnv is like , except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. It's also used to store the dynamic linker state to allow for multiple linkers in the same address space. Things like the module graph don't change during a single compilation.Historical note: "hsc" used to be the name of the compiler binary, when there was a separate driver and compiler. To compile a single module, the driver would invoke hsc on the source code... so nowadays we think of hsc as the layer of the compiler that deals with compiling a single module.ghcThe dynamic flag settingsghc-The targets (or roots) of the current sessionghc'The module graph of the current sessionghc1The context for evaluating interactive statementsghcGlobal Name cache so that each Name gets a single Unique. Also track the origin of the Names.ghc:The cached result of performing finding in the file systemghc7Used for one-shot compilation only, to initialise the IfGblEnv. See  for (. See also Note [hsc_type_env_var hack]ghctarget code interpreter (if any) to use for TH and GHCi. See Note [Target code interpreter]ghcPluginsghc/Unit environment (unit state, home unit, etc.).)Initialized from the databases cached in  hsc_unit_dbs and from the DynFlags.ghcLogger with its flags.Don't forget to update the logger flags if the logging related DynFlags change. Or better, use hscSetFlags setter which does it.ghcHooksghcTemporary filesghcLLVM configuration cache.ghc:The Hsc monad: Passing an environment and diagnostic state Safe-InferredvʖghcSwitches in the DynFlags and Plugins from the InteractiveContext˖ghcA variant of runHsc that switches in the DynFlags and Plugins from the InteractiveContext before running the Hsc computation.֖ghc(Retrieve the ExternalPackageState cache.ؖghcFind all the instance declarations (of classes and families) from the Home Package Table filtered by the provided predicate function. Used in  tcRnImports, to select the instances that are in the transitive closure of imports from the currently compiled module.ٖghc4Find instances visible from the given set of importsږghcGet rules from modules "below" this one (in the dependency sense)ۖghcGet annotations from modules "below" this one (in the dependency sense)ghcThis function returns all the modules belonging to the home-unit that can be reached by following the given dependencies. Additionally, if both the boot module and the non-boot module can be reached, it only returns the non-boot one.ݖghcGet things from modules "below" this one (in the dependency sense) C.f Inst.hptInstancesޖghcDeal with gathering annotations in from all possible places and combining them into a single 9ߖghc Find the  for the given  by using all the resources at our disposal: the compiled modules in the : and the compiled modules in other packages that live in '. Note that this does NOT look up the  in the module being compiled: you have to do that yourself, if desiredghc Find the  for a  , searching in both the loaded home and external package module informationghc$Retrieve the target code interpreter0Fails if no target code interpreter is availableghcUpdate the LogFlags of the Log in hsc_logger from the DynFlags in hsc_dflags. You need to call this when DynFlags are modified.ghc Update Flagsghc Set FlagsghcDiscard the contents of the InteractiveContext, but keep the DynFlags and the loaded plugins. It will also keep ic_int_print and ic_monad if their names are from external packages.4̖͖ΖϖЖіҖՖӖԖȖɖʖ˖֖זٖؖۖܖݖږޖߖ4̖͖ΖϖЖіҖՖӖԖȖɖʖ˖֖זٖؖۖܖݖږޖߖ Safe-InferredSghcLocate a module that was imported by the user. We have the module's name, and possibly a package name. Without a package name, this function will use the search path and the known exposed packages to find the module, if a package is specified then only that package is searched for the module.ghcLocate a plugin module requested by the user, for a compiler plugin. This consults the same set of exposed packages as  , unless -hide-all-plugin-packages or -plugin-package are specified.ghcLocate a specific  0. The purpose of this function is to create a  for a given  , that is to find out where the files associated with this module live. It is used when reading the interface for a module mentioned by another interface, for example (a "system import").ghcGiven a monadic actions this and or_this, first execute this. If the returned }/ is successful, return it; otherwise, execute or_this. If both failed, this function also combines their failure messages in a reasonable way.ghcHelper function for 8: this function wraps an IO action which would look up mod_name in the file system (the home package), and first consults the  cache to see if the lookup has already been done. Otherwise, do the lookup (with the IO action) and save the result in the finder cache and the module location cache (if it was successful.)ghcImplements the search for a module name in the home package only. Calling this function directly is usually *not* what you want; currently, it's used as a building block for the following operations: When you do a normal package lookup, we first check if the module is available in the home module, before looking it up in the package database.When you have a package qualified import with package name "this", we shortcut to the home module.When we look up an exact  , if the unit id associated with the module is the current home module do a look up in the home module.Some special-case code in GHCi (ToDo: Figure out why that needs to call this.)ghc1Prepend the working directory to the search path.ghc.Search for a module in external packages only.ghc2Look up the interface file associated with module mod. This function requires a few invariants to be upheld: (1) the   in question must be the module identifier of the *original* implementation of a module, not a reexport (this invariant is upheld by GHC.Unit.State) and (2) the >, must be consistent with the unit id in the  . The redundancy is to avoid an extra lookup in the package state for the appropriate config.ghcConstructs the filename of a .o file for a given source file. Does not! check whether the .o file existsghcConstructs the filename of a .dyn_o file for a given source file. Does not% check whether the .dyn_o file existsghcConstructs the filename of a .hi file for a given source file. Does not" check whether the .hi file existsghcConstructs the filename of a .dyn_hi file for a given source file. Does not& check whether the .dyn_hi file existsghcConstructs the filename of a .hie file for a given source file. Does not# check whether the .hie file exists7}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}7}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-InferredghcSee Note [Initializers and finalizers in Cmm] in GHC.Cmm.InitFini for details.ghc(Generate code to initialise cost centresghcGenerate code to initialise info pointer origin See Note [Mapping Info Tables to Source Positions] ghc3additional files to be compiled with the C compiler ghc Dependencies Safe-Inferredghc.The profiling header words in a static closureghc+Profiling header words in a dynamic closureghc1Initialise the profiling field of an update frameghcRecord the allocation of a closure. The CmmExpr is the cost centre stack to which to attribute the allocation.ghcRecord the allocation of a closure (size is given by a CmmExpr) The size must be in words, because the allocation counter in a CCS counts in words.ghc; see Note [unpack_cstring closures] in StgStdThunks.cmm).The CAFLabel! is the label of the CAF closure.The  Set CAFLabel is the set of CAFfy closures which should be included in the closure's SRT.Note that CAFs are treated differently from other labelled blocks:we never shortcut a reference to a CAF to the contents of its SRT, since the point of SRTs is to keep CAFs alive.CAFs therefore don't take part in the dependency analysis in depAnalSRTs. instead we generate their SRTs after everything else.ghcGet the list of blocks that correspond to the entry points for  FUN_STATIC closures. These are the blocks for which if we have an SRT we can merge it with the static closure. [FUN]ghcGiven  of a module, returns the set of non-CAFFY names in the module. Any Names not in the set are CAFFY.ghcResolve a CAFfyLabel to its  using the .ghc&Attach SRTs to all info tables in the $s, and add SRT declarations to the .ghc;Build the SRT for a strongly-connected component of blocks.ghc Build an SRT for a set of blocksghcBuild a static SRT object (or a chain of objects) from a list of s.ghcUpdate info tables with references to their SRTs. Also generate static closures, splicing in SRT fields as necessary.ghcThe blocks representing continuations, ie. those that will get RET info tables. These labels will get their own SRTs, so we don't aggregate CAFs from references to these labels, we just use the label.ghcThe top label of the procghc for procedures. From .ghcCAFEnv for statics. Maps statics to the set of the CAFfy things which they refer to. From .ghcthe decls to analyse.ghcs and s for code blocksghcstatic data decls and their sghc-which blocks are static function entry pointsghc static dataghc-which blocks are static function entry pointsghcblocks in this setghclabels for those blocksghcTrue  = this SRT is for a CAFghcSRT for this setghcSRT labels for each blockghc&SRTs to merge into FUN_STATIC closuresghc.Whether the CmmDecl's group has CAF references Safe-InferredN ghcEmit code for a foreign call, and return the results to the sequel. Precondition: the length of the arguments list is the same as the arity of the foreign function.ghc1Produce code to save the current thread state to  CurrentTSOghcSave STG registersSTG registers must be saved around a C call, just in case the STG register is mapped to a caller-saves machine register. Normally we don't need to worry about this the code generator has already loaded any live STG registers into variables for us, but in hand-written low-level Cmm code where we don't know which registers are live, we might have to save them all.ghcRestore STG registers (see )ghcPush a subset of STG registers onto the stack, specified by the bitmapSometimes, a "live" subset of the STG registers needs to be saved on the stack, for example when storing an unboxed tuple to be used in the GHCi bytecode interpreter.The "live registers" bitmap corresponds to the list of registers given by , with the least significant bit indicating liveness of the first register in the list.Each register is saved to a stack slot of one or more machine words, even if the register size itself is smaller.The resulting Cmm code looks like this, with a line for each real or virtual register used for returning tuples:... if((mask & 2) != 0) { Sp_adj(-1); Sp(0) = R2; } if((mask & 1) != 0) { Sp_adj(-1); Sp(0) = R1; })See Note [GHCi and native call registers]ghc2Pop a subset of STG registers from the stack (see )ghccloseNursery dflags tso produces code to close the nursery. A local register holding the value of  CurrentTSO is expected for efficiency.6Closing the nursery corresponds to the following code:  tso = CurrentTSO; cn = CurrentNuresry; // Update the allocation limit for the current thread. We don't // check to see whether it has overflowed at this point, that check is // made when we run out of space in the current heap block (stg_gc_noregs) // and in the scheduler when context switching (schedulePostRunThread). tso->alloc_limit -= Hp + WDS(1) - cn->start; // Set cn->free to the next unoccupied word in the block cn->free = Hp + WDS(1); ghc3Produce code to load the current thread state from  CurrentTSOghcopenNursery profile tso produces code to open the nursery. A local register holding the value of  CurrentTSO is expected for efficiency.6Opening the nursery corresponds to the following code:  tso = CurrentTSO; cn = CurrentNursery; bdfree = CurrentNursery->free; bdstart = CurrentNursery->start; // We *add* the currently occupied portion of the nursery block to // the allocation limit, because we will subtract it again in // closeNursery. tso->alloc_limit += bdfree - bdstart; // Set Hp to the last occupied word of the heap block. Why not the // next unoccupied word? Doing it this way means that we get to use // an offset of zero more often, which might lead to slightly smaller // code on some architectures. Hp = bdfree - WDS(1); // Set HpLim to the end of the current nursery block (note that this block // might be a block group, consisting of several adjacent blocks. HpLim = bdstart + CurrentNursery->blocks*BLOCK_SIZE_W - 1;  Safe-Inferredi"ghcOut of line fake primop that's actually just a foreign call to other (presumably) C--.ghc#Real primop turned into inline C--.ghcInterpret the argument as an unsigned value, assuming the value is given in two-complement form in the given width. Example: asUnsigned W64 (-1) is 18446744073709551615.This function is used to work around the fact that many array primops take Int# arguments, but we interpret them as unsigned quantities in the code gen. This means that we have to be careful every time we work on e.g. a CmmInt literal that corresponds to the array size, as it might contain a negative Integer value if the user passed a value larger than 2^(wORD_SIZE_IN_BITS-1) as the Int# literal.ghc*The big function handling all the primops.In the simple case, there is just one implementation, and we emit that.In more complex cases, there is a foreign call (out of line) fallback. This might happen e.g. if there's enough static information, such as statically know arguments.ghc1Implements branchless recovery of the carry flag c/ by checking the leftmost bits of both inputs a and b and result  r = a + b:  c = a&b | (a|b)&~r  https://brodowsky.it-sky.net/2015/04/02/how-to-recover-the-carry-bit/ghc1Implements branchless recovery of the carry flag c/ by checking the leftmost bits of both inputs a and b and result  r = a - b:  c = ~a&b | (~a|b)&r  https://brodowsky.it-sky.net/2015/04/02/how-to-recover-the-carry-bit/ghc?Translate byte array prefetch operations into proper primcalls.ghcTranslate mutable byte array prefetch operations into proper primcalls.ghc, but check for range overlap when -fcheck-prim-bounds is on.ghcEmit a call to memmove.ghcEmit a call to memset9. The second argument must fit inside an unsigned char.ghcPush a range of pointer-array elements that are about to be copied over to the update remembered set.ghc The primopghcThe primop argumentsghc element typeghc index typeghcreturn registerghcrepresentation of the arrayghc info pointerghcheader payloadghc array sizeghcinitial elementghc copy functionghc source arrayghcoffset in source arrayghcdestination arrayghcoffset in destination arrayghcnumber of elements to copyghc copy functionghc source arrayghcoffset in source arrayghcdestination arrayghcoffset in destination arrayghcnumber of elements to copyghc Result regghcAtomic op (e.g. add)ghcMutableByteArray#ghcIndexghc(Type of element by which we are indexingghc Op argument (e.g. amount to add)ghc Result regghcAtomic op (e.g. add)ghcAddr#ghcPointed value typeghc Op argument (e.g. amount to add)ghc Result regghcMutableByteArray#ghcIndexghc(Type of element by which we are indexingghc Result regghcAddr#ghc(Type of element by which we are indexingghcMutableByteArray#ghcIndexghc(Type of element by which we are indexingghcValue to writeghcAddr#ghc(Type of element by which we are indexingghcValue to writeghc Result regghcMutableByteArray#ghcIndexghc(Type of element by which we are indexingghc Old valueghc New valueghcaccessed indexghcarray size (in elements)ghcfirst accessed indexghc%number of accessed indices (non-zero)ghcarray size (in elements)ghcaccessed index (in bytes)ghc pointer to  StgMutArrPtrsghcaccessed index (in bytes)ghc pointer to  StgMutArrPtrsghcaccessed index (in elements)ghc pointer to  StgArrBytesghc indexing typeghc element typeghcarray header size (in bytes)ghcdestination arrayghc&offset in destination array (in words)ghcnumber of elements to copy Safe-Inferred %&)*$# ghc>the offset of Sp relative to the base on entry to this block.ghcthe number of bytes of arguments in the area for this block Defn: the offset of young(L) relative to the base is given by (sm_sp - sm_args) of the StackMap for block L.ghcNumber of words of stack that we do not describe with an info table, because it contains an update frame.ghcregs on the stackghccreate a sequence of assignments to establish the new StackMap, given the old StackMap.ghcGiven a set of live registers and a StackMap, save all the registers on the stack and return the new StackMap and the assignments to do the saving.ghcManifest Sp: turn all the CmmStackSlots into CmmLoads from Sp. The block looks like this:middle_pre -- the middle nodes Sp = Sp + sp_off -- Sp adjustment goes here last -- the last nodeAnd we have some extra blocks too (that don't contain Sp adjustments)The adjustment for middle_pre will be different from that for middle_post, because the Sp adjustment intervenes.ghc,Determine whether a stack check cannot fail.ghcEliminate stores of the formSp[area+n] = rwhen we know that r is already in the same slot as Sp[area+n]. We could do this in a later optimisation pass, but that would involve a separate analysis and we already have the information to hand here. It helps clean up some extra stack stores in common cases.Note that we may have to modify the StackMap as we walk through the code using procMiddle, since an assignment to a variable in the StackMap will invalidate its mapping there. Safe-Inferred&ghc!Top level driver for C-- pipelineConverts C-- with an implicit stack and native C-- calls into optimized, CPS converted and native-call-less C--. The latter C-- can be used to generate assembly.ghcThe Cmm pipeline for a single  . Returns:in the case of a : M3 of the resulting (possibly proc-point-split)  s and their CafEnv. CAF analysis necessarily happens *before* proc-point splitting, as described in Note [SRTs].in the case of a , the unmodified  and a  containing Safe-Inferred %&9+ghcMaps Ids to their stack depth. This allows us to avoid having to mess with it after each push/pop.ghcsee Note [Generating code for top-level string literal bindings]ghcBuilds a bitmap for a stack layout with a nonpointer prefix followed by some number of arguments.ghcPush an atom for constructor (i.e., PACK instruction) onto the stack. This is slightly different to pushAtom due to the fact that we allow packing constructor fields. See also  mkConAppCode and  pushPadding.ghc/Indicate if the calling convention is supportedghcLet szsw be the sizes in bytes of some items pushed onto the stack, which has initial depth original_depth. Return the values which the stack environment should map these items to.ghc'original expression; for debugging onlyghcarityghc bitmap sizeghcbitmapghcTrue  =* is a return point, rather than a functionghc9The number of nonpointer words that prefix the arguments.ghcThe stack layout of the arguments, where each offset is relative to the bottom of the stack space they occupy. Their offsets must be word-aligned, and the list must be sorted in order of ascending offset (i.e. bottom to top).qq Safe-Inferred,Jghc Using Cabal? Safe-Inferred 95<ghc-A function called to log warnings and errors.ghcA monad transformer to add GHC specific features to another monad.Note that the wrapped monad must support IO and handling of exceptions.ghcThe Session is a handle to the complete state of a compilation session. A compilation session consists of a set of modules constituting the current program or library, the context for interactive evaluation, and various caches.ghcA minimal implementation of a . If you need a custom monad, e.g., to maintain additional state consider wrapping this monad or using .ghc:A monad that has all the features needed by GHC API calls.In short, a GHC monadallows embedding of IO actions,can log warnings,/allows handling of (extensible) exceptions, andmaintains a current session.If you do not use  or , make sure to call 5 before any call to the GHC API functions can occur.ghc+Call the argument with the current session.ghc#Grabs the DynFlags from the SessionghcSet the current session to the result of applying the current session to the argument.ghcSet the current session to the result of applying the current session to the argument.ghc3Call an action with a temporarily modified Session.ghcModify the loggerghcPush a log hook on the stackghcPop a log hook from the stackghcPut a log messageghcPut a log messageghcTime an actionghc+A monad that allows logging of diagnostics.ghcReflect a computation in the  monad into the D monad.>You can use this to call functions returning an action in the  monad inside an D action. This is needed for some (too restrictive) callback arguments of some library functions: libFunc :: String -> (Int -> IO a) -> IO a ghcFunc :: Int -> Ghc a ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a ghcFuncUsingLibFunc str = reifyGhc $ \s -> libFunc $ \i -> do reflectGhc (ghcFunc i) sghcPrint the all diagnostics in a '. Useful inside exception handlers. Safe-Inferred)*9ghcGiven: * an initial mapping from info tables to possible source locations, * initial  , * a ,#map every info table listed in the >s of the group to their possible source locations and update  for skipped stack info tables (in case both -finfo-table-map and -fno-info-table-map-with-stack were given). See: Note [Stacktraces from Info Table Provenance Entries (IPE based stack unwinding)]Note: While it would be cleaner if we could keep the recursion and accumulation internal to this function, this cannot be done without separately traversing stream of  in . The initial implementation of this logic did such a thing, and code generation performance suffered considerably as a result (see #23103).ghcSee Note [Stacktraces from Info Table Provenance Entries (IPE based stack unwinding)]ghcSee Note [Stacktraces from Info Table Provenance Entries (IPE based stack unwinding)] Safe-Inferred9B.ghcThe monad used by Core-to-Core passes to register simplification statistics. Also used to have common state (in the form of UniqueSupply) for generating Uniques.ghcJust n  = float lambdas to top level, if doing so will abstract over n or fewer value variables Nothing  = float all lambdas to top level, regardless of how many free variables Just 0 is the vanilla case: float a lambda iff it has no free varsghcTrue  = float constants to top level, even if they do not escape a lambdaghcTrue  = float out over-saturated applications based on arity information. See Note [Floating over-saturated applications] in GHC.Core.Opt.SetLevelsghc%Allow floating to the top level only.ghcLift an } operation into ghcLift an D operation into  while consuming its Qghc2Adjust the dyn flags passed to the argument actionghcDrop the single count of the argument action so it doesn't effect the total.ghcGet all annotations of a given type. This happens lazily, that is no deserialization will take place until the [a] is actually demanded and the [a] can also be empty (the UniqFM is not filtered).This should be done once at the start of a Core-to-Core pass that uses annotations.See Note [Annotations]ghcGet at most one annotation of a given type per annotatable item.ghc%Output a String message to the screenghcOutput a message to the screenghcOutput an error to the screen. Does not cause the compiler to die.ghcOutput a fatal error to the screen. Does not cause the compiler to die.ghcOutput a fatal error to the screen. Does not cause the compiler to die.ghc8Output a string debugging message at verbosity level of -v or higherghc2Outputs a debugging message at verbosity level of -v or higherghcddump-simpl-statsghcMask!t!t Safe-InferredO7ghcA  is a binding along with a cached set containing its free variables (both type variables and dictionaries). We need this set in splitDictBinds, when filtering bindings to decide which are captured by a binderghcThe binders of . Caches a superset of the expression `mkVarSet (bindersOfDictBinds fdb_binds))` for later addition to an InScopeSetghcAn argument that we might want to specialise. See Note [Specialising Calls] for the nitty gritty details.ghcType arguments that should be specialised, due to appearing free in the type of a .ghc.Type arguments that should remain polymorphic.ghcDictionaries that should be specialised. mkCallUDs ensures that only "interesting" dictionary arguments get a SpecDict; see Note [Interesting dictionary arguments]ghc/Value arguments that should not be specialised.ghcSpecialise calls to type-class overloaded functions occurring in a program.ghc.Specialise a set of calls to imported bindingsghcReturns whether or not to show a missed-spec warning. If -Wall-missed-specializations is on, show the warning. Otherwise, if -Wmissed-specializations is on, only show a warning if there is at least one imported function being specialized, and if all imported functions are marked with an inline pragma Use the most specific warning as the reason.ghc(Given binders from an original function f , and the s corresponding to its usage, compute everything necessary to build a specialisation.?We will use the running example from Note [Specialising Calls]:=f :: forall a b c. Int -> Eq a => Show b => c -> Blah f a b @c i dEqA dShowB x = blah c -> Blah $sf = SUBST[a :-> T1, b :-> T2, dEqA :-> dEqT1, dShowB :-> dShow1] (@c i x -> blah)?where dShow1 is a floated binding created by bindAuxiliaryDict.The cases for  below are presented in the same order as this running example. The result of  for this example is as follows:( -- Returned arguments env + [a :-> T1, b :-> T2, dEqA :-> dEqT1, dShowB :-> dShow1] , [x]- RULE helpers , [c, i, d1, d2] , [T1, T2, c, i, d1, d2]- Specialised function helpers , [c, i, x] , [dShow1 = $dfShow dShowT2] , [T1, T2, c, i, dEqT1, dShow1] )ghcBinds a dictionary argument to a fresh name, to preserve sharingghc Construct a  from a \ghc!Identify the free variables of a \ghcFlatten a set of "dumped" s, and some other binding pairs, into a single recursive binding.ll  Safe-InferredR ghc3Options for Specializing over constructors in Core.ghcThe threshold at which a worker-wrapper transformation used as part of this pass will no longer happen, measured in the number of arguments.ghc"Whether to print debug informationghcUnfolding optionsghc&The name of the module being processedghc#Size threshold: Nothing => no limitghcMax # of specialisations for any one function. Nothing => no limit. See Note [Avoiding exponential blowup] and decreaseSpecCountghcMax # of specialisations over recursive type. Stops ForceSpecConstr from diverging.ghcSpecialise on arguments that are known constructors, even if they are not scrutinised in the body. See Note [Making SpecConstr keener].ghc9Does this occurence represent one worth specializing for.ghcwildCardPats are always boring Safe-InferredSnghc5Clone the binders bound by a single-alternative case. Safe-InferredT/ Safe-Inferred '7<>TU   Safe-Inferred%&VghcProduce a fingerprint of a DynFlags> value. We only base the finger print on important fields in DynFlags= so that the recompilation checker can use this fingerprint.NB: The   parameter is the  3 recorded by the *interface* file, not the actual   according to our t. Safe-Inferred aghcDiagnostics optsghcTarget platformghcLinting the result of this passghc*s that should be treated as being in scopeghcAllow  makeStatic to occur anywhere.ghcAllow  makeStatic calls at the top-level only.ghc Reject any  makeStatic occurrence.ghcSee Note [Checking StaticPtrs]ghc,See Note [Linting type synonym applications]ghcSee Note [Linting linearity]ghcTarget platformghcTarget platformghcConfiguration for boilerplate operations at the end of a compilation pass producing Core.ghcWhether core bindings should be dumped with the size of what they are binding (i.e. the size of the RHS of the binding).ghc/Whether we should lint the result of this pass.ghc Type-check a \!. See Note [Core Lint guarantee].ghc1Checks the RHS of bindings. It only differs from 8 in that it doesn't reject occurrences of the function  makeStatic( when they appear at the top level and 'lf_check_static_ptrs == AllowAtTopLevel, and for join points, it skips the outer lambdas that take arguments to the join point.See Note [Checking StaticPtrs].ghc9Lint the RHS of a join point with expected join arity of n (see Note [Join points] in GHC.Core).ghcLint an expression cast through the given coercion, returning the type resulting from the cast.ghcThis function checks that we are able to perform eta expansion for functions with no binding, in order to satisfy invariant I3 from Note [Representation polymorphism invariants] in GHC.Core.ghc'Implements the case rules for linearityghclintValApp arg fun_ty arg_ty lints an application of fun arg where  fun :: fun_ty and  arg :: arg_ty), returning the type of the application.ghcThis checks whether a pass correctly looks through debug annotations ( SourceNote). This works a bit different from other consistency checks: We check this by running the given task twice, noting all differences between the results.ghcRun the given pass without annotations. This means that we both set the debugLevel setting to 0 in the environment as well as all annotations from incoming modules.ghcIf L!, display linter warnings. If I, ignore linter warnings.ghc The source of the linted programghc"The linted program, pretty-printedghcTrue  = is a compulsory unfoldingghc6the function (head of the application) we are checkingghc the arguments to the applicationghc0the instantiated type of the overall applicationghcThe source of the linted axiomsghc Action to runghc>What sort of casted thing this is ("expression" or "type").ghc:What sort of coercion is being used ("type" or "kind").ghcThe thing being casted.,, Safe-Inferredc+   Safe-Inferredhǚghc Stop[e] = eghcDescribes how the ƚ will evaluate the hole as a Z. This can be more insightful than the limited syntactic context that ƚ provides, because the ǚ# constructor might carry a useful Z.. For example, when simplifying the argument e in `f e` and f has the demand signature ` MP(S,A)?`, this function will give you back `P(S,A)` when simplifying e.PRECONDITION: Don't call with ɚ. We haven't thoroughly thought about what to do then and no call sites so far seem to care.ǚghc Type of the holeghcTells if there is something interesting about the syntactic context, and hence the inliner should be a bit keener (see interestingCallContext) Specifically: This is an argument of a function that has RULES Inlining the call might allow the rule to fire Never ValAppCxt (use ApplyToVal instead) or CaseCtxt (use Select instead)ghcThe evaluation context of e. Tells how e is evaluated. This fuels eta-expansion or eta-reduction without looking at lambda bodies, for example.See Note [Eta reduction based on evaluation context] The evaluation context for other SimplConts can be reconstructed with ۚܚݚޚƚ˚ǚȚɚʚ͚̚ΚϚКњҚӚԚ՚֚ךؚٚښšÚĚŚߚۚܚݚޚƚ˚ǚȚɚʚ͚̚ΚϚКњҚӚԚ՚֚ךؚٚښšÚĚŚߚ Safe-Inferred kghcPush a TickIt context outwards past applications and cases, as long as this is a non-scoping tick, to let case and application optimisations apply.ghc.A "friendly name" to build the new binder from Safe-InferredmghcConfiguration record for ˛#. The values of this datatype are only( driven by the demands of that function.śghcConfiguration record for ʛ#. The values of this datatype are only( driven by the demands of that function.śƛǛțɛ›Ûěʛ˛śƛǛțɛ›Ûěʛ˛ Safe-Inferredm͛ghcThe core-to-core simplifier.ghc'A description of the plugin pass itself̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛ̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛ Safe-Inferredoghc Type-check a \!. See Note [Core Lint guarantee]. Safe-Inferred )*yghc?A typecheckable thing available in a local context. Could be  1, but also lexically scoped variables, etc. See GHC.Tc.Utils.Env for how to retrieve a  given a .ghcThe current collection of docs that Template Haskell has built up via putDoc.ghcThis is a mirror of Template Haskell's DocLoc, but the TH names are resolved to GHC names.ghc$A plugin for controlling defaulting.ghc.Initialize plugin, when entering type-checker.ghcDefault some typesghc9Clean up after the plugin, when exiting the type-checker.ghc pure $ TcPluginOK [] [] 5 if your plugin does not provide this functionality.ghc+Rewrite saturated type family applications.The plugin is expected to supply a mapping from type family names to rewriting functions. For each type family , the plugin should provide a function which takes in the given constraints and arguments of a saturated type family application, and return a possible rewriting. See + for the expected shape of such a function.Use  \ _ -> emptyUFM 4 if your plugin does not provide this functionality.ghc9Clean up after the plugin, when exiting the type-checker.ghc5 is the monad in which type-checking plugins operate.ghcFor rewriting type family applications, a type-checking plugin provides a function of this type for each type family .The function is provided with the current set of Given constraints, together with the arguments to the type family. The type family application will always be fully saturated.ghcThe solve function of a type-checking plugin takes in Given and Wanted constraints, and should return a  indicating which Wanted constraints it could solve, or whether any are insoluble.ghc>IsGroupClosed describes a group of mutually-recursive bindingsghc+IdBindingInfo describes how an Id is bound.?It is used for the following purposes: a) for static forms in  and b) to figure out when a nested binding can be generalised, in .ܜghcType alias for ; the convention is we'll use this for mutable bits of data in  which are updated during typechecking and returned at the end.ghc describes the top-level of the module at the point at which the typechecker is finished work. It is this structure that is handed on to the desugarer For state that needs to be updated during the typechecking phase and returned at end, use a ܜ (= ).ghcModule being compiledghcIf a signature, the backing module See also Note [Identity versus semantic module]ghc4What kind of module (regular Haskell, hs-boot, hsig)ghc$Top level envt; used during renamingghcTypes used for defaulting. Nothing => no default declghcJust for things in this moduleghcJust for things in this module See Note [The interactive package] in GHC.Runtime.ContextghcGlobal type env for the module we are compiling now. All TyCons and Classes (for this module) end up in here right away, along with their derived constructors, selectors.(Ids defined in this module start in the local envt, though they move to the global envt during zonking)NB: for what "things in this module" means, see Note [The interactive package] in GHC.Runtime.ContextghcInstance envt for all  home-package modules; Includes the dfuns in tcg_insts NB. BangPattern is to fix a leak, see #15111ghcDitto for family instances NB. BangPattern is to fix a leak, see #15111ghcAnd for annotationsghcWhat is exportedghcInformation about what was imported from where, including things bound in this module. Also store Safe Haskell info here about transitive trusted package requirements.There are not many uses of this field, so you can grep for all them.The ImportAvails records information about the following things: 6All of the modules you directly imported (tcRnImports)The orphans (only!) of all imported modules in a GHCi session (runTcInteractive)(The module that instantiated a signature%Each of the signatures that merged inIt is used in the following ways: - imp_orphs is used to determine what orphan modules should be visible in the context (tcVisibleOrphanMods) - imp_finsts is used to determine what family instances should be visible (tcExtendLocalFamInstEnv) - To resolve the meaning of the export list of a module (tcRnExports) - imp_mods is used to compute usage info (mkIfaceTc, deSugar) - imp_trust_own_pkg is used for Safe Haskell in interfaces (mkIfaceTc, as well as in GHC.Driver.Main) - To create the Dependencies field in interface (mkDependencies)ghcTrue" <=> Template Haskell syntax used.We need this so that we can generate a dependency on the Template Haskell package, because the desugarer is going to emit loads of references to TH symbols. The reference is implicit rather than explicit, so we have to zap a mutable variable.ghcTrue( <=> A Template Haskell splice was used.2Splices disable recompilation avoidance (see #481)ghcThe set of runtime dependencies required by this module See Note [Object File Dependencies]ghc&Allows us to choose unique DFun names.ghcThe requirements we merged with; we always have to recompile if any of these changed.ghcRenamed decls, maybe. Nothing! <=> Don't retain renamed decls.ghc"dependencies from addDependentFileghc'Top-level declarations from addTopDeclsghcForeign files emitted from TH.ghc>Exact names bound in top-level declarations in tcg_th_topdeclsghc#Template Haskell module finalizers.+They can use particular local environments.ghc,Core plugins added by Template Haskell code.ghcTemplate Haskell stateghc#Docs added in Template Haskell via putDoc.ghcMaybe Haddock header docsghcTrue if any part of the prog uses hpc instrumentation. NB. BangPattern is to fix a leak, see #15111ghc5Whether this module has a corresponding hi-boot fileghcThe Name of the main function, if this module is the main module.ghcHas the typechecker inferred this module as -XSafe (Safe Haskell)? See Note [Safe Haskell Overlapping Instances Implementation], although this is used for more than just that failure case.ghcUnreported reasons why tcg_safe_infer is False. INVARIANT: If this Messages is non-empty, then tcg_safe_infer is False. It may be that tcg_safe_infer is False but this is empty, if no reasons are supplied (#19714), or if those reasons have already been reported by GHC.Driver.Main.markUnsafeInferghcA list of user-defined type-checking plugins for constraint solving.ghcA collection of all the user-defined type-checking plugins for rewriting type family applications, collated by their type family s.ghc;A list of user-defined plugins for type defaulting plugins.ghc8A list of user-defined plugins for hole fit suggestions.ghc%The RealSrcSpan this module came fromghcWanted constraints of static forms. See Note [Constraints in static forms].ghc,Tracking indices for cost centre annotationsghc2See Note [Generating fresh names for FFI wrappers]ghc describes the result of running the frontend of a Haskell module. Currently one always gets a , since running the frontend involves typechecking a program. hs-sig merges are not handled here.This data type really should be in GHC.Driver.Env, but it needs to have a TcGblEnv which is only defined here.ÝghcA Ý carries the necessary context for performing rewrites (i.e. type family reductions and following filled-in metavariables) in the solver.ŝghc"In which context are we rewriting?Type-checking plugins might want to use this location information when emitting new Wanted constraints when rewriting type family applications. This ensures that such Wanted constraints will, when unsolved, give rise to error messages with the correct source location.ǝghcAt what role are we rewriting?3See Note [Rewriter EqRels] in GHC.Tc.Solver.Rewriteȝghc"See Note [Wanteds rewrite Wanteds]ϝghc0Historical "type-checking monad" (now it's just ԝ).Нghc+Historical "renaming monad" (now it's just ԝ).֝ghcA ֝ is a substitution on s that can be used to refine the identities of a hole while we are renaming interfaces (see GHC.Iface.Rename). Specifically, a ֝ for ns_module_name A, defines a mapping from {A.T} (for some   T) to some arbitrary other ."The most intriguing thing about a ֝(, however, is how it's constructed. A ֝ is *implied* by the exported *s of the implementor of an interface: if an implementor of signature  exports M.T-, you implicitly define a substitution from {H.T} to M.T. So a ֝ is computed from the list of *s that are exported by the implementation of a module, or successively merged together by the export lists of signatures which are joining together.It's not the most obvious way to go about doing this, but it does seem to work!NB: Can't boot this and put it in NameShape because then we start pulling in too many DynFlags things.۝ghc,The plugin has not found any contradictions,The first field is for constraints that were solved. The second field contains new work, that should be processed by the constraint solver.ܝghcThe plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.7The returned list of constraints should never be empty.ghcGet target platformghcMatches on either a global  or a w.ghcUnion two ImportAvailsThis function is a key part of Import handling, basically for each import we create a separate ImportAvails structure and then union them all together with this function.ghc#No signature or a partial signatureghc;This function provides an escape for direct access to the ϝ: monad. It should not be used lightly, and the provided  API should be favoured instead.ghc Check the  for consistency. Currently, only checks axioms, but should check other aspects, too.ghcRewriter environmentghcGivensghctype family argumentsghcGivensghcWanteds՝ԝϝНӝѝҝܜɝʝ˝̝͝ΝyyyyyyݝÝĝŝƝǝȝߜߝ|||||||||||ޜٜ՜֜ל؜yœÜĜyޝؔה^^͜ΜϜМќҜӜԜɜʜ˜̜ȜݜŜǜƜyۜڜ֝ם؝ٝڝܝ۝՝ԝϝНӝѝҝܜɝʝ˝̝͝ΝyyyyyyݝÝĝŝƝǝȝߜߝ|||||||||||ޜٜ՜֜ל؜yœÜĜyޝؔה^^͜ΜϜМќҜӜԜɜʜ˜̜ȜݜŜǜƜyۜڜ֝ם؝ٝڝܝ۝ܝ۝ Safe-Inferred %&+ghc*Setup the initial typechecking environmentghcRun a ϝ& action in the context of an existing GblEnv.ghcDo it flag is trueghcUpdate the external package state. Returns the second result of the modifier function.This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.ghc"Update the external package state.This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.ghc"A convenient wrapper for taking a MaybeErr SDoc a. and throwing an exception if it is an error.ghc3Trace when a certain flag is enabled. This is like  but accepts a string as a label and formats the trace message uniformly.ghcDump if the given  is set.ghc&Unconditionally dump some trace outputCertain tests (T3017, Roles3, T12763 etc.) expect part of the output generated by `-ddump-types` to be in   style. However, generally we want all other debugging output to use   style. We   style if  useUserStyle is True.ghcAdd current location if -dppr-debug (otherwise the full location is usually way too much)ghc*Like logInfoTcRn, but for user consumptionghcAdd a fixed message to the error context. This message should not do any tidying.ghcAdd a message to the error context. This message may do tidying.ghcAdd a fixed landmark message to the error context. A landmark message is always sure to be reported, even if there is a lot of context. It also doesn't count toward the maximum number of contexts reported.ghc Variant of 1 that allows for monadic operations and tidying.ghctcCollectingUsage thing_inside runs  thing_inside and returns the usage information which was collected as part of the execution of  thing_inside . Careful: tcCollectingUsage thing_inside itself does not report any usage information, it's up to the caller to incorporate the returned usage information into the larger context appropriately.ghc tcScalingUsage mult thing_inside runs  thing_inside* and scales all the usage information by mult.ghcDrop elements of the input that fail, so the result list can be shorter than the argument listghcApply the function to all elements on the input list If all succeed, return the list of results Otherwise fail, propagating all errorsghc2The accumulator is not updated if the action failsghc(Display a warning if a condition is met.ghc(Display a warning if a condition is met.ghc+Display a diagnostic if a condition is met.ghc,Display a diagnostic in the current context.ghc(Display a diagnostic in a given context.ghcA variation of $ that takes a function to produce a  TcRnDsMessage5 given some additional context about the diagnostic.ghcDisplay a diagnostic for the current source location, taken from the ԝ monad.ghc1Display a diagnostic for a given source location.ghcDisplay a diagnostic, with an optional flag, for the current source location.ghcCreates an EvBindsVar incapable of holding any bindings. It still tracks covar usages (see comments on ebv_tcvs in GHC.Tc.Types.Evidence!), thus must be made monadicallyghc5Throw out any constraints emitted by the thing_insideghcThe name says it all. The returned TcLevel is the *inner* TcLevel.ghcAdds the given modFinalizers to the global environment and set them to use the current local environment.ghcMark that safe inference has failed See Note [Safe Haskell Overlapping Instances Implementation] although this is used for more than just that failure case.ghc.Figure out the final correct safe haskell modeghc9Switch instances to safe instances if we're in Safe mode.ghcRun an ҝ= (top-level interface monad) computation inside an existing ԝ; (typecheck-renaming monad) computation by initializing an  based on .ghc? can be used when there's no chance that the action will call typecheckIface% when inside a module loop and hence  tcIfaceGlobal.ghc'This is used when we are doing to call typecheckModule on an ModIface, if it's part of a loop with some other modules then we need to use their IORef TypeEnv vars when typechecking but crucially not our own.ghc.Initialize interface typechecking, but with a ֝' to apply when typechecking top-level  s (see lookupIfaceTop)ghcRun thing_inside in an interleaved thread. It shares everything with the parent thread, so this is DANGEROUS.+It throws an error if the computation failsIt's used for lazily type-checking interface signatures, which is pretty benign.&See Note [Masking exceptions in forkM]ghc]:B. We need a *specific* ModIface, e.g. p[A=q():A]:B (or maybe even p[A=]:B) which we load up (either to merge it, or to just use during typechecking).Suppose we have:p[A=]:M ==> p[A=q():A]:MSubstitute all occurrences of with q():A (renameHoleModule). Then, for any Name of form {A.T}, replace the Name with the Name according to the exports of the implementing module. This works even for p[A=]:M, since we just read in the exports of B.hi, which is assumed to be ready now. This function takes an optional ֝, which can be used to further refine the identities in this interface: suppose we read a declaration for {H.T} but we actually know that this should be Foo.T; then we'll also rename this (this is used when loading an interface to merge it into a requirement.)ghcRename just the exports of a ?. Useful when we're doing shaping prior to signature merging.ghcRun a computation in the  monad.ghcThe key function. This gets called on every Name embedded inside a ModIface. Our job is to take a Name from some generalized unit ID p[A=, B=], and change it to the correct name for a (partially) instantiated unit ID, e.g. p[A=q[]:A, B=].%There are two important things to do:If a hole is substituted with a real module implementation, we need to look at that actual implementation to determine what the true identity of this name should be. We'll do this by loading that module's interface and looking at the mi_exports.However, there is one special exception: when we are loading the interface of a requirement. In this case, we may not have the "implementing" interface, because we are reading this interface precisely to "merge it in".External case: p[A=]:A (and thisUnitId is something else) We are loading this in order to determine B.hi! So don't load B.hi to find the exports.Local case: p[A=]:A (and thisUnitId is p[A=]) This should not happen, because the rename is not necessary in this case, but if it does we shouldn't load A.hi!Compare me with  tcIfaceGlobal!ghcRename an implicit name, e.g., a DFun or coercion axiom. Here is where we ensure that DFuns have the correct module as described in Note [rnIfaceNeverExported].ghc Rename an o?, with special handling for an associated dictionary function. Safe-Inferred ;ghc Given a type ty :: ki, this function ensures that ty has a fixed  RuntimeRep), by emitting a new equality constraint ki ~ concrete_tv for a concrete metavariable  concrete_tv.Returns a coercion co :: ty ~# concrete_ty as evidence. If ty obviously has a fixed  RuntimeRep, e.g  ki = IntRep*, then this function immediately returns B$, without emitting any constraints.ghcLike *, but we perform an eager syntactic check.Throws an error in the ϝ monad if the check fails.This is useful if we are not actually going to use the coercion returned from ; it would generally be unsound to allow a non-reflexive coercion but not actually make use of it in a cast.The goal is to eliminate all uses of this function and replace them with , making use of the returned coercion. This is what is meant by going from PHASE 1 to PHASE 2, in Note [The Concrete mechanism].ghc>Internal function to check whether the given type has a fixed  RuntimeRep.Use  to allow rewriting, or  to perform a syntactic check.ghcEnsure that the given type ty can unify with a concrete type, in the sense of Note [Concrete types].Returns a coercion co :: ty ~# conc_ty, where conc_ty is concrete.If the type is already syntactically concrete, this immediately returns a reflexive coercion. Otherwise, it creates a new concrete metavariable  concrete_tv# and emits an equality constraint ty ~# concrete_tv*, to be handled by the constraint solver.:Invariant: the kind of the supplied type must be concrete.We assume the provided type is already at the kind-level (this only matters for error messages).ghc'Ensure that the given type is concrete.This is an eager syntactic check, and never defers any work to the constraint solver.Invariant: the kind of the supplied type must be concrete. Invariant: the output type is equal to the input type, up to zonking.We assume the provided type is already at the kind-level (this only matters for error messages).ghcTry to turn the provided type into a concrete type, by ensuring unfilled metavariables are appropriately marked as concrete.Returns a zonked type which is "as concrete as possible", and a list of problems encountered when trying to make it concrete.INVARIANT: the returned type is equal to the input type, up to zonking. INVARIANT: if this function returns an empty list of NotConcreteReasons, then the returned type is concrete, in the sense of Note [Concrete types].ghcContext to be reported to the user if the type ends up not having a fixed  RuntimeRep.ghc-The type to check (we only look at its kind).ghc (co, ty') where  ty' :: ki', ki is concrete, and co :: ty ~# ty' . That is, ty' has a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep].ghcContext to be reported to the user if the type does not have a syntactically fixed  RuntimeRep.ghc-The type to check (we only look at its kind).ghc!The check to perform on the kind.ghc#The context which required a fixed  RuntimeRep1, e.g. an application, a lambda abstraction, ...ghc The type ty4 to check (the check itself only looks at its kind).ghcReturns  (co, frr_ty) with co :: ty ~# frr_ty and frr_ty has a fixed  RuntimeRep. Safe-Inferred   Safe-Inferred*yghcHoleFit is the type we use for valid hole fits. It contains the element that was checked, the Id of that element as found by tcLookup, and the refinement level of the fit, which is the number of extra argument holes that this fit uses (e.g. if hfRefLvl is 2, the fit is for `Id _ _`).yghcA fit that is just displayed as is. Here so thatHoleFitPlugins can inject any fit they want.yghcThe elements id in the TcMyghcThe candidate that was checked.yghc$The type of the id, possibly zonked.yghc The number of holes in this fit.yghcThe wrapper for the match.yghc;What the refinement variables got matched with, if anythingyghc,Documentation of this HoleFit, if available.yghc7A HoleFitPlugin is a pair of candidate and fit plugins.yghcHoleFitCandidates are passed to hole fit plugins and then checked whether they fit a given typed-hole.ghcHoleFitPluginR adds a TcRef to hole fit plugins so that plugins can track internal state. Note the existential quantification, ensuring that the state cannot be modified from outside the plugin.ghc0Initializes the TcRef to be passed to the pluginghc'The function defining the plugin itselfghc7Cleanup of state, guaranteed to be called even on errorghc=A plugin for modifying hole fits *after* they've been found.ghcA plugin for modifying the candidate hole fits *before* they're checked.ghcAny relevant Cts to the holeghcThe nested implications of the hole with the innermost implication first.ghcThe hole itself, if available. yyyyyyyyyyyyyyy yyyyyyyyyyyyyyy Safe-Inferred ( [ghcExtract docs from renamer output. This is monadic since we need to be able to read documentation added from Template Haskell's putDoc, which is stored in .ghcIf we have an explicit export list, we extract the documentation structure from that. Otherwise we use the renamed exports and declarations.ghcFigure out the documentation structure by correlating the module exports with the located declarations.ghcExtract named documentation chunks from the renamed declarations.If there is no explicit export list, we simply return an empty map since there would be no way to link to a named chunk.ghcCreate decl and arg doc-maps by looping through the declarations. For each declaration, find its names, its subordinates, and its doc strings.ghcThe "OccEnv Name" is the default method environment for this module Ultimately, the a special "defaultMethodOcc" name is used for the signatures on bindings for default methods. Unfortunately, this name isn't generated until typechecking, so it is not in the renamed AST. We have to look it up from the $ parameter constructed from the typechecked AST. See also Note [default method Name] in GHC.Iface.RecompghcGet all subordinate declarations inside a declaration, and their docs. A subordinate declaration is something like the associate type or data family of a type class.ghcExtract constructor argument docs from inside constructor decls.ghcAll the sub declarations of a class (that we handle), ordered by source location, with documentation attached if it exists.ghc;Extract function argument docs from inside top-level decls.ghc1Extract function argument docs from inside types.ghc1Extract function argument docs from inside types.ghcThe top-level declarations of a module that we care about, ordered by source location, with documentation attached if it exists.ghcTake all declarations except pragmas, infix decls, rules from an W.ghc7Collect docs and attach them to the right declarations.;A declaration may have multiple doc strings attached to it.This is an example.ghc7Filter out declarations that we don't handle in HaddockghcGo through all class declarations and filter their sub-declarationsghc%Was this signature given by the user?ghcTake a field of declarations from a data structure and create HsDecls using the given constructorghcExtracts out individual maps of documentation added via Template Haskell's putDoc.ghcUnions together two  ArgDocMaps (or ArgMaps in haddock-api), such that two maps with values for the same key merge the inner map as well. Left biased so unionArgMaps a b prefers a over b.ghc  Module headerDocs on top level declarationsDocs on argumentsghcThe current moduleghcImportsghcExplicit export listghc All exportsghcDefault MethodsghcThe current moduleghcExplicit export listghcThe default method environmentghcAll exports, unorderedghc#Do we have an explicit export list?ghcDefault method environment for this module. See Note [default method Name] in GHC.Iface.RecompghcThe default method environment Safe-Inferred 1%GghcG is the compiler plugin data type. Try to avoid constructing one of these directly, and just modify some fields of ޞ instead: this is to try and preserve source-code compatibility when we add fields to this.Nonetheless, this API is preliminary and highly likely to change in the future.ghcA static plugin with its arguments. For registering compiled-in plugins through the GHC API.ghc>A plugin with its arguments. The result of loading the plugin.ghcStatic plugins which do not need dynamic loading. These plugins are intended to be added by GHC API users directly to this list.;To add dynamically loaded plugins through the GHC API see addPluginModuleName instead.ghcExternal plugins loaded directly from libraries without loading module interfaces.ghcPlugins dynamically loaded after processing arguments. What will be loaded here is directed by DynFlags.pluginModNames. Arguments are loaded from DynFlags.pluginModNameOpts.The purpose of this field is to cache the plugins so they don't have to be loaded each time they are needed. See .ghcThe object files required by the loaded plugins See Note [Plugin dependencies]ghc9the actual plugin together with its commandline argumentsghcExternal plugin loaded directly from a library without loading module interfacesghcPlugin with its argumentsghcUnitIdghc Module nameghc9the actual plugin together with its commandline argumentsghc the module containing the pluginžghcthe actual callable pluginÞghc%command line arguments for the pluginŞghcModify the Core pipeline that will be used for compilation. This is called as the Core pipeline is built for every module being compiled, and plugins get the opportunity to modify the pipeline in a nondeterministic order.ƞghcAn optional typechecker plugin, which may modify the behaviour of the constraint solver.ǞghcAn optional defaulting plugin, which may specify the additional type-defaulting rules.ȞghcAn optional plugin to handle hole fits, which may re-order or change the list of valid hole fits and refinement hole fits.ɞ ghcAn optional plugin to update , right after plugin loading. This can be used to register hooks or tweak any field of DynFlags' before doing actual work on a module.ʞghc3Specify how the plugin should affect recompilation.˞ghc8Modify the module when it is parsed. This is called by GHC.Driver.Main when the parser has produced no or only non-fatal errors. Compilation will fail if the messages produced by this function contain any errors.̞ghcModify each group after it is renamed. This is called after each W has been renamed.͞ghcModify the module when it is type checked. This is called at the very end of typechecking.Ξghc4Modify the TH splice or quasiqoute before it is run.Ϟghc>Modify an interface that have been loaded. This is called by GHC.Iface.Load when an interface is successfully loaded. Not applied to the loading of the plugin interface. Tools that rely on information from modules other than the currently compiled one should implement this function.Оghc2Result of running the parser and the parser pluginҞghc/Parsed module, potentially modified by a pluginӞghcWarnings and errors from parser, potentially modified by a pluginԞghc*Errors and warnings produced by the parser؞ghcCommand line options gathered from the -PModule.Name:stuff syntax are given to you as this typeޞghcDefault plugin: does nothing at all, except for marking that safe inference has failed unless -fplugin-trustworthy is passed. For compatibility reason you should base all your plugin definitions on this default value.ߞghcA renamer plugin which mades the renamed source available in a typechecker plugin.ghc9Perform an operation by using all of the plugins in turn.ghcPerform a constant operation by using all of the plugins in turn.ghcLoad external pluginsGĞŞƞǞȞɞʞ˞̞͞ΞϞޞ؞Ԟ՞֞מОўҞӞ۞ܞݞHߞžÞڞٞGĞŞƞǞȞɞʞ˞̞͞ΞϞޞ؞Ԟ՞֞מОўҞӞ۞ܞݞHߞžÞڞٞ Safe-Inferred )*3ghc8A wrapper around the interpretation function for phases.0 Safe-Inferred 5ghcHooks can be used by GHC API clients to replace parts of the compiler pipeline. If a hook is not installed, GHC uses the default built-in behaviourghcActual type: Maybe ([LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList (Id, CoreExpr))) Safe-Inferred 8rghcDesugaring monad. See also TcM.ghc>Local state of the desugarer, extended as we lexically descendghcTemplate Haskell bindingsghc%To put in pattern-matching error msgsghc(See Note [Long-distance information] in GHC.HsToCore.Pmc. The set of reaching values Nablas is augmented as we walk inwards, refined through each pattern match in turnghcGlobal read-only context and state of the desugarer. The statefulness is implemented through s.ghc2See Note [Generating fresh names for FFI wrappers]^^ Safe-Inferred9$ Safe-Inferred9ghc#The source of the linted expression Safe-Inferred9ʛʛ Safe-Inferred<ghcThis list is used to ensure that when you say "Prelude.map" in your source code, or in an interface file, you get a Name with the correct known key (See Note [Known-key names] in GHC.Builtin.Names)ghc.Check the known-key names list of consistency.ghcGiven a  lookup its associated ) if it corresponds to a known-key thing.ghcIs a  known-key?ghcMaps s to known-key names. The type is UniqFM Name Name to denote that the s used in the domain are s associated with *s (as opposed to some other namespace of s).ghcGiven a  lookup any associated arbitrary SDoc's to be displayed by GHCi's ':info' command. zz zz Safe-Inferred=s Safe-Inferred >{ghcGenerate Cmm code for a tick. Depending on the type of Tickish, this will either generate actual Cmm instrumentation code, or simply pass on the annotation as a  CmmTickish. Safe-Inferred> Safe-Inferred ?ghcGenerate a source note spanning from "a" to "b" (inclusive), then proceed with parsing. This allows debugging tools to reason about locations in Cmm code.ghcaddressghcvalue9 9  Safe-Inferred1@D Safe-Inferred"79:;T63ghc's get converted into 's before being written into .hie files. See  and  fromHieName6 for logic on how to convert between these two types.ghcScope of a type variable.%This warrants a data type apart from 6 because of complexities introduced by features like -XScopedTypeVariables and -XInstanceSigs. For example, consider: "foo, bar, baz :: forall a. a -> a Here a' is in scope in all the definitions of foo, bar, and baz, so we need a list of scopes to keep track of this. Furthermore, this list cannot be computed until we resolve the binding sites of foo, bar, and baz.Consequently, a starts with an  [foo, bar, baz] Nothing# which later gets resolved into a .ghc4Unresolved scopes should never show up in the final .hie fileghctype or data familyghc type synonymghcdata declarationghcconstructor declarationghcpattern synonymghcclass declarationghcinstance declarationghcTypes of imports and exportsghcEq/Ord instances compare on the converted HieName, as non-exported names may have different uniques after a roundtripghcbound by a pattern matchghcbound by a type signatureghcbound by a hswrapperghcbound by an implicit variableghc%Bound by some instance of given classghcA direct let bindingghc0Different contexts under which identifiers existghcregular variableghc import/exportghc Value bindingghcPattern bindingThis case is tricky because the bound identifier can be used in two distinct scopes. Consider the following example (with -XViewPatterns) 'do (b, a, (a -> True)) <- bar foo a The identifier a% has two scopes: in the view pattern  (a -> True) and in the rest of the do -block in foo a.ghc Declarationghc Type variableghc Record fieldghc/Constraint/Dictionary evidence variable bindingghcUsage of evidence variableghc,Information associated with every identifierWe need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on)ghc'The information stored in one AST node.The type parameter exists to provide flexibility in representation of types (see Note [Efficient serialization of redundant type info]).ghc Annotationsghc'The Haskell types of this node, if any.ghc%All the identifiers and their detailsghcA node annotationghc name of the AST node constructorghcname of the AST node TypeghcSource of node infoghcNodeInfos grouped by sourceghc/Mapping from filepaths to the corresponding ASTghcA list of type arguments along with their respective visibilities (ie. is this an argument that would return L for isVisibleForAllTyFlag?).ghc(Roughly isomorphic to the original core Type.ghcA flattened version of Type.9See Note [Efficient serialization of redundant type info]ghctype with constraint: t1 => t2 (see  IfaceDFunTy)ghcGHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:a simplified AST3nodes are annotated with source positions and types0identifiers are annotated with scope information+the raw bytes of the initial Haskell source#Besides saving compilation cycles, .hie; files also offer a more stable interface than the GHC API.ghc Initial Haskell source file pathghcThe module this HIE file is forghcTypes referenced in the .9See Note [Efficient serialization of redundant type info]ghc$Type-annotated abstract syntax treesghc"The names that this module exportsghc'Raw bytes of the initial Haskell sourceghcCurrent version of .hie filesghc3names of the definitions over which the scope spansghcthe location of the instance/class declaration for the case where the type variable is declared in a method type signatureghc,whether or not the binding is in an instanceghc#scope over which the value is boundghcspan of entire bindingghcscope in the pattern9 (the variable bound can be used further in the pattern)ghc%rest of the scope outside the patternghcspan of entire bindingghctype of declarationghcspan of entire bindingghc!how did this bind come into beingghc#scope over which the value is boundghcspan of the binding site Safe-Inferred "(9^ghc>One must contain the other. Leaf nodes cannot contain anythingghc/Insert an AST in a sorted list of disjoint AstsghcMerge two nodes together.,Precondition and postcondition: elements in  are ordered.ghcMerge two sorted, disjoint lists of ASTs, combining when necessary.1In the absence of position-altering pragmas (ex: # line "file.hs" 3), different nodes in an AST tree should either have disjoint spans (in which case you can say for sure which one comes first) or one span should be completely contained in the other (in which case the contained span corresponds to some child node).>However, since Haskell does have position-altering pragmas it is possible for spans to be overlapping. Here is an example of a source file in which foozball and quuuuuux have overlapping spans: module Baz where # line 3 "Baz.hs" foozball :: Int foozball = 0 # line 3 "Baz.hs" bar, quuuuuux :: Int bar = 1 quuuuuux = 2 8In these cases, we just do our best to produce sensible 's. The blame should be laid at the feet of whoever wrote the line pragmas in the first place (usually the C preprocessor...).ghc*combines and sorts ASTs using a merge sortghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghctype to associate with the nodeghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghctype to associate with the node Safe-Inferred"``ghcLook for any identifiers which occur outside of their supposed scopes. Returns a list of error messages.   Safe-Inferredbghc7The header for HIE files - Capital ASCII letters "HIE".ghcWrite a  to the given ., with a proper header and symbol tables for s and sghcRead a  from a . Can use an existing b. Allows you to specify which versions of hieFile to attempt to read. M* case returns the failing header versions.ghcRead a  from a . Can use an existing b. Safe-InferredgghcRead an interface file header, checking the magic number, version, and way. Returns the hash of the source file and a BinHandle which points at the start of the rest of the interface file data.ghcRead an interface file.ghcThis performs a get action after reading the dictionary and symbol table. It is necessary to run this before trying to deserialise any Names or FastStrings.ghc?Setup a BinHandle to read something written using putWithTablesReading names has the side effect of adding them into the given NameCache.ghcWrite an interface fileghc(Put a piece of data with an initialised  field. This is necessary if you want to serialise Names or FastStrings. It also writes a symbol table and the dictionary. This segment should be read using .ghcWrite name/symbol tables =setup the given BinHandle with Name/FastString table handlingwrite the following - FastString table pointer - Name table pointer - payload - Name table - FastString tableIt returns (number of names, number of FastStrings, payload write result)ghc:Initial ram buffer to allocate for writing interface files Safe-Inferred (vghc,B=]:B, although the free holes are A and B, B might not depend on A at all!If this is invoked on a signature, this does NOT include the signature itself; e.g. precise free module holes of p[A=,B=]:B never includes B.ghc>Check if we need to try the dynamic interface for -dynamic-tooghcWrite interface fileghc readIface tries just the one file.Failed err  => file not found, or unreadable, or illegible Succeeded iface  = successfully found and parsedghc'Read binary interface, and print it outghcShow a ModIface but don't display details; suitable for ModIfaces stored in the EPT.ghcShow a ModIface+The UnitState is used to pretty-print unitsghc/Reason for loading the iface (used for tracing)ghc=The unique identifier of the on-disk module we're looking forghcThe *actual* module we're looking for. We use this to check the consistency of the requirements of the module we read out.ghc Looking for .hi-boot or .hi file  Safe-Inferred zdghc#tcCheckUsage name mult thing_inside runs  thing_inside, checks that the usage of name is a submultiplicity of mult, and removes name from the usage environment. See also Note [Wrapper returned from tcSubMult] in GHC.Tc.Utils.Unify, which applies to the wrapper returned from this function.ghcGet a ( that includes mappings for all vars free in the given type. Useful when tidying open types.ghcMake a name for the dict fun for an instance decl. It's an *external* name, like other top-level names, and hence must be made with newGlobalBinder.ghc mkWrapperName ref what nameBase7See Note [Generating fresh names for FFI wrappers] for ref 's purpose.aaaayœÜĜۜaaaayœÜĜۜ Safe-Inferred }}ghcSee Note [The ZonkEnv] Confused by zonking? See Note [What is zonking?] in GHC.Tc.Utils.TcMType.ghc!Extend the knot-tied environment.%͂s^ۜڜ%͂s^ۜڜ Safe-Inferred %ghc Used when  is the wired-in name for a wired-in class method, so the caller knows its type for sure, which should be of form forall a. C a =>  is supposed to instantiate just the outer type variable and constraintghcGiven ty::forall k1 k2. k, instantiate all the invisible forall-binders returning ty kk1  kk2 :: k[kk1k1, kk2k1] Called only to instantiate kinds, in user-written type signaturesghc This takes a ~# b and returns a ~~ b.ghc This takes a ~# b and returns a ~ b.ghcGiven a list of [], skolemize the type variables, returning a substitution mapping the original tyvars to the skolems, and the list of newly bound skolems.ghcGive fresh uniques to a bunch of TyVars, but they stay as TyVars, rather than becoming TcTyVars Used in , and ghcGive fresh uniques to a bunch of CoVars Used in "GHC.Tc.Instance.Family.newFamInst"ghcCheck that the result type of an expression has a fixed runtime representation.'Used only for arrow operations such as arr, first, etc.ghcwhy do we need this?ghcname of the methodghc)types with which to instantiate the classghc%How to instantiate the type variablesghcType to instantiateghc1Result (type vars, preds (incl equalities), rho)ghcType to instantiate it atghc(Standard name, user name)ghc(Standard name, suitable expression) USED ONLY FOR CmdTop (sigh) *** See Note [CmdSyntaxTable] in  GHC.Hs.Expr## Safe-Inferredbghc looks for just one function arrow, returning an uninstantiated sigma-type.Invariant: the returned argument type has a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.4See Note [Return arguments with a fixed RuntimeRep].ghcLike , but used when you have an "actual" type, for example in function application.INVARIANT: the returned argument types all have a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. See Note [Return arguments with a fixed RuntimeRep].ghcUse this function to split off arguments types when you have an "expected" type.*This function skolemises at each polytype.Invariant: this function only applies the provided function to a list of argument types which all have a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. See Note [Return arguments with a fixed RuntimeRep].ghcFill an w with the given type.If !co = fillInferResult t1 infer_res, then co :: t1 ~# t2 , where t2 is the type stored in the w field of  infer_res.0This function enforces the following invariants:%Level invariant. The stored type t2* is at the same level as given by the w field. FRR invariant. Whenever the w field is not Nothing, t2 is guaranteed to have a syntactically fixed RuntimeRep, in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.ghc Variant of  that takes an ExpTypeghcChecks (TYVAR-TV), (COERCION-HOLE) and (CONCRETE) of Note [Unification preconditions]; returns True if these conditions are satisfied. But see the Note for other preconditions, too.ghc-Breaks apart a function kind into its pieces. ghc'If present, the thing that has type ty1ghc)See Note [Herald for matchExpectedFunTys]ghcThe thing with type TcSigmaTypeghcTotal number of value args in the call, and types of values args to which function has been applied already (reversed) (Both are used only for error messages)ghcType to analyse: a TcRhoTypeghc)See Note [Herald for matchExpectedFunTys]ghcthe thing with type TcSigmaTypeghcActualghcExpectedghcUsed when instantiatingghcUsed when skolemisingghcThe expression that has type actual (if known)ghc Actual typeghc Expected typeghcThe wrapper has type: spec_ty ~> expected_ty Just like tcTopSkolemise, but calls deeplySkolemise instead of topSkolemise See Note [Deep skolemisation]ghcThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcTopSkolemiseghcThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcTopSkolemiseghctype, only for errorsghcn: number of desired arrowsghcfun_kindghc-co :: fun_kind ~ (arg1 -> ... -> argn -> res)## Safe-Inferred %&ghc&A monad within which we will generate KindRep+s. Here we keep an environment containing KindReps which we've already generated so we can re-use them opportunistically.ghcMaps kinds to KindRep bindings. This binding may either be defined in some other module (in which case the Maybe (LHsExpr Id will be J) or a binding which we generated in the current module (in which case it will be K the RHS of the binding).ghcTarget platformghcof TyConghc To construct TrName,s The various TyCon and DataCons of KindRepghc A group of s in need of type-rep bindings.ghcBuild exported KindRep% bindings for the given set of kinds.ghcModule's typerep bindingghcPackage name fingerprintghcModule name fingerprintghcThe s in need of bindings kindsghcInformation we need about a / to generate its representation. We carry the 4 in order to share it between the generation of the TyCon and KindRep bindings.ghcGenerate the Typeable bindings for a module. This is the only entry-point of this module and is invoked by the typechecker driver in  tcRnSrcDecls.&See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.ghc6Generate TyCon bindings for a set of type constructorsghc [a] -> a sumNumList [] = 0 sumNumList (x : xs) = x + sumList xsand add a breakpoint to it:ghci> break sumNumList ghci> sumNumList ([0 .. 9] :: [Int])+ghci shows us more precise types than just as:Stopped in Main.sumNumList, debugger.hs:3:23-39 _result :: Int = _ x :: Int = 0 xs :: [Int] = _ghc&How many times to recurse for subtermsghc Force thunksghc!Type of the object to reconstructghcObject to reconstructghc&How many times to recurse for subtermsghcType to refineghc Refine the type using this value   Safe-Inferred )* ghcThrow an error message if a user attempts to quantify an inferred type variable in a place where specificity cannot be observed. For example, forall {a}. [a] -> [a]2 would be rejected to the inferred type variable {a}, but forall a. [a] -> [a] would be accepted. See +Note [Unobservably inferred type variables].ghc"Examines a non-outermost type for foralls or contexts, which are assumed to be nested. For example, in the following declaration: ,instance forall a. forall b. C (Either a b) The outermost forall a is fine, but the nested forall b is not. We invoke  on the type forall b. C (Either a b) to catch the nested forall' and create a suitable error message.  returns K err_msg if such a forall# or context is found, and returns Nothing otherwise./This is currently used in the following places:In GADT constructor types (in  rnConDecl ). See Note [GADT abstract syntax] (Wrinkle: No nested foralls or contexts) in  GHC.Hs.Type."In instance declaration types (in  rnClsIntDecl and rnSrcDerivDecl in GHC.Rename.Module and  renameSig in GHC.Rename.Bind ). See 6Note [No nested foralls or contexts in instance types] in  GHC.Hs.Type.ghcA common way to invoke .ghcChecks to see if we need to warn for -Wunused-record-wildcards or -Wredundant-record-wildcardsghcProduce a warning when the `..`! pattern binds no new variables. 0 data P = P { x :: Int } foo (P{x, ..}) = x The `..`$ here doesn't bind any variables as x is already bound.ghc/Produce a warning when no variables bound by a `..` pattern are used. . data P = P { x :: Int } foo (P{..}) = () The `..` pattern binds x6 but it is not used in the RHS so we issue a warning.ghcMake a map from selector names to field labels and parent tycon names, to be used when reporting unused record fields.ghc$Should we report the fact that this  is unused? The   may differ from  due to DuplicateRecordFields.ghc?Ensure that a boxed or unboxed tuple has arity no larger than .ghc8Ensure that a constraint tuple has arity no larger than .ghcThe error msg if the signature is not allowed to contain manually written inferred variables.** Safe-Inferred}ghcAttempt to convert a Template Haskell name to one that GHC can understand. Original TH names such as those you get when you use the 'foo syntax will be translated to their equivalent GHC name exactly. Qualified or unqualified TH names will be dynamically bound to names in the module being compiled, if possible. Exact TH names will be bound to the name they represent, exactly.ghcAttempt to convert a Template Haskell name to one that GHC can understand. Original TH names such as those you get when you use the 'foo syntax will be translated to their equivalent GHC name exactly. Qualified or unqualified TH names will be dynamically bound to names in the module being compiled, if possible. Exact TH names will be bound to the name they represent, exactly.1One must be careful to consistently use the same b> to create identifier that might be compared. (C.f. how the . Monad enforces that variables from separate  invocations are never intermingled; it would be valid to use the same tricks for s and bs.)For now, the easiest and recommended way to ensure a consistent b< is used it to retrieve the preexisting one from an active  . A single  is created per GHC "session", and this ensures everything in that session will get the same name cache.)GĞŞƞǞȞɞʞ˞̞͞ΞϞ؞Ԟ՞֞מОўҞӞHžÞޞ۞ܞݞߞڞٞ++++++***************++++++***+**+++++++++++++++++++++*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++$ $ $$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''&''''''''''''''''''''&&'''&&''''&'''''''&&&&&&''''&'&&&&''''''''''''''&\`````````a`aaaaaaa``a```aa````````````````````````````aaaaaaaa``a``````````a````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````_______________```!!!! _____```!``!!!!!!```````````````````````````````````` tt̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛQQQQQQQQQQQQQQQQQQQQQQQQQQ]]]]]]]]]]]]]\\\]]]]\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\!\\\:]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"]]]]]]]]]]]]]]]]]]]]JJJJJJJJJJJJJJJJJJJJJJJJKJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ#SSS#SSSSSSSSSSSSSS###SSSSSSSSSSSSS!SS##SSSSSS#S##S#SSSS#SSSS#S##SSSSSSSSSSS#SS#SSSSSSSSSS#jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjGjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjlllllllmllllllmmmllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm(ccccccccccccccccccccccccccccccccccccccccccccccdccc((EEEEFlFEFElllFlllllllllllllEEElElFllllFFEEllllllllll͋ʋԋҋӋы΋Ћϋɋˋ̋ċŋƋNjȋË‹99999999999999999tttttuutttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuttttttttttt>>>>>>>>NNNNttttttttttttssstttttttttttttttttttttttttttttssssttt===========%%%%%%tttsssssssssssssssuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>uuuuuuvvuuuuuuuuuuuuuuuuuuuuuuuuuuuvuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv%vvvvvvvvvvvuuuuvvv} }} }p{{{{{{{{{{{{{{>>>>>>>>{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|>>>>>>>>>>>>>{{{{{{{{{{{{{{{|{|{{|||{|||||||||{|||||{|        CCCBBBBBBBFFFFFFFFFGCGG'GCCG##D''FFGGGGGGGEGEGFF''GGFCF'FFEEEEEEEEEEEEEEEEE'FGGCCCCCCCCCCCCCCC''EEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'''FFFFFFFFFFFFFA'FFFFFFFFGGGGGGGG'GGG'GGGGGGGGGGGGGGGGGGGG'GGGGGFFFFFFFGFFFF'GFFGGGGGGGGGGFFGGFGGGGGGGGGGGGGGGGGGGGGGFFFFFFFGGGGFGGGG'F'FGG'FGGGGGGGGGFGGGGAAAAAAAAA@@@@@@@@@@@@@@@@@@@@AAAAAAA@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAA@@@@@@@@@@@@@AAAAA@@@BBAAAAAAABBBBABABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAABAABBBBAAAAAAAAAAAAAAAABBBBBBBABBBBBBBABBBBABBBBBAABABABBBBBBBABAAAAAAAAAAABBBBBBBBBBBBBBBB!!!LLLLLEL@LCCMLLLL@@@@@@@MMM@@L@@LLLLMMMMMM@@@MM@@@L@@@LM@L@LL@M@@@@M@MMMM@MMMMMMMMMMM@MLL@LLLLLLMMMMMMM!@@LL@LLLLLLLLLLLLLLLLLLLLEEEEEECEEFFFFFFE@MMMMMMMMMMMMMMMMMMMMMM@LLLLLLLFFMMLLMMMMaaaaaaaaaabbbbaabbabbabbbbbbbbbbbbbbba#baabbbabbbabbababbbabbbb$ba5ba7bbabbbbbababbabbbbbb#b#####bbb#bbbbbbbb#bbbb#bbb##bb#aa#ab##b$b##DDDDDD##b####bbb#abbbabba#abb##########b###b###############################bbb##bb######b#bbbbbbbb#bbbbbb̖͖ΖϖЖіҖՖӖԖȖɖʖ˖֖זٖؖۖܖݖږޖߖ ! !!!!!!!!!!!!!!!!!! !!!!! !!! !!!!!!!!! !!!!!!! !! !"!!!!!!!!!""!!!!!!!!!""! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""!"""!""""""""""!"""""'''''''''(((((''(''('(('(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))())))())))))))))))))))))))))))))))))))))))))))))))))))***))))))))))))))))************************************************************]{ yyyyyyyyyyyyyyy΍ύЍэҍӍԍՍ֍׍؍ٍڍۍ܍ݍލߍ؋ًڋۋ܋݋ދߋ׋֋Ջ֗חؗٗڗۗԗ՗ܗݗޗߗԏӏN$ $ $$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $%&& $$$$&&$&&$$$&&&&&&&&$$ $&&&&&$$&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$&&&&\&```'''``````a`'aaaaaaa``a`'``aa`````````````````````'```'''''````aaaaaaaa``a``````````a````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`(EEEEFlFEFElllFlllllllllllllEEElElFllllFFEEllllllllll&&&&EE&EECCC&&&&&&&&&&BBBBBBB&FFFFFFFFFGCGG'GCCG##D''''''FFFGGGGGGGEGEGFFE''G'G'FCFEEEEFFFFEE'FFEEEEEEEEEEEEEEEEE'FGGCCCCCCCCCCCCCCC''EEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'''FFFFFFFFFFFFFA'FFFFFFFFGGGGGGGGG'GGG'GGGGGGGGGGGGGGGGGGGG'GGGGGFFFFFFFGFFFF'GFFGGGGGGGGGGFFG''''''''''&&'''GFGGGGGGGGGGGGGGGGGGGGGGFFFFFFFGGGGFGGGG'F'FGG'FGGGGGGGGGFGGGGBBBBBBBBBBBBBBBB!!!&LLLLLEL@LCCMLLLL@@@@@@@MMM@@L@@LLLLMMMMMM@@@MM@@@L@@@LM@L@LL@M@@@@M@MMMM@MMMMMMMMMMM@MLL@LLLLLLMMMMMMM!@@LL@LLLLLLLLLLLLLLLLL''LLLEEEEEECEEFFFFFFFE@MMMMMMMMMMMMMMMMMMMMMM@LLLLLLLFFMMLLMMMMԏӏN Safe-Inferred'9 ghc$Always true if we compile with -profghcWhich unfoldings to exposeghctrim off the arity, one-shot-ness, strictness etc which were retained for the benefit of the code generatorghcAre rules exposed or not?ghc?Options for generated static pointers, if enabled (/= Nothing).ghcDon't expose unfoldingsghcOnly expose required unfoldingsghcExpose all unfoldingsghcCollect cost centres defined in the current module, including those in unfoldings. Safe-Inferred Safe-Inferred ghcThis flag is intended to aid in debugging strictness analysis bugs. These are particularly nasty to chase down as they may manifest as segmentation faults. When this flag is enabled we instead produce an b expression to catch the case where a function we think should bottom unexpectedly returns.ghc.This environment is used for three operations: To support cloning of local Ids so that they are all unique (see item (6) of CorePrep overview).To support beta-reduction of runRW, see Note [runRW magic] and Note [runRW arg].To let us inline trivial RHSs of non top-level let-bindings, see Note [lazyId magic], Note [Inlining in CorePrep] and Note #12076(CorePrep inlines trivial CoreExpr not Idghc/Whether to generate a default alternative with b in these cases. This is helpful when debugging demand analysis or type checker bugs which can sometimes manifest as segmentation faults.ghcConvert some numeric literals (Integer, Natural) into their final Core form.ghc%See Note [Floating Ticks in CorePrep]ghc Convert a  so it satisfies , without producing any floats (any generated floats are immediately let-bound using ). Generally you want this, esp. when you've reached a binding form (e.g., a lambda) and floating any further would be incorrect.ghc Convert a  so it satisfies ; also produce a list of  which are being propagated upwards. In fact, this function is used in only two cases: to implement  (which is what you usually want), and in the case when a let-binding is in a case scrutinee--here, we can always float out:case (let x = y in z) of ... ==> let x = y in case z of ...ghcIs an argument okay to CPE?ghc+Like wrapFloats, but only wraps tick floatsghcCreate a function that converts Bignum literals into their final CoreExpr   Safe-Inferred Safe-Inferred ()*YghcIf co :: T ts ~ rep_ty then: +instNewTyCon_maybe T ts = Just (rep_ty, co)Checks for a newtype, and for being saturated Just like Coercion.instNewTyCon_maybe, but returns a TcCoercionghcLike , but returns the arguments back if there is no data family to unwrap. Returns a Representational coercionghcConverts a data family type (eg F [a]) to its representation type (eg FList a) and returns a coercion between the two: co :: F [a] ~R FList a.ghc gets rid of top-level newtypes, potentially looking through newtype  instances and type synonyms.It is only used by the type inference engine (specifically, when solving representational equality), and hence it is careful to unwrap only if the relevant data constructor is in scope. That's why it gets a GlobalRdrEnv argument.It is careful not to unwrap data/newtype instances nor synonyms if it can't continue unwrapping. Such care is necessary for proper error messages.It does not look through type families. It does not normalise arguments to a tycon.If the result is Just ((gres, co), rep_ty), then co : ty ~R rep_ty gres are the GREs for the data constructors that had to be in scopeghc4Checks to make sure no two family instances overlap.ghcCheck whether a new open type family equation can be added without violating injectivity annotation supplied by the user. Returns True when this is possible and False if adding this equation would violate injectivity annotation. This looks only at the one equation; it does not look for interaction between equations. Use checkForInjectivityConflicts for that. Does checks (2)-(4) of Note [Verifying injectivity annotation] in GHC.Core.FamInstEnv.ghcReport a list of injectivity errors together with their source locations. Looks only at one equation; does not look for conflicts *among* equations.ghc,Is type headed by a type family application?ghcIf a RHS is a bare type variable return a set of LHS patterns that are not bare type variables.ghcReturn the set of type variables that a type family equation is expected to be injective in but is not. Suppose we have type family F a b = r | r -> a. Then any variables that appear free in the first argument to F in an equation must be fixed by that equation's RHS. This function returns all such variables that are not indeed fixed. It also returns whether any of these variables appear invisibly and whether -XUndecidableInstances would help. See Note [Coverage condition for injective type families].ghcReport error message for a pair of equations violating an injectivity annotation. No error message if there are no branches.ghcReport error message for equation with injective type variables unused in the RHS. Note [Coverage condition for injective type families], step 6ghcReport error message for equation that has a type family call at the top level of RHSghcReport error message for equation that has a bare type variable in the RHS but LHS pattern is not a bare type variable.ghc(Type family for which we generate errorsghc1Currently checked equation (represented by axiom)ghcInjectivity annotation d d Safe-Inferred 'ghcReport unsolved goals as errors or warnings. We may also turn some into deferred run-time errors if `-fdefer-type-errors` is on.ghcReport *all* unsolved goals as errors, even if -fdefer-type-errors is on However, do not make any evidence bindings, because we don't have any convenient place to put them. NB: Type-level holes are OK, because there are no bindings. See Note [Deferring coercion errors to runtime] Used by solveEqualities for kind equalities (see Note [Failure in local type signatures] in GHC.Tc.Solver)ghcReport all unsolved goals as warnings (but without deferring any errors to run-time). See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.Solverghc,Report unsolved goals as errors or warnings.ghcMake a report from a single .ghc Returns True  == the SolverReportErrCtxt indicates that something is deferredghcShould we completely ignore this constraint in error reporting? It *must* be the case that any constraint for which this returns True somehow causes an error to be reported elsewhere. See Note [Constraints to ignore].ghcMakes an error item from a constraint, calculating whether or not the item should be suppressed. See Note [Wanteds rewrite Wanteds] in GHC.Tc.Types.Constraint. Returns Nothing if we should just ignore a constraint. See Note [Constraints to ignore].ghcActually report this .ghc#zonkTidyTcLclEnvs takes a bunch of y$s, each from a Hole. It returns a ( :-> ) mapping which gives the zonked, tidied type for each Id in any of the binder stacks in the ys. Since there is a huge overlap between these stacks, is is much, much faster to do them all at once, avoiding duplication.ghcWrap an input  with additional contextual information, such as relevant bindings or valid hole fits.ghcPretty-print supplementary information, to add to an error report.ghc(Display a collection of valid hole fits.ghc'Add a "Constraints include..." message."See Note [Constraints include ...]ghcConstructs a new hole error, unless this is deferred. See Note [Constructing Hole Errors].ghcFor all the skolem type variables in a type, zonk the skolem info and group together all the type variables with the same origin.ghcAdds deferred bindings (as errors). See Note [Adding deferred bindings].ghcReport a representation-polymorphism error to the user: a type is required to have a fixed runtime representation, but doesn't.See Note [Reporting representation-polymorphism errors] in GHC.Tc.Types.Origin.ghc&Whether to report something using the FixedRuntimeRep mechanism.ghcThis function tries to reconstruct why a "Coercible ty1 ty2" constraint is left over.ghc&Whether to print explicit kinds (with -fprint-explicit-kinds ) in an  = when a type mismatch occurs to due invisible kind arguments.)This function first checks to see if the   argument is a . If so, it first checks whether the equality is a visible equality; if it's not, definitely print the kinds. Even if the equality is a visible equality, check the expected/actual types to see if the types have equal visible components. If the   is not a 6, fall back on the actual mismatched types themselves.ghcIf the  is a type mismatch between an actual and an expected type, return the actual and expected types (in that order)./Prefer using this over manually inspecting the  datatype if you just want this information, as the datatype itself is subject to change across GHC versions.ghc The main payload of the message.ghcThe context to add, after the main diagnostic but before the supplementary information. Nothing  = don't add any context.ghcSupplementary information, to be added at the end of the message.ghcThe context we're in, i.e. the implications and the tidy environmentghcUnsolved simple constraintsghcThe holeghcWe return the new context with a possibly updated tidy environment, and the valid hole fits. Safe-Inferredghc returns (True, fixity) if it finds a  in a local environment or from an interface file. Otherwise, it returns (False, fixity) (e.g., for unbound s or .s without user-supplied fixity declarations).ghcLook up the fixity of an occurrence of a record field selector. We use  so that we can specify the  6 as the field label, which might be different to the   of the selector  if DuplicateRecordFields is in use (#1173). Safe-Inferred',ghcWhen looking up GREs, we may or may not want to include fields that were defined in modules with NoFieldSelectors( enabled. See Note [NoFieldSelectors].ghcInclude normal names, and fields with selectors, but ignore fields without selectors.ghcInclude normal names and all fields (regardless of whether they have selectors).ghcInclude only fields, with or without selectors, ignoring any non-fields in scope.ghcResult of looking up an occurrence that might be an ambiguous field.ghcOccurrence picked out a single name, which may or may not belong to a field (or might be unbound, if an error has been reported already, per Note [ Unbound vs Ambiguous Names ]).ghcOccurrence picked out two or more fields, and no non-fields. For now this is allowed by DuplicateRecordFields in certain circumstances, as the type-checker may be able to disambiguate later.ghcFound an Exact Or Orig NameghcThe RdrName was an Exact or Orig, but there was an error looking up the Nameghc)The RdrName is neither an Exact nor Origghc Lookup an Exact RdrName. See Note [Looking up Exact RdrNames]. This never adds an error, but it may return one, see Note [Errors in lookup functions]ghcLook up an occurrence of a field in record construction or pattern matching (but not update). When the -XDisambiguateRecordFields flag is on, take account of the data constructor name to disambiguate which field to use.See Note [DisambiguateRecordFields] and Note [NoFieldSelectors].ghcLook up an occurrence of a field in a record update, returning the selector name..Unlike construction and pattern matching with -XDisambiguateRecordFields (see ), there is no data constructor to help disambiguate, so this may be ambiguous if the field is in scope multiple times. However we ignore non-fields in scope with the same name if -XDisambiguateRecordFields: is on (see Note [DisambiguateRecordFields for updates]).!Here a field is in scope even if NoFieldSelectors was enabled at its definition site (see Note [NoFieldSelectors]).ghc,Used in export lists to lookup the children.ghc5Specialised version of msum for RnM ChildLookupResultghc Look up a +% used as a variable in an expression.This may be a local variable, global variable, or one or more record selector functions. It will not return record fields created with the NoFieldSelectors) extension (see Note [NoFieldSelectors]).If the name is not in scope at the term level, but its promoted equivalent is in scope at the type level, the lookup will succeed (so that the type-checker can report a more informative error later). See Note [Promotion].ghcLike -, but with a more informative result if the +! happens to be a record selector:Nothing -> name not in scope (no error reported)Just (UnambiguousGre x) -> name uniquely refers to x, or there is a name clash (reported)Just AmbiguousFields -> name refers to two or more record fields (no error reported)(See Note [ Unbound vs Ambiguous Names ].ghcLike  but returning at most one name, reporting an ambiguity error if there are more than one.ghc%Look up *all* the names to which the + may refer in GHCi (using -fimplicit-import-qualified). This will normally be zero or one, but may be more in the presence of DuplicateRecordFields.ghc,Lookup a name in relation to the names in a ghc,Lookup a name in relation to the names in a ghc:description of thing we're looking up, like "type family"ghc:description of thing we're looking up, like "type family"ghcThe standard nameghcPossibly a non-standard name Lookup a Name that may be subject to Rebindable Syntax (RS).8When RS is off, just return the supplied (standard) NameWhen RS is on, look up the OccName of the supplied Name; return what we find, or the supplied Name if there is nothing in scopeghcThe standard nameghcPossibly a non-standard name<< Safe-Inferred2ghcIndicates if Instance met the Safe Haskell overlapping instances safety check.See Note [Safe Haskell Overlapping Instances] in GHC.Tc.Solver See Note [Safe Haskell Overlapping Instances Implementation] in GHC.Tc.SolverghcExtra information about the parent instance declaration, needed when type-checking associated types. The @. is the enclosing class, the [TyVar] are the scoped* type variable of the instance decl. The  VarEnv Type. maps class variables to their instance types.ghcThe scoped6 tyvars of the instance Why scoped? See bind_me in ghcMaps class tyvars to their instance types See Note [Matching in the consistent-instantiation check]ghc,Assumes that we've checked that this is the Typeable4 class, and it was applied to the correct argument.ghcRepresentation for a type ty of the form  arg -> ret.ghc co1) ~ ty2 (modulo a swap-flag)ghcCall when canonicalizing an equality fails, but if the equality is representational, there is some hope for the future. Examples in Note [Use canEqFailure in canDecomposableTyConApp]ghcCall when canonicalizing an equality fails with utterly no hope.ghc%Solve a reflexive equality constraintghc :: ty1 ~ ty2ghcty1ghc :: ty1 ~ ty1'ghcty2ghcty2, with type synonymsghc>See Note [Wanteds rewrite Wanteds] in GHC.Tc.Types.Constraintghc old evidenceghc"new predicate + coercion, of type  typeof old evidence ~ new predicate  0 Safe-InferredVghc=Perform some IO, typically to interact with an external tool.ghc)Output useful for debugging the compiler.ghc.Create a new Wanted constraint with the given .ghc:Create a new given constraint, with the supplied evidence.#This should only be invoked within  tcPluginSolve.ghc!Create a fresh evidence variable.#This should only be invoked within  tcPluginSolve.ghcCreate a fresh coercion hole. This should only be invoked within  tcPluginSolve.ghcBind an evidence variable.#This should only be invoked within  tcPluginSolve.'}}}}}}}}}}}'}}}}}}}}}}} Safe-Inferredaghc&Instance dictionary function and type.ghcRepresents collections of constraints generated by typechecker pluginsghcOriginal inputs to the plugins with solved/bad constraints removed, but otherwise unmodifiedghcConstraints solved by pluginsghc,Constraints reported as insoluble by pluginsghc"New constraints emitted by pluginsghc7A solved pair of constraints, with evidence for wantedsghc8A pair of (given, wanted) constraints to pass to pluginsghcExtract the (inert) givens and invoke the plugins on them. Remove solved givens from the inert set and emit insolubles, but return new work produced so that ( can feed it back into the main solver.ghcGiven a bag of (rewritten, zonked) wanteds, invoke the plugins on them and produce an updated bag of wanteds (possibly with some new work) and a bag of insolubles. The boolean indicates whether < should feed the updated wanteds back into the main solver.ghcStarting from a pair of (given, wanted) constraints, invoke each of the typechecker constraint-solving plugins in turn and return%the remaining unmodified constraints,"constraints that have been solved,#constraints that are insoluble, and new work.Note that new work generated by one plugin will not be seen by other plugins on this pass (but the main constraint solver will be re-invoked and they will see it later). There is no check that new work differs from the original constraints supplied to the plugin: the plugin itself should perform this check if necessary.ghcAs a last resort, we TEMPORARILY allow a prohibited superclass solve, emitting a loud warning when doing so: we might be creating non-terminating evidence (as we are in T22912 for example).See Note [Migrating away from loopy superclass solving] in GHC.Tc.TyCl.Instance.ghcIf a class is "naturally coherent", then we needn't worry at all, in any way, about overlapping/incoherent instances. Just solve the thing! See Note [Naturally coherent classes] See also Note [The equality types story] in GHC.Builtin.Types.Prim.ghcTry to find a local quantified instance that dominates all others, i.e. which has a weaker instance context than all the others.See Note [Pattern match warnings with insoluble Givens] above.ghc4Return True if the Wanteds are soluble, False if notghcNormalise a type as much as possible using the given constraints. See Note [tcNormalise].ghcWhen inferring types, should we quantify over a given predicate? Generally true of classes; generally false of equality constraints. Equality constraints that mention quantified type variables and implicit variables complicate the story. See Notes [Inheriting implicit parameters] and [Quantifying over equality constraints]ghcLike , but in the TcS monad. Safe-Inferred{ghcCheck a list of binders to see if they make a valid telescope. See Note [Bad TyCon telescopes]ghc0Information about a type being validity-checked.ghcWhen validity-checking an application of a type synonym, should we check the arguments, check the expanded type, or both? See Note [Correctness and performance of type synonym validity checking]ghcOnly check the expanded type.ghcOnly check the arguments.ghc/Check both the arguments and the expanded type.ghcIndicates whether a ? represents type-level contexts, kind-level contexts, or both.ghcA + that only represents type-level positions.ghcA + that only represents kind-level positions.ghcA 8 that can represent both type- and kind-level positions.ghcCheck whether the type signature contains custom type errors, and fail if so.1Note that some custom type errors are acceptable:in the RHS of a type synonym, e.g. to allow users to define type synonyms for custom type errors with large messages (#20181),inside a type family application, as a custom type error might evaporate after performing type family reduction (#20241).ghcDetermine whether a  can represent type-level contexts, kind-level contexts, or both.ghcReturns L if the supplied  is unambiguously not the context for a kind of a type. If the  can refer to both types and kinds, this function conservatively returns L.An example of something that is unambiguously the kind of a type is the Show a => a -> a in type Foo :: Show a => a -> a'. On the other hand, the same type in foo :: Show a => a -> a is unambiguously the type of a term, not the kind of a type, so it is permitted.ghcReturns L if the supplied  is unambiguously not the context for a kind of a type, where the arbitrary use of constraints is currently disallowed. (See Note [Constraints in kinds] in GHC.Core.TyCo.Rep.)ghcReturns L if the supplied  is unambiguously not the context for a kind of a type, where all function arrows currently must be unrestricted.ghcReturns L if the supplied  is unambiguously not the context for the type of a term, where visible, dependent quantification is currently disallowed. If the  can refer to both types and kinds, this function conservatively returns L.An example of something that is unambiguously the type of a term is the forall a -> a -> a in foo :: forall a -> a -> a'. On the other hand, the same type in %type family Foo :: forall a -> a -> a is unambiguously the kind of a type, not the type of a term, so it is permitted.For more examples, see  testsuitetests dependentshould_compileT16326_Compile*.hs+ (for places where VDQ is permitted) and  testsuitetests dependent should_failT16326_Fail*.hs' (for places where VDQ is disallowed).ghcIf LiberalTypeSynonyms is enabled, we start in $ mode for the reasons explained in Note [Liberal type synonyms]. Otherwise, we start in  mode.ghc2See Note [Validity checking of HasField instances]ghc#Split an instance type of the form #forall tvbs. inst_ctxt => inst_head and return (inst_ctxt, inst_head). This function makes no attempt to look through type synonyms. See (Note [Instances and constraint synonyms].ghcDo validity checks on a type family equation, including consistency with any enclosing class instance head, termination, and lack of polytypes.ghc.Checks that an associated type family default:  induced by an import of a particular interface, but without |.ghcIssue a warning if the user imports Data.List without either an import list or  qualified.. This is part of the migration plan for the  proposal. See #17244.ghc7Given an import/export spec, construct the appropriate +s.ghcWarn the user about top level binders that lack type signatures. Called after type inference, so that we can report the inferred type of the functionghc>Warn the user about tycons that lack kind signatures. Called after type (and kind) inference, so that we can report the inferred kinds.++ Safe-Inferredr Safe-Inferred "ghcGiven a resolved name in the children export list and a parent. Decide whether we are allowed to export the child with the parent. Invariant: gre_par == NoParent See Note [Typing Pattern Synonym Exports]ghcJ means no explicit export listghc-Imported modules; this is used to test if a  module Foo6 export is valid (it's not valid if we didn't import Foo!)ghc5Alleged parent type constructor User wrote T( P, Q )ghcEither a a) Pattern Synonym Constructor b) A pattern synonym selector Safe-Inferred 1ghc9Name of an operator in an operator application or sectionghcA normal identifierghcPrefix negationghcAn unbound identifierghcA record field occurrenceghcShould GHC warn if a quantified type variable goes unused? Usually, the answer is "yes", but in the particular case of binding T$, we avoid emitting warnings. See 8Note [Suppress -Wunused-foralls when binding LHsQTyVars].ghcAlways bind any free tyvars of the given type, regardless of whether we have a forall at the top.For pattern type sigs, we do want to bring those type variables into scope, even if there's a forall at the top which usually stops that happening, e.g: \ (x :: forall a. a -> b) -> eHere we do bring b into scope.RULES can also use #, such as in the following example: {-# RULES \"f\" forall (x :: forall a. a -> b). f x = ... b ... #-}This only applies to RULES that do not explicitly bind their type variables. If a RULE explicitly quantifies its type variables, then  is used instead. See also ,Note [Pattern signature binders and scoping] in  GHC.Hs.Type.ghcNever bind any free tyvars. This is used for RULES that have both explicit type and term variable binders, e.g.: {-# RULES \"const\" forall a. forall (x :: a) y. const x y = x #-})The presence of the type variable binder  forall a. implies that the free variables in the types of the term variable binders x and y are not bound. In the example above, there are no such free variables, but if the user had written (y :: b) instead of y% in the term variable binders, then b5 would be rejected for being out of scope. See also ,Note [Pattern signature binders and scoping] in  GHC.Hs.Type.ghcWhen the NamedWildCards extension is enabled, partition_nwcs removes type variables that start with an underscore from the FreeKiTyVars in the argument and returns them in a separate list. When the extension is disabled, the function returns the argument and empty list. See Note [Renaming named wild cards]ghcCreate new renamed type variables corresponding to source-level ones. Duplicates are permitted, but will be removed. This is intended especially for the case of handling the implicitly bound free variables of a type signature.ghcCreate fresh type variables for binders, disallowing multiple occurrences of the same variable. Similar to  except that duplicate occurrences will result in an error, and the source locations of the variables are not adjusted, as these variable occurrences are themselves the binding sites for the type variables, rather than the variables being implicitly bound by a signature.ghc(In what contexts are wildcards permittedghc>Ensures either that we're in a type or that -XPolyKinds is setghc=Look up the fixity for an operator name. Be careful to use  for record fields (see #13132).ghcFilter out any type and kind variables that are already in scope in the the supplied LocalRdrEnv. Note that this includes named wildcards, which look like perfectly ordinary type variables at this point.ghcFilter out any type and kind variables that are already in scope in the the environment's LocalRdrEnv. Note that this includes named wildcards, which look like perfectly ordinary type variables at this point.ghc finds the type/kind variables of a HsType/HsKind. It's used when making the forall6s explicit. See Note [Kind and type-variable binders]ghcExtracts the free type/kind variables from the kind signature of a HsType. This is used to implicitly quantify over k in type T = Nothing :: Maybe k. The left-to-right order of variables is preserved. See Note [Kind and type-variable binders] and Note [Ordering of implicit variables] and Note [Implicit quantification in type synonyms].ghcExtracts free type and kind variables from types in a list. When the same name occurs multiple times in the types, all occurrences are returned.ghcExtracts free type and kind variables from an argument in a GADT constructor, returning variable occurrences in left-to-right order. See %Note [Ordering of implicit variables].ghcGet type/kind variables mentioned in the kind signature, preserving left-to-right order:data T a (b :: k1) :: k2 -> k1 -> k2 -> Type -- result: [k2,k1] an associated type declghcSurface-syntax free vars that we will implicitly bind. May have duplicates, which are removed here.ghcK _ => an associated type declghcSurface-syntax free vars that we will implicitly bind. Duplicate variables will cause a compile-time error regarding repeated bindings.ghcname of the wildcard, or J for an anonymous wildcardghctypeghcK _ => an associated type declghcExplicitly bound hereghcPotential implicit bindersghcFinal implicit binders44 Safe-Inferred%(9ghcBuild a ~ out of an extension constructor, and the two components of the expansion: original and desugared patternsghcTurn a Fractional-looking literal which happens to be an integer into an Integer-looking literal. We only convert numbers where the exponent is between 0 and 100 to avoid converting huge numbers and incurring long compilation times. See #15646.ghcsource patternghcexpanded patternghcsuitably wrapped ~ Safe-Inferred / Safe-Inferred  ghc0'InstDeclFreeVarsMap is an association of an InstDecl with FreeVars. The FreeVars are the tycon names that are both a) free in the instance declaration b) bound by this group of typeclassinstance declsghcStandalone kind signatures.ghc-Free variables of standalone kind signatures.ghcTracks whether we are renaming an equation in a closed type family equation ( ) or not ().ghcTracks whether we are renaming: A type family equation that is not associated with a parent type class ( ). Examples:  type family F a type instance F Int = Bool -- NonAssocTyFamEqn NotClosed type family G a where G Int = Bool -- NonAssocTyFamEqn Closed  /An associated type family default declaration (). Example:  class C a where type A a type instance A a = a -> a -- AssocTyFamDeflt C  0An associated type family instance declaration (). Example:  instance C a => C [a] where type A [a] = Bool -- AssocTyFamInst C [a] ghc rnSourceDecl "renames" declarations. It simultaneously performs dependency analysis and precedence parsing. It also does the following error checks:Checks that tyvars are used properly. This includes checking for undefined tyvars, and tyvars in contexts that are ambiguous. (Some of this checking has now been moved to module  TcMonoType, since we don't have functional dependency information at this point.)1Checks that all variable occurrences are defined. Checks the (..)$ etc constraints in the export list.Brings the binders of the group into scope in the appropriate places; does NOT assume that anything is in scope alreadyghcFor Windows DLLs we need to know what packages imported symbols are from to generate correct calls. Imported symbols are tagged with the current package, so if they get inlined across a package boundary we'll still know where they're from.ghc8Warn about non-canonical typeclass instance declarationsA "non-canonical" instance definition can occur for instances of a class which redundantly defines an operation its superclass provides as well (c.f. /!). In such cases, a canonical instance is one where the subclass inherits its method implementation from its superclass instance (usually the subclass has a default method implementation to that effect). Consequently, a non-canonical instance occurs when this is not the case.See also descriptions of checkCanonicalMonadInstances and checkCanonicalMonoidInstancesghcRenames role annotations, returning them as the values in a NameEnv and checks for duplicate role annotations. It is quite convenient to do both of these in the same place. See also Note [Role annotations in the renamer]ghc Construct an InstDeclFreeVarsMap by eliminating any Names from the FreeVars" which are *not* the binders of a TyClDecl.ghcGet the  LInstDecls which have empty FreeVars sets, and the InstDeclFreeVarsMap with these entries removed. We call (getInsts tcs instd_map) when we've completed the declarations for tcs. The call returns (inst_decls, instd_map'), where inst_decls are the instance declarations all of whose free vars are now defined instd_map' is the inst-decl map with tcs- removed from the free-var setghcRename injectivity annotation. Note that injectivity annotation is just the part after the "|". Everything that appears before it is renamed in rnFamDecl.ghcBrings pattern synonym names and also pattern synonym selectors from record pattern synonyms into scope.ghcAdditional kind variables to implicitly bind if there is no explicit forall. (See the comments on  all_imp_vars+ below for a more detailed explanation.)ghc.Type variables declared in type family headghcResult signatureghcInjectivity annotation Safe-Inferred ghc/Rename a splice pattern. See Note [rnSplicePat]ghcThe splice data to be loggedghcEnsure that we are not using a term-level name in a type-level namespace or vice-versa. Throws a  error if there is a problem.ghcReturns the result of running a splice and the modFinalizers collected during the execution.5See Note [Delaying modFinalizers in untyped splices].ghcoutputs splice information for 2 flags which have different output formats: `-ddump-splices` and `-dth-dec-file` Safe-Inferred(/ghcRename some StmtsghcA tree of statements using a mixture of applicative and bind constructs.ghcThe s of return and pure. These may not be  returnName and pureName due to  QualifiedDo or RebindableSyntax.ghcmaybe rearrange statements according to the ApplicativeDo transformationghc.strip the FreeVars annotations from statementsghcIs this a context where we respect RebindableSyntax? but ListComp are never rebindable Neither is ArrowExpr, which has its own desugarer in GHC.HsToCore.Arrowsghcrearrange a list of statements using ApplicativeDoStmt. See Note [ApplicativeDo].ghcTurn a sequence of statements into an ExprStmtTree using a heuristic algorithm. O(n^2)ghcTurn a sequence of statements into an ExprStmtTree optimally, using dynamic programming. O(n^3)ghcTurn the ExprStmtTree back into a sequence of statements, using ApplicativeStmt where necessary.ghcDivide a sequence of statements into segments, where no segment depends on any variables defined by a statement in another segment.ghcFind a "good" place to insert a bind in an indivisible segment. This is the only place where we use heuristics. The current heuristic is to peel off the first group of independent statements and put the bind after those.ghcBuild an ApplicativeStmt, and strip the "return" from the tail if necessary.For example, if we start with do x <- E1; y <- E2; return (f x y) then we get do (E1[x] | E2[y]); f x ythe LastStmt in this case has the return removed, but we set the flag on the LastStmt to indicate this, so that we can print out the original statement correctly in error messages. It is easier to do it this way rather than try to ignore the return later in both the typechecker and the desugarer (I tried it that way first!).ghcGiven the statements following an ApplicativeStmt, determine whether we need a join or not, and remove the return if necessary.We don't need join if there's a single LastStmt in the form of return E,  return $ E, pure E or pure $ E.ghc(Just e, Just False), if the expression is  return/pure e-, and the third argument is Nothing, (Just e, Just True) if the expression is return/pure $ e-, and the third argument is Nothing, (Just (pure e), Nothing) if the expression is  return/pure e!, and the third argument is Just pure_expr, (Just (pure $ e), Nothing) if the expression is return/pure $ e!, and the third argument is Just pure_expr, otherwise Nothing.ghcBuild a  out of an extension constructor, and the two components of the expansion: original and desugared expressions.ghc7How to rename the body of each statement (e.g. rnLExpr)ghc Statementsghcif these statements scope over something, this renames it and returns the result.ghc'How to rename the body of the statementghc The statementghc0Rename the stuff that this statement scopes overghcThe free variables used in later statements. If the boolean is L, this might be an underestimate because we are in GHCi, and might thus be missing some "used later" FVs. See Note [What is "used later" in a rec stmt]ghc the "tail"ghcfree variables of the tailghcThe argsghcTrue  = need a joinghcThe body statementsghcsource expressionghcexpanded expressionghcsuitably wrapped  Safe-Inferred %&!ghcLoad the module containing the given Name and get its associated . Throws a . if loading fails or the name cannot be found.ghc"Temporarily extend the loaded env.ghcDisplay the loader state.ghc,Initialise the dynamic linker. This entails*a) Calling the C initialisation procedure,6b) Loading any packages specified on the command line,c) Loading any packages specified on the command line, now held in the -l options in v_Opt_l,d) Loading any .o/.dll7 files specified on the command line, now held in ldInputs, e) Loading any MacOS frameworks.NOTE: This function is idempotent; if called more than once, it does nothing. This is useful in Template Haskell, where we call it before trying to link.ghcMerge runs of consecutive of |. This allows for resolution of cyclic symbol references when dynamically linking. Specifically, we link together all of the static objects into a single shared object, avoiding the issue we saw in #13786.ghcLoad a single expression,  including first loading packages and modules that this expression depends on.Raises an IO exception () if it can't find a compiled version of the dependents to load.ghc#Load the object files and link themIf the interpreter uses dynamic-linking, build a shared library and load it. Otherwise, use the RTS linker.ghcCreate a shared library containing the given object files and load it.ghc!Useful to apply to the result of ghc8Unloading old objects ready for a new compilation sweep.The compilation manager provides us with a list of linkables that it considers "stable", i.e. won't be recompiled this time around. For each of the modules current linked in memory,if the linkable is stable (and it's the same one -- the user may have recompiled the module on the side), we keep it,otherwise, we unload it.?we also implicitly unload all temporary bindings at this point.ghcLoad exactly the specified packages, and their dependents (unless of course they are already loaded). The dependents are loaded automatically, and it doesn't matter what order you specify the input packages.ghcRetrieve the list of search directory GCC and the System use to find libraries and components. See Note [Fork/Exec Windows].ghcCache for the GCC search directories as this can't easily change during an invocation of GHC. (Maybe with some env. variable but we'll) deal with that highly unlikely scenario then.ghcGet a list of system search directories, this to alleviate pressure on the findSysDll function.ghcMerge the given list of paths with those in the environment variable given. If the variable does not exist then just return the identity.ghc%returns the set of linkables requiredghcThe linkables to *keep*.|||||||||||||||||||||| Safe-InferredlghcInitialise plugins specified by the current DynFlags and update the session.ghcLoads the plugins specified in the pluginModNames field of the dynamic flags. Should be called after command line arguments are parsed, but before actual compilation starts. Idempotent operation. Should be re-called if pluginModNames or pluginModNameOpts changes.ghc=Force the interfaces for the given modules to be loaded. The  # parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.ghcForce the interface for the module containing the name to be loaded. The  # parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.ghc Load the  associated with the given name, come hell or high water. Fails if:!The interface could not be loadedThe name is not that of a +The name did not exist in the loaded moduleghc#Loads the value corresponding to a  if that value has the given . This only provides limited safety in that it is up to the user to ensure that that type corresponds to the type you try to use the return value at!8If the value found was not of the correct type, returns Left actual_type.. Any other condition results in an exception:%If we could not load the names module(If the thing being loaded is not a value(If the Name does not exist in the moduleIf the link failedghcCoerce a value as usual, but:1) Evaluate it immediately to get a segfault early if the coercion was wrong2) Wrap it in some debug messages at verbosity 3 or higher so we can see what happened if it does segfaultghc Finds the  corresponding to the given + in the context of the   . Returns Nothing if no such > could be found. Any other condition results in an exception: If the module could not be found3If we could not determine the imports of the moduleCan only be used for looking up names while loading plugins (and is *not* suitable for use within plugins). The interface file is loaded very partially: just enough that it can be used, without its rules and instances affecting (and being linked from!) the module being compiled. This was introduced by 57d6798.Need the module as well to record information in the interface file   Safe-Inferred %& ghcReturns true if an p is for data T (an abstract data type)ghc Merge two ps together, preferring a non-abstract one. If both are non-abstract we pick one arbitrarily (and check for consistency later.)ghc Merge two $s of ps by  .ghcThis is a very interesting function. Like typecheckIface, we want to type check an interface file into a ModDetails. However, the use-case for these ModDetails is different: we want to compare all of the ModDetails to ensure they define compatible declarations, and then merge them together. So in particular, we have to take a different strategy for knot-tying: we first speculatively merge the declarations to get the "base" truth for what we believe the types will be (this is "type computation.") Then we read everything in relative to this truth and check for compatibility.During the merge process, we may need to nondeterministically pick a particular declaration to use, if multiple signatures define the declaration (). If, for all choices, there are no type synonym cycles in the resulting merged graph, then we can show that our choice cannot matter. Consider the set of entities which the declarations depend on: by assumption of acyclicity, we can assume that these have already been shown to be equal to each other (otherwise merging will fail). Then it must be the case that all candidate declarations here are type-equal (the choice doesn't matter) or there is an inequality (in which case merging will fail.)Unfortunately, the choice can matter if there is a cycle. Consider the following merge:signature H where { type A = C; type B = A; data C } signature H where { type A = (); data B; type C = B } If we pick  type A = C as our representative, there will be a cycle and merging will fail. But if we pick  type A = () as our representative, no cycle occurs, and we instead conclude that all of the types are unit. So it seems that we either (a) need a stronger acyclicity check which considers *all* possible choices from a merge, or (b) we must find a selection of declarations which is acyclic, and show that this is always the "best" choice we could have made (ezyang conjectures this is the case but does not have a proof). For now this is not implemented.It's worth noting that at the moment, a data constructor and a type synonym are never compatible. Consider:signature H where { type Int=C; type B = Int; data C = Int} signature H where { export Prelude.Int; data B; type C = B; }This will be rejected, because the reexported Int in the second signature (a proper data type) is never considered equal to a type synonym. Perhaps this should be relaxed, where a type synonym in a signature is considered implemented by a data type declaration which matches the reference of the type synonym.ghcTypecheck a signature  under the assumption that we have instantiated it under some implementation (recorded in ?) and want to check if the implementation fills the signature.0This needs to operate slightly differently than  because (1) we have a ֝, from the exports of the implementing module, which we will use to give our top-level declarations the correct s even when the implementor provided them with a reexport, and (2) we have to deal with DFun silliness (see Note [rnIfaceNeverExported])ghc1See Note [Interface File with Core: Sharing RHSs]ghcTrue  =# discard IdInfo on IfaceId bindingsghc,For associated type/data family declarationsghcTrue  =# discard IdInfo on IfaceId bindingsghcIs this unfolding compulsory? See Note [Checking for representation polymorphism] in GHC.Core.Lint Safe-Inferred(1ghc) describes how to typecheck an explicit (T) or implicit () binder in a type. It is just a record of flags that describe what sort of  to create.ghc1Describes the kind expected in a certain context.ghca specific kindghcany kind will doghcsomething of the form TYPE _ghcInfo about the context in which we're checking a type. Currently, differentiates only between types and kinds, but this will likely grow, at least to include the distinction between patterns and not-patterns./To find out where the mode is used, search for =This data type is purely local, not exported from this moduleghcTypecheck a deriving strategy. For most deriving strategies, this is a no-op, but for the via* strategy, this requires typechecking the via type.ghc%Type-check a visible type applicationghcCheck and desugar a type, returning the core type and its possibly-polymorphic kind. Much like  tcInferRho at the expression level.ghcCall / and check its result against an expected kind.ghcInfer the kind of a type and desugar. This is the "up" type-checker, as described in Note [Bidirectional type checking]ghcApply a type of a given kind to a list of arguments. This instantiates invisible parameters as necessary. Always consumes all the arguments, using matchExpectedFunKind as necessary. This takes an optional  VarEnv Kind which maps kind variables to kinds.- These kinds should be used to instantiate invisible kind variables; they come from an enclosing class for an associated type/data family.tcInferTyApps also arranges to saturate any trailing invisible arguments of a type-family application, which is usually the right thing to do tcInferTyApps_nosat does not do this saturation; it is used only by ":kind" in GHCighcApply a type of a given kind to a list of arguments. This instantiates invisible parameters as necessary. Always consumes all the arguments, using matchExpectedFunKind as necessary. This takes an optional  VarEnv Kind which maps kind variables to kinds.- These kinds should be used to instantiate invisible kind variables; they come from an enclosing class for an associated type/data family.tcInferTyApps also arranges to saturate any trailing invisible arguments of a type-family application, which is usually the right thing to do tcInferTyApps_nosat does not do this saturation; it is used only by ":kind" in GHCighcThis instantiates invisible arguments for the type being checked if it must be saturated and is not yet saturated. It then calls and uses the result from checkExpectedKindX to build the final typeghcNew unification variable '_' for a wildcardghc Kind-check a T . Used in inferInitialKind$ (for tycon kinds and other kinds).-This function does not do telescope checking.ghcKind-check a declaration header against a standalone kind signature. See Note [kcCheckDeclHeader_sig]ghcSkolemise the Ts in an T with the supplied .ghcBring into scope the binders of a PolyTcTyCon Used for the type variables of a type or class decl in the "kind checking" and "type checking" pass, but not in the initial-kind run.ghcGeneralize some of the free variables in the given type. All such variables should be *kind* variables; any type variables should be explicitly quantified (with a forall ) before now.The WantedConstraints are un-solved kind constraints. Generally they'll be reported as errors later, but meanwhile we refrain from quantifying over any variable free in these unsolved constraints. See Note [Failure in local type signatures].But in all cases, generalize only those variables whose TcLevel is strictly greater than the ambient level. This "strictly greater than" means that you likely need to push the level before creating whatever type gets passed here.Any variable whose level is greater than the ambient level but is not selected to be generalized will be promoted. (See [Promoting unification variables] in  GHC.Tc.Solver. and Note [Recipe for checking a signature].)The resulting KindVar are the variables to quantify over, in the correct, well-scoped order. They should generally be Inferred, not Specified, but that's really up to the caller of this function.ghcSpecialised version of , but with empty WantedConstraints, so no filtering is needed i.e. kindGeneraliseAll = kindGeneralizeSome emptyWCghcSpecialized version of , but where no variables can be generalized, but perhaps some may need to be promoted. Use this variant when it is unknowable whether metavariables might later be constrained.To see why this promotion is needed, see Note [Recipe for checking a signature], and especially Note [Promotion in signatures].ghcChecks that the return kind in a data declaration's kind signature is permissible. There are three cases:If dealing with a data, newtype,  data instance, or newtype instance- declaration, check that the return kind is Type.If the declaration is a newtype or newtype instance and the UnliftedNewtypes extension is enabled, this check is slightly relaxed so that a return kind of the form TYPE r (for some r) is permitted. See )Note [Implementation of UnliftedNewtypes] in  GHC.Tc.TyCl.If dealing with a  data family declaration, check that the return kind is either of the form: TYPE r (for some r), ork (where k% is a bare kind variable; see #12369))See also Note [Datatype return kinds] in  GHC.Tc.TyClghc2Checks that the result kind of a class is exactly  Constraint<, rejecting type synonyms and type families that reduce to  Constraint . See #16826.ghcMake an appropriate message for an error in a function argument. Used for both expressions and types.ghc3Add a "In the data declaration for T" or some such. ghcThe deriving strategyghcThe typechecked deriving strategy and the tyvars that it binds (if using V).ghcargument typesghcof these kindsghc expected kind of the whole tupleghcFunction (for printing only)ghcFunctionghcArgsghc(f args, result kind)ghcFunction (for printing only)ghcFunctionghcArgsghc(f args, result kind)ghc"type we're checking (for printing)ghctype we're checkingghcthe known kind of that typeghcthe expected kindghcof the thing being checkedghc What sort of  is being checkedghcBinders in the headerghcThe result kindghcA suitably-kinded TcTyConghcof the thing being checkedghc What sort of  is being checkedghcBinders in the headerghc/The result kind. AnyKind == no result signatureghc%A suitably-kinded generalized TcTyConghcof the thing being checkedghc What sort of  is being checkedghcBinders in the headerghcThe result kindghc%A suitably-kinded generalized TcTyConghcof the thing being checkedghc What sort of  is being checkedghcThe result kindghc)A suitably-kinded non-generalized TcTyConghc;Standalone kind signature, fully zonked! (zonkTcTypeToType)ghcof the thing being checkedghc What sort of  is being checkedghcBinders in the headerghc/The result kind. AnyKind == no result signatureghcA suitably-kinded, fully generalised TcTyCon Postcondition to (kcCheckDeclHeader_sig sig_kind n f hs_tvs kc_res_ki): kind(returned PolyTcTyCon) = sig_kindghcneedn't be zonkedʆ†ÆĆņƆdžȆɆˆ̆͆ΆφІц҆ӆԆՆֆ׆؆نچʆ†ÆĆņƆdžȆɆˆ̆͆ΆφІц҆ӆԆՆֆ׆؆نچ Safe-InferredghcFind the location of the top-level context of a HsType. For example:  forall a b. (Eq a, Ord b) => blah ^^^^^^^^^^^^^  If there is none, return Nothingghc0If there are no wildcards, return a LHsSigWcType,y,y Safe-Inferred 6ghc A variant of tcPat that takes a custom originghc:Convenient wrapper for calling a matchExpectedXXX functionghcCheck that a pattern isn't a GADT, or doesn't have existential variables, in a situation in which that is not permitted (inside a lazy pattern, or in arrow notation).ghcatternsghctypes of the patternsghcchecker for the bodyghc(origin to use if the type needs inst'ingghcFully refined result typeghcTranslated patternghcType of the patternghcThe TyCon that this data constructor actually returns. In the case of a data family, this is the representation TyCon.ghcThe type of the pattern. In the case of a data family, this would mention the family TyConghc existentialsghcargument types   Safe-Inferred Safe-Inferred ghcWarn the user about polymorphic local binders that lack type signatures.ghcThe location of the first pattern synonym binding (for error reporting) Safe-Inferred 9ghcA monad for type synonym cycle checking, which keeps track of the TyCons which are known to be acyclic, or a failure message reporting that a cycle was found.ghc Test if a 8 is acyclic, short-circuiting if we've seen it already.ghcChecks if any of the passed in s have cycles. Takes the   of the home package (as we can avoid checking those TyCons: cycles never go through foreign packages) and the corresponding LTyClDecl Name for each (, so we can give better error messages.   Safe-Inferred +R ghcGiven a {. of an instantiated signature (note that the { must be knot-tied consistently with the actual implementation) and a + constructed from the implementor of this interface, verify that the actual implementation actually matches the original interface.Note that it is already assumed that the implementation *exports* a sufficient set of entities, since otherwise the renaming and then typechecking of the signature  would have failed.ghc Checks if a z is "defined". In general, for hsig files we can't assume that the implementing file actually implemented the instances (they may be reexported from elsewhere). Where should we look for the instances? We do the same as we would otherwise: consult the EPS. This isn't perfect (we might conclude the module exports an instance when it doesn't, see #9422), but we will never refuse to compile something.ghc For a module modname of type  , determine the list of extra "imports" of other requirements which should be considered part of the import of the requirement, because it transitively depends on those requirements by imports of modules from other packages. The situation is something like this:unit p where signature X signature Y import Xunit q where dependency p[X=,Y=] signature A signature BAlthough q's B does not directly import A, we still have to make sure we process A first, because the merging process will cause B to indirectly import A. This function finds the TRANSITIVE closure of all such imports we need to make.ghcLike implicitRequirements', but returns either the module name, if it is a free hole, or the instantiated unit the imported module is from, so that that instantiated unit can be processed and via the batch mod graph (rather than a transitive closure done here) all the free holes are still reachable.ghcGiven a  , make sure it is well typed. This is because unit IDs come from Cabal, which does not know if things are well-typed or not; a component may have been filled with implementations for the holes that don't actually fulfill the requirements.ghcTop-level driver for signature instantiation (run when compiling an hsig file.)ghcTop-level driver for signature merging (run after typechecking an hsig file).ghc The list of s of *non-exported* ps which this p may refer to. A non-exported p1 should be kept after thinning if an *exported* p (or , perhaps) refers to it; we can't decide to keep it by looking at the exports of a module after thinning. Keep this synchronized with  rnIfaceDecl.ghcGiven a local ), merge all inherited requirements from |) into this signature, producing a final ? that matches the local signature and all required signatures.ghcAdd on the necessary transitive information from the merged signature to the | of the result of merging. This propagates the orphan instances which were in the transitive closure of the signature through the merge.ghcTop-level driver for signature instantiation (run when compiling an hsig file.)ghcCheck if module implements a signature. (The signature is always un-hashed, which is why its components are specified explicitly.)ghcGiven , instantiate a  from the indefinite library to use the actual implementations of the relevant entities, checking that the implementation matches the signature.ghc+From the signature resulting from the mergeghcFrom the original signature   Safe-Inferred -Rghc PatSyn NameghcPatSyn type (UniBidirExplicitBidir)ghc Whether infixghcPattern of the PatSynghcPattern arguments and types. These must have a syntactically fixed RuntimeRep as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.ghc Pattern type ghc Type) Maybe where {} 'Then in order to typecheck the default F+ instance, we must apply the substitution #[k :-> (Type -> Type), a :-> Maybe] to F's binders, which are [k, a, (b :: k)]#. The result should look like this: ? type F (Type -> Type) Maybe (b :: Type -> Type) = (Proxy (Type -> Type) Maybe, Proxy $(Type -> Type) (b :: Type -> Type)) 9Making this work requires some care. There are two cases: If we encounter a type variable in the domain of the substitution (e.g., k or a+), then we apply the substitution directly.Otherwise, we substitute into the type variable's kind (e.g., turn b :: k to b :: Type -> Type=). We then return an extended substitution where the old b (of kind k) maps to the new b (of kind  Type -> Type).This step is important to do in case there are later occurrences of b, which we must ensure have the correct kind. Otherwise, we might end up with Proxy @(Type -> Type) (b :: k) on the right-hand side of the default instance, which would be completely wrong. Contrast . function with similar substitution functions: substTyVars does not substitute into the kinds of each type variable, nor does it extend the substitution.  substTyVars8 is meant for occurrences of type variables, whereas  substATBndrs is meant for binders.substTyVarBndrs does substitute into kinds and extends the substitution, but it does not apply the substitution to the variables themselves. As such, substTyVarBndrs returns a list of s rather than a list of s.   Safe-Inferred 1N!ghcInformation about the arguments to the class in a stock- or newtype-derived instance. For a deriving2-generated instance declaration such as this one: instance Ctx => Cls cls_ty_1 ... cls_ty_m (TC tc_arg_1 ... tc_arg_n) where ...  corresponds to cls_ty_1 ... cls_ty_m. corresponds to TC. corresponds to tc_arg_1 ... tc_arg_n.See &Note [DerivEnv and DerivSpecMechanism] in GHC.Tc.Deriv.Utils for a more in-depth explanation, including the relationship between  and .A ? value can be seen as a more structured representation of the  denv_inst_tys in a DerivEnv , as the  denv_inst_tys is equal to dit_cls_tys ++ [' dit_tc dit_tc_args]?. Other parts of the instance declaration can be found in the DerivEnv. For example, the Cls* in the example above corresponds to the denv_cls field of DerivEnv./Similarly, the type variables that appear in a + value are the same type variables as the denv_tvs in the parent DerivEnv. Accordingly, if we are inferring an instance context, the type variables will be , skolems. Otherwise, they will be ordinary s. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.ghc,Other arguments to the class except the lastghcType constructor for which the instance is requested (last arguments to the type class)ghc!Arguments to the type constructorghcThe representation tycon for 7 (for data family instances). Otherwise the same as .ghcThe representation types for 7 (for data family instances). Otherwise the same as .ghcThe cached results of instantiating each data constructor's field types using S data_con  . See 2Note [Instantiating field types in stock deriving].This field is only used for stock-derived instances and goes unused for newtype-derived instances. It is put here mainly for the sake of convenience.ghcA declarative description of an auxiliary binding that should be generated. See Note [Auxiliary binders]8 for a more detailed description of how these are used.ghc$tag2con:: Given a tag, computes the corresponding data constructorghc$maxtag: The maximum possible tag value among a data type's constructorsghc$t: The DataType representation for a Data instanceghc$c: The Constr representation for a Data instanceghc Retrieve the +" of the binding that the supplied  describes.ghcshowString :: String -> ShowSghc(showsPrec :: Show a => Int -> a -> ShowSghcshows :: Show a => a -> ShowSghc6Generate the full code for an auxiliary binding. See =Note [Auxiliary binders] (Wrinkle: Reducing code duplication).ghcGenerate the code for an auxiliary binding that is a duplicate of another auxiliary binding. See =Note [Auxiliary binders] (Wrinkle: Reducing code duplication).ghc:Generate the type signature of an auxiliary binding. See Note [Auxiliary binders].ghcTake a  of s and generate the code for auxiliary bindings based on the declarative descriptions in the supplied s. See Note [Auxiliary binders].ghcMake a function binding. If no equations are given, produce a function with the given arity that produces a stock error.ghcMake a function binding. If no equations are given, produce a function with the given arity that uses an empty case expression for the last argument that is passes to the given function to produce the right-hand side.ghcProduces a function binding. When no equations are given, it generates a binding of the given arity and an empty case expression for the last argument that it passes to the given function to produce the right-hand side.ghcProduces a function binding. When there are no equations, it generates a binding with the given arity that produces an error based on the name of the type of the last argument.ghc0A table of postfix modifiers for unboxed values.ghcLookup  in an association list.ghcLookup  in an association list.ghc>Generate the name for an auxiliary binding, giving it a fresh . Returns an + + with an underlying System . See Note [Auxiliary binders].ghc$getPossibleDataCons tycon tycon_args returns the constructors of tycon0 whose return types match when checked against  tycon_args.7See Note [Filter out impossible GADT data constructors]ghc;Look up a data constructor's instantiated field types in a . See 2Note [Instantiating field types in stock deriving].ghc tycon arg_tys' constructs a cache that maps each of tycon's data constructors to their field types, with are to be instantiated with arg_tys. See 2Note [Instantiating field types in stock deriving].ghc#Apply a substitution to all of the s contained in a . See 2Note [Instantiating field types in stock deriving]' for why we need to substitute into a  in the first place.ghc Zonk the s in a  value to s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.&& Safe-Inferred V6 ghcDoes not contain variableghcThe variable itselfghc$The variable itself, contravariantlyghc Function typeghcTuple type. The [a]= is the result of folding over the arguments of the tuple.ghc2Type app, variable only in last argument. The two ,s are the function and argument parts of  fun_ty arg_ty, respectively.ghc.Type app, variable other than in last argumentghc Forall typeghc#Return all syntactic subterms of a  that are applied to the  argument. This determines what constraints should be inferred for derived *, 5, and 6 instances in GHC.Tc.Deriv.Infer. For instance, if we have: :data Foo a = MkFoo Int a (Maybe a) (Either Int (Maybe a)) Then the following would hold: a Int would return [], since Int' does not contain the type variable a at all. a a would return []. Although the type a contains the type variable a , it is not applied to a!, which is the criterion that  checks for. a (Maybe a) would return [Maybe], as Maybe is applied to a. a (Either Int (Maybe a)) would return [Either Int, Maybe]%. Both of these types are applied to a through composition. As used in GHC.Tc.Deriv.Infer, the ! argument will always come from , so it is important that the  comes from S to match. Make sure not to take the  from A, as these differ from the S when the data type is a GADT. (See #22167 for what goes wrong if A is used.)ghcVariable to look forghc How to foldghcType to process Safe-Inferred _ghcSee documentation of ; that function uses the fields of this type to interpret the structure of a type when that type is considered as an argument to a constructor that is being represented with Rep1.ghc Called by 6; generates a list of types, each of which must be a * in order for the Generic1- instance to work. For instance, if we have: :data Foo a = MkFoo Int a (Maybe a) (Either Int (Maybe a)) Then  a (f (g a)) would return  [Either Int], as a derived Generic1 instance would need to call  at that type. Invoking  a* on any of the other fields would return []. is very similar in spirit to  in GHC.Tc.Deriv.Functor. Just like with , it is important that the  argument come from S%. (See #22167 for what goes wrong if A is used.)ghc argTyFold3 implements a generalised and safer variant of the arg function from Figure 3 in  (http://dreixel.net/research/pdf/gdmh.pdf. arg is conceptually equivalent to: arg t = case t of _ | isTyVar t -> if (t == argVar) then Par1 else Par0 t App f [t'] | representable1 f && t' == argVar -> Rec1 f App f [t'] | representable1 f && t' has tyvars -> f :.: (arg t') _ -> Rec0 twhere argVar is the last type variable in the data type declaration we are finding the representation for. argTyFold is more general than arg because it uses . to abstract out the concrete invocations of Par0, Rec0, Par1, Rec1, and :.:. argTyFold is safer than arg because arg would lead to a GHC panic for some data types. The problematic case is when t0 is an application of a non-representable type f to argVar: App f [argVar] is caught by the _% pattern, and ends up represented as Rec0 t. This type occurs free in the RHS of the eventual Rep1 instance, which is therefore ill-formed. Some representable1 checks have been relaxed, and others were moved to canDoGenerics1.ghc-Variant of foldr for producing balanced lists Safe-Inferred 2ghc A list of  constraints to simplify when inferring a derived instance's context. For the stock, newtype, and via- deriving strategies, these will consist of  s, and for DeriveAnyClass, these will consist of 0s. Here is an example to illustrate the latter: class Foo a where bar :: forall b. Ix b => a -> b -> String default bar :: forall y. (Show a, Ix y) => a -> y -> String bar x y = show x ++ show (range (y, y)) baz :: Eq a => a -> a -> Bool default baz :: Ord a => a -> a -> Bool baz x y = compare x y == EQ data Quux q = Quux deriving anyclass Foo Then it would generate two s, one for each method: [ SubTypePredSpec { stps_ty_actual = forall y. (Show (Quux q), Ix y) => Quux q -> y -> String , stps_ty_expected = forall b. (Ix b) => Quux q -> b -> String , stps_ty_origin = DerivClauseCtxt } , SubTypePredSpec { stps_ty_actual = Ord (Quux q) => Quux q -> Quux q -> Bool , stps_ty_expected = Eq (Quux q) => Quux q -> Quux q -> Bool , stps_ty_origin = DerivClauseCtxt } ] (Note that the type variable q is bound by the data type Quux , and thus appears free in the s and s.)See ?Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer! for an explanation of how these /s are used to compute implication constraints.ghcA  specifies a constraint to emitted when inferring the instance context for a derived instance in .ghc An ordinary  that directly stores a , which will be emitted as a wanted constraint in the constraint solving machinery. This is the simple case, as there are no skolems, metavariables, or given constraints involved.ghc A special  that is only used by DeriveAnyClass. This will check if stps_ty_actual0 is a subtype of (i.e., more polymorphic than) stps_ty_expected in the constraint solving machinery, emitting an implication constraint as a side effect. For more details on how this works, see ?Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer.ghc"The constraint to emit as a wantedghcThe origin of the constraintghc(Whether the constraint is a type or kindghc#The actual type. In the context of DeriveAnyClass-, this is the default method type signature.ghc%The expected type. In the context of DeriveAnyClass., this is the original method type signature.ghcThe origin of the constraintghc-Describes how to generate instance bindings ()) and associated type family instances (+) for a particular stock-derived instance.ghcDescribes how to generate instance bindings for a stock-derived instance."This function takes two arguments: : the source location where the instance is being derived. This will eventually be instantiated with the  field of a .: information about the argument types to which a class is applied in a derived instance. This will eventually be instantiated with the  field of a ."This function returns four things: U /6: The derived instance's function bindings (e.g., !compare (T x) (T y) = compare x y)[U /]: A list of instance specific signatures/pragmas. Most likely INLINE pragmas for class methods. : Auxiliary bindings needed to support the derived instance. As examples, derived % and ,+ instances sometimes require top-level con2tag functions. See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate.[]: A list of Names for which -Wunused-binds should be suppressed. This is used to suppress unused warnings for record selectors when deriving -, 1, or Generic . See +Note [Deriving and unused record selectors].ghcDescribes how to generate associated type family instances for a stock-derived instance. This function takes the same arguments as the  function but returns a list of ds instead. Generating type family instances is done separately from  since the type family instances must be generated before the instance bindings can be typechecked. See Note [Staging of tcDeriving] in  GHC.Tc.Deriv.ghcRecords whether a particular class can be derived by way of an  originative deriving strategy (i.e., stock or anyclass).See Note [Deriving strategies] in  GHC.Tc.Deriv.ghcWhether GHC is processing a deriving. clause or a standalone deriving declaration.ghc'InferContext mb_wildcard is either:A deriving clause (in which case  mb_wildcard is J).A standalone deriving declaration with an extra-constraints wildcard as the context (in which case  mb_wildcard is K loc, where loc$ is the location of the wildcard.GHC should infer the context.ghc theta. is a standalone deriving declaration, where theta& is the context supplied by the user.ghc>What action to take in order to derive a class instance. See &Note [DerivEnv and DerivSpecMechanism], as well as Note [Deriving strategies] in  GHC.Tc.Deriv.ghc"Standard" classesghc GeneralizedNewtypeDerivingghc DeriveAnyClassghc  DerivingViaghcInformation about the arguments to the class in the derived instance, including what type constructor the last argument is headed by. See &Note [DerivEnv and DerivSpecMechanism].ghcHow to generate the instance bindings and associated type family instances.ghcInformation about the arguments to the class in the derived instance, including what type constructor the last argument is headed by. See &Note [DerivEnv and DerivSpecMechanism].ghcThe newtype rep type.ghc0All arguments to the class besides the last one.ghcThe last argument to the class.ghcThe via typeghcContains all of the information known about a derived instance when determining what its EarlyDerivSpec should be. See &Note [DerivEnv and DerivSpecMechanism].ghc Is this an overlapping instance?ghcUniversally quantified type variables in the instance. If the  denv_ctxt is , these will be  skolems. If the  denv_ctxt is , these will be ordinary  s. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.&All type variables that appear in the , , , and  should come from .ghc-Class for which we need to derive an instanceghcAll arguments to  in the derived instance.ghc theta for standalone deriving (where theta( is the context of the instance).  for deriving clauses, or for standalone deriving that uses a wildcard constraint. See %Note [Inferring the instance context].ghcThe   used to skolemise the denv_tvs in the case where the  is .ghcK if user requests a particular deriving strategy. Otherwise, J.ghc0To avoid having to manually plumb everything in " throughout various functions in  GHC.Tc.Deriv and GHC.Tc.Deriv.Infer , we use #, which is a simple reader around ԝ.ghc4Is GHC processing a standalone deriving declaration?ghcIs GHC processing a standalone deriving declaration with an extra-constraints wildcard as the context? (e.g., !deriving instance _ => Eq (Foo a))ghcReturn φ! if processing with a standalone deriving declaration or ֆ if processing a deriving clause.ghc wc returns  if wc is L, and  if wc is I. Useful for error-reporting.ghcSet the  in a .ghc Zonk the s in a  to s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.ghc Convert a  to its corresponding V.ghc Zonk the s in a  to s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.ghcBuild a list of s, using the supplied   and   values for each .ghc"Capture wanted constraints from a .ghcSome common validity checks shared among stock derivable classes. One check that absolutely must hold is that if an instance C (T a) is being derived, then T must be a tycon for a data type or a newtype. The remaining checks are only performed if using a deriving) clause (i.e., they're ignored if using StandaloneDeriving): The data type must have at least one constructor (this check is ignored if using EmptyDataDeriving).0The data type cannot have any GADT constructors.The data type cannot have any constructors with existentially quantified type variables.+The data type cannot have a context (e.g., data Foo a = Eq a => MkFoo).8The data type cannot have fields with higher-rank types.ghcFor some classes (eg %, ,) we allow unlifted arg types by generating specialised code. For others (eg Data!) we don't. For even others (eg Lift7), unlifted types aren't even a special consideration!ghc2Information about the type arguments to the class.ghcO if deriving an instance for this type is possible. Otherwise, it's O err, where err explains what went wrong.ghc9Used to inform error messages as to whether we are in a deriving clause or a standalone deriving declarationghc0The specs from which constraints will be createdghc? if this is standalone deriving with a user-supplied context,  if not. If it is the former, we relax some of the validity checks we would otherwise perform (i.e., "just go for it").ghcL  = allow higher rank arguments and empty data types (with no data constructors) even in the absence of the -XEmptyDataDeriving extension. Safe-InferredrghcLike #, but used only in the case of the stock deriving strategy. The constraints are inferred by inspecting the fields of each data constructor. In this example: 'data Foo = MkFoo Int Char deriving Show*We would infer the following constraints (s): (Show Int, Show Char)9Note that this function also returns the type variables (s) and class arguments (w>s) for the resulting instance. This is because when deriving *-like classes, we must sometimes perform kind substitutions to ensure the resulting instance is well kinded, which may affect the type variables and class arguments. In this example: newtype Compose (f :: k -> Type) (g :: Type -> k) (a :: Type) = Compose (f (g a)) deriving stock FunctorWe must unify k with Type in order for the resulting *+ instance to be well kinded, so we return []/ [Type, f, g] for the sws, not [k] [k, f, g]-. See Note [Inferring the instance context].ghcLike , but used only in the case of DeriveAnyClass, which gathers its constraints based on the type signatures of the class's methods instead of the types of the data constructor's field.See Note [Gathering and simplifying constraints for DeriveAnyClass] for an explanation of how these constraints are used to determine the derived instance context.ghcGiven instance (wanted) => C inst_ty , simplify wanted, as much as possible. Fail if not possible.ghc1Needed constraints (after simplification), i.e. []. Safe-Inferred%()*1ghcRebuild an application: takes a type-checked application head expression together with arguments in the form of typechecked s and returns a typechecked application of the head to the arguments.This performs a representation-polymorphism check to ensure that the remaining value arguments in an application have a fixed RuntimeRep.=See Note [Checking for representation-polymorphic built-ins].ghcThe worker function for : simply rebuilds an application chain in which arguments are specified as typechecked s.ghcTypecheck the remaining value arguments in a partial application, ensuring they have a fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.Example: >repPolyId :: forall r (a :: TYPE r). a -> a repPolyId = coerce$This is an invalid instantiation of coerce, as we can't eta expand it to 1\@r \@(a :: TYPE r) (x :: a) -> coerce @r @a @a xbecause the binder x. does not have a fixed runtime representation.ghc:Count visible and invisible value arguments in a list of  arguments.ghcCounts the number of invisible term-level arguments applied by an y7. Precondition: this wrapper contains no abstractions.ghcthe function being appliedghcthe arguments to the functionghcresult type of the applicationghcthe function being appliedghcthe arguments to the function22 Safe-Inferred%&/bghcType-check a MatchGroup.ghccheckArgCounts takes a [RenamedMatch] and decides whether the same number of args are used in each equation.ghc Case contextghcType of scrutineeghcThe case alternativesghc!Type of the whole case expressionghcExpected pattern types.ghc"Expected result-type of the Match. Safe-Inferred -9ghc'Arrow type constructor, of kind *->*->*ghc5Typechecking for case command alternatives. Used for Y.ghcTypechecking for Y and Y.ghc2Type-checked Arrow class methods (arr, (>>>), ...)ghcType of the scrutinee.ghccase alternatives Safe-Inferred )*1ghcArgumentghcType expected by the function Safe-Inferred 1ghc!Slightly more general version of  that allows the caller to specify the shape of the result of the syntax operatorghcTypecheck a syntax operator The operator is a variable or a lambda at this stage (i.e. renamer output)tghcDesugars a record update $record_expr { fld1 = e1, fld2 = e2 } into a case expression that matches on the constructors of the record r), as described in Note [Record Updates].Returns a renamed but not-yet-typechecked expression, together with the result type of this desugared record update.ghcPretty-print a collection of lines, adding commas at the end of each line, and adding "and" to the start of the last line.ghc=Checks if the given name is closed and emits an error if not.%See Note [Not-closed error messages].ghc"shape of syntax operator argumentsghcoverall result typeghcType check any arguments, takes a type per hole and a multiplicity per arrow in the shape.ghcArgument types. This function ensures they all have a fixed runtime representation.ghc/the operator to check (for error messages only)ghcshape it is expected to haveghccheck the argumentsghcreturns a wrapper :: (type of right shape) "->" (type passed in)ghc1the operator we are checking (for error messages)ghcargument shapesghc result shapeghccheck the argumentsghcreturns a wrapper to be applied to the original function, wrappers to be applied to arguments and a wrapper to be applied to the overall expressionghc record_expr2: expression to which the record update is appliedghcthe record update fieldsghc-the expected result type of the record updatewwwwwwwwwwwwww Safe-Inferred Safe-Inferred (ghcCheck that the type has the form (IO t) or (t) , and that t satisfies the given predicate. When calling this function, any newtype wrappers (should) have been already dealt with by normaliseFfiType.We also check that the Safe Haskell condition of FFI imports having results in the IO monad holds. Safe-Inferred Dghc%Stuff needed to process a datatype's  `deriving` clausesghcThe data tycon for normal datatypes, or the *representation* tycon for data familiesghc4Variables that scope over the deriving clause. See !Note [Scoped tyvars in a TcTyCon] in GHC.Core.TyCon.ghc error contextghc(Process the derived classes in a single deriving clause.ghc Process a single predicate in a deriving clause.This returns a @& because the user might try to derive Typeable, which is a no-op nowadays.ghc Generate the  for the required instance, plus any auxiliary bindings required (see Note [Auxiliary binders] in GHC.Tc.Deriv.Generate) and any additional free variables that should be marked (see +Note [Deriving and unused record selectors] in GHC.Tc.Deriv.Utils).ghcGenerate the associated type family instances for a derived instance.ghcIf , add a snippet about how not even GeneralizedNewtypeDeriving would make this declaration work. This only kicks in when an explicit deriving strategy is not given. Safe-Inferred (ghcGet the initial kind of a TyClDecl, either generalized or non-generalized, depending on the .ghcMaybe return a list of Bools that say whether a type family was declared injective in the corresponding type arguments. Length of the list is equal to the number of arguments (including implicit kind/coercion arguments). True on position N means that a function is injective in its Nth argument. False means it is not.ghcProduce an "expected kind" for the arguments of a data/newtype. If the declaration is indeed for a newtype, then this expected kind will be the kind provided. Otherwise, it is OpenKind for datatypes and liftedTypeKind. Why do we not check for -XUnliftedNewtypes? See point  ErrorMessages. in Note [Implementation of UnliftedNewtypes]ghcFrom information about a source datacon definition, extract out what the universal variables and the GADT equalities should be. See Note [mkGADTVars].ghcProduce an error for oversaturated type family equations with too many required arguments. See Note [Oversaturated type family equations] in GHC.Tc.Validity.ghc Just cls  =* this is an associated family of class clsghc Just cls  =* this is an associated family of class clsghcFamily TyCon (not knot-tied)ghcDefaultsghcType checked RHSghcThe tycon varsghcThe datacon varsghcThe matching between the template result type and the actual result typeghcThe univ. variables, the GADT equalities, and a subst to apply to the GADT equalities and existentials. Safe-Inferred ghcUse DerivInfo for data family instances (produced by tcInstDecls1), datatype declarations (TyClDecl), and standalone deriving declarations (DerivDecl) to check and process all derived class instances.  Safe-Inferred 9ghcThis is a value of type a with potentially a CoreExpr-shaped hole in it. This is used to deal with cases where we are potentially handling pattern match failure, and want to later specify how failure is handled.ghcWe represent the case where there is no hole without a function from , like this, because sometimes we have nothing to put in the hole and so want to be sure there is in fact no hole.ghcThe patterns for an equation NB: We have already applied decideBangHood3 to these patterns. See Note [decideBangHood] in GHC.HsToCore.Utilsghc-Was this equation present in the user source?=This helps us avoid warnings on patterns that GHC elaborated.For instance, the pattern  -1 :: Word gets desugared into W# -1## :: Word9, but we shouldn't warn about an overflowed literal for both of these cases.ghcWhat to do after matchghcRun a  action inside the ϝ monad.ghcRun a  action inside the D monad.ghc5Build a set of desugarer environments derived from a .ghcRun a & action in the context of an existing ghc0Get the current pattern match oracle state. See .ghcSet the pattern match oracle state within the scope of the given action. See .ghcEmit a diagnostic for the current source location. In case the diagnostic is a warning, the latter will be ignored and discarded if the relevant  is not set in the DynFlags. See Note [Discarding Messages] in .ghcIssue an error, but return the expression for (), so that we can continue reporting errors.ghcThe COMPLETE pragmas that are in scope.ghcInject a trace message into the compiled program. Whereas pprTrace prints out information *while compiling*, pprRuntimeTrace captures that information and causes it to be printed *at runtime* using Debug.Trace.trace.pprRuntimeTrace hdr doc expr*will produce an expression that looks liketrace (hdr + doc) exprWhen using this to debug a module that Debug.Trace depends on, it is necessary to import {-# SOURCE #-} Debug.Trace () in that module. We could avoid this inconvenience by wiring in Debug.Trace.trace, but that doesn't seem worth the effort and maintenance cost.ghcSee .ghcProduct is an "or" on fallibility---the combined match result is infallible only if the left and right argument match results both were.This is useful for combining a bunch of alternatives together and then getting the overall fallibility of the entire group. See  mkDataConCase for an example.ghcheaderghcinformation to outputghc expression4 !"ef4 !"ef Safe-InferredghcGenerate a fresh  of a given typeghc=All warning flags that need to run the pattern match checker.ghcCheck whether the redundancy checker should run (redundancy only)ghcCheck whether the exhaustiveness checker should run (exhaustiveness only)ghc6Check whether unnecessary bangs should be warned aboutghcDenotes whether an exhaustiveness check is supported, and if so, via which  it's controlled. Returns J if check is not supported.ghcCheck whether any part of pattern match checking is enabled for this X (does not matter whether it is the redundancy check or the exhaustiveness check).ghc4Return True when any of the pattern match warnings () are enabled, in which case we need to run the pattern match checker.   Safe-Inferred(3ghc)See Note [Case split inhabiting patterns]ghcA high-level pattern-match constraint. Corresponds to  from Figure 3 of the LYG paper.ghcA type constraint "T ~ U".ghc PhiCoreCt x e encodes "x ~ e", equating x with the  e.ghcPhiConCt x K tvs dicts ys encodes K @tvs dicts ys <- x , matching x against the  application K @tvs dicts ys , binding tvs, dicts and possibly unlifted fields ys in the process. See Note [Strict fields and variables of unlifted type].ghcPhiNotConCt x K! encodes "x D K", asserting that x can't be headed by K.ghc PhiBotCt x encodes "x ~ E", equating x to E. by K.ghcPhiNotBotCt x y! encodes "x D E", asserting that x can't be E.ghcThe return value of ghc was able to simplify the type with some local constraint from the type oracle, but M! couldn't identify a type redex.ghc5 may or may not been able to simplify the type, but M made progress either way and got rid of at least one outermost type or data family redex or newtype. The first field is the last type that was reduced solely through type family applications (possibly just the d type). This is the one that is equal (in source Haskell) to the initial type. The third field is the type that we get when also looking through data family applications and newtypes. This would be the representation type in Core (modulo casts). The second field is the list of Newtype #s that we looked through in the chain of reduction steps between the Source type and the Core type. We also keep the type of the DataCon application and its field, so that we don't have to reconstruct it in inhabitationCandidates and 1. For an example, see Note [Type normalisation].ghcAdd a bunch of  s to all the  s. Lifts  over many .ghcaddPmCtsNablas for a single PmCt.ghcTest if any of the s is inhabited. Currently this is pure, because we preserve the invariant that there are no uninhabited s. But that could change in the future, for example by implementing this function in terms of notNull  $ generateInhabitingPatterns 1 ds.ghcUpdate the COMPLETE sets of , or J4 if there was no change as per the update function.ghc A pseudo-^1 for the vanilla complete set of the given data . Ex.: vanillaCompleteMatchTC @ ==> Just (Maybe, {K,J})ghcInitialise from 1 (containing all COMPLETE pragmas) if the given  were empty.ghcAdds the declared ^ from COMPLETE pragmas, as well as the vanilla data defn if it is a #.ghcAdds * the ^% from COMPLETE pragmas * and the vanilla ^ from the data  to the , if not already present.ghcReturn the fields of 3. Returns appropriate defaults in the other cases.ghcGet rid of *outermost* (or toplevel) * type function redex * data family redex * newtypes Behaves like d, but instead of returning a coercion, it returns useful information for issuing pattern matching warnings. See Note [Type normalisation] for details. It also initially -s the type with the bag of local constraints.See % for the meaning of the return value.NB: Normalisation can potentially change kinds, if the head of the type is a type family with a variable result kind. I (Richard E) can't think of a way to cause trouble here, though.ghcReturns L if the argument  is a fully saturated application of a closed type constructor.Closed type constructors are those with a fixed right hand side, as opposed to e.g. associated types. These are of particular interest for pattern-match coverage checking, because GHC can exhaustively consider all possible forms that values of a closed type can take on.Note that this function is intended to be used to check types of value-level patterns, so as a consequence, the = supplied as an argument to this function should be of kind Type.ghcNormalise the given source type to WHNF. If it isn't already in WHNF () , it will normalise the type and then try to step through type family applications, but not data family applications or newtypes.(This is a pretty common case of calling  and it should be efficient.ghc Is the source type in WHNF wrt. ?Returns False if the given type is not a TyCon application, or if the TyCon app head is a type family TyCon. (But not for data family TyCons!)ghcThe fuel for the inhabitation test. See Note [Fuel for the inhabitation test].ghcAdds new constraints to  and returns J# if that leads to a contradiction.0In terms of the paper, this function models the E_3 function in Figure 7 on batches of  constraints.ghcAdds new type-level constraints by calling out to the type-checker via .ghc'Add some extra type constraints to the  ; return J# if we find a contradiction (e.g.  Int ~ Bool).See Note [Pattern match warnings with insoluble Givens] in GHC.Tc.Solver.ghcAllocates a fresh & name for PredTys.ghcAdds a single higher-level  constraint by dispatching to the various oracle functions.In terms of the paper, this function amounts to the constructor constraint case of E_ in Figure 7, which "desugars" higher-level  constraints into lower-level  constraints. We don't have a data type for  constraints and call the corresponding oracle function directly instead.Precondition: The  is not0 a type constraint! These should be handled by  before, through .ghcAdds the constraint x ~ E', e.g. that evaluation of a particular  x$ surely diverges. Quite similar to #, only that it only cares about E.ghcAdds the constraint x ~/ E to . Quite similar to *, but only cares for the E "constructor".ghc Record a x ~/ K$ constraint, e.g. that a particular  x can't take the shape of a  K in the  and return Nothing if that leads to a contradiction. See Note [TmState invariants].ghcAdd a x ~ K tvs args ts constraint. addConCt x K tvs args ts+ extends the substitution with a solution x :-> (K, tvs, args)? if compatible with the negative and positive info we have on x , reject (Nothing ) otherwise.See Note [TmState invariants].ghcAdds a x ~ y constraint by merging the two &s and record the gained knowledge in .Returns Nothing5 when there's a contradiction while merging. Returns  Just nabla when the constraint was compatible with prior facts, in which case nabla; has integrated the knowledge from the equality constraint.See Note [TmState invariants].ghc Inspects a PmCoreCt  let x = e by recording constraints for x based on the shape of the  e . Examples:For let x = Just (42, z)( we want to record the constraints $x ~ Just a, a ~ (b, c), b ~ 42, c ~ z . See  data_con_app.For let x = unpackCString# "tmp"/ we want to record the literal constraint  x ~ "tmp".For  let x = I# 42 we want the literal constraint x ~ 42'. Similar for other literals. See .Finally, if we have  let x = e and we already have seen  let y = e, we want to record x ~ y.ghcLike ', but with an effectful modifier actionghcFinds a representant of the semantic equality class of the given e. Which is the x of a  let x = e' constraint (with e semantically equivalent to e') we encountered earlier, or a fresh identifier if there weren't any such constraints.ghc Change out s which are uniquely determined by their type to a common value, so that different names for dictionaries of the same type are considered equal when building a ^.6See Note [Unique dictionaries in the TmOracle CoreMap]ghcMakes sure the given  is still inhabited, by trying to instantiate all dirty variables (or all variables when the 1 changed) to concrete inhabitants. It returns a  with the *same* inhabitants, but with some amount of work cached (like failed instantiation attempts) from the test.The  D E x inh, judgment form in Figure 8 of the LYG paper.ghcChecks whether the given . needs to be tested for inhabitants. Returns I when we can skip the inhabitation test, presuming it would say "yes" anyway. See Note [Shortcutting the inhabitation test].ghcReturns (Just vi) if at least one member of each ConLike in the COMPLETE set satisfies the oracle9Internally uses and updates the CompleteMatchs in vi_rcm. NB: Does not filter each CompleteMatch with the oracle; members may remain that do not satisfy it. This lazy approach just avoids doing unnecessary work.ghcThe E_{Bot} rule from the paperghcDoes a ' and then tries to look through a data family application to find the representation TyCon, to which the data constructors are attached. Returns the representation TyCon, the TyCon application args and a representational coercion that will be Refl for non-data family apps.ghcThis is the |-Inst rule from the paper (section 4.5). Tries to find an inhabitant in every complete set by instantiating with one their constructors. If there is any complete set where we can't find an inhabitant, the whole thing is uninhabited. It returns the updated  where all the attempted ConLike instantiations have been purged from the , which functions as a cache.ghc instCompleteSet fuel nabla x cls iterates over cls5 until it finds the first inhabited ConLike (as per ). Any failed instantiation attempts of a ConLike are recorded as negative information in the returned , so that later calls to this function can skip repeatedly fruitless instantiation of that same constructor.Note that the returned Nabla is just a different representation of the original Nabla, not a proper refinement! No positive information will be added, only negative information from failed instantiation attempts, entirely as an optimisation.ghcIs this # trivially inhabited, that is, without needing to perform any inhabitation testing because of strict/unlifted fields or type equalities? See Note [DataCons that are definitely inhabitable]ghc'All these types are trivially inhabitedghc"instCon fuel nabla (x::match_ty) K tries to instantiate x to K. by adding the proper constructor constraint.#See Note [Instantiating a ConLike].ghcmatchConLikeResTy _ _ ty K tries to match ty against the result type of K, res_ty. It returns a substitution s for K's universal tyvars such that  s(res_ty) equals ty if successful.Make sure that ty is normalised before.2See Note [Matching against a ConLike result type].ghc%generateInhabitingPatterns vs n nabla returns a list of at most n% (but perhaps empty) refinements of nabla that represent inhabited patterns. Negative information is only retained if literals are involved or for recursive GADTs. Safe-Inferred )*9ghc*Coverage checking action. Can be composed  or .ghc Composes s top-to-bottom: If a value falls through the resulting action, then it must fall through the first action and then through the second action. If a value matches the resulting action, then it either matches the first action or matches the second action. Basically the semantics of the LYG branching construct.ghc Composes s left-to-right: If a value falls through the resulting action, then it either falls through the first action or through the second action. If a value matches the resulting action, then it must match the first action and then match the second action. Basically the semantics of the LYG guard construct.ghcthrottle limit old new returns old if the number of s in new is exceeding the given limit and the old number of -s. See Note [Countering exponential blowup]. Safe-Inferred ghcUse -XStrict to add a ! or remove a ~ See Note [decideBangHood]ghc Scrutineeghc Type of expghc,Alternatives (bndrs *include* tyvars, dicts)ghcticks to add, possiblyghc The patternghc(Expression to which the pattern is boundghcId the rhs is bound to, for desugaring strict binds (see Note [Desugar Strict binds] in GHC.HsToCore.Binds) and all the desugared bindsghcOriginal pattern55 Safe-Inferred< Safe-Inferred Safe-Inferredghc(Desugaring of JavaScript foreign imports Safe-InferredOghc Foreign calls Safe-Inferred  Safe-Inferred  ghc'See Note [FractionalLit representation]ghcPost-typechecker, the   field of an G8 contains (an expression for) the literal value itself.ghcEmit warnings on overloaded integral literals which overflow the bounds implied by their type.ghcEmit warnings on integral literals which overflow the bounds implied by their type.ghcEmit warnings on integral literals which overflow the bounds implied by their type.ghc Warns about  [2,3 .. 1] or [b .. a] which return the empty list. For numeric literals, only works for integral types, not floating point.ghcSee if the expression is an ( literal.ghcIf (, extract the value and type of the overloaded literal. See Note [Literals and the OverloadedLists extension]ghcIf (;, extract the value and type of the non-overloaded literal.ghc5Extract the Char if the expression is a Char literal.ghcConvert a pair (Integer, Type) to (Integer, Name) after eventually normalising the typeghcConvert a pair (Integer, Type) to (Integer, Name) without normalising the typeghc'the literal value and name of its tyconghc!Type of the whole case expressionghc All PgLits   Safe-Inferredghc Guarded RHSsghc Type of RHSghcRefined pattern match checking models, one for the pattern part and one for each GRHS. Safe-Inferred %)* ghc.Smart constructor that eliminates trivial letsghcADT constructor pattern => no existentials, no local constraintsghcCreates a '[PmGrd]' refining a match var of list type to a list, where list fields are matched against the incoming tagged '[PmGrd]'s. For example: )mkListGrds "a" "[(x, True <- x),(y, !y)]" to 2"[(x:b) <- a, True <- x, (y:c) <- b, !y, [] <- c]" where b and c are freshly allocated in  mkListGrds and a is the match variable.ghc2Create a '[PmGrd]' refining a match variable to a .ghcdesugarPat _ x pat transforms pat into a '[PmGrd]', where the variable representing the match is x.ghc-, but also select and return a new match var.ghc-, but also select and return a new match var.ghc desugarListPat _ x [p1, ..., pn] is basically 6desugarConPatOut _ x $(mkListConPatOuts [p1, ..., pn]> without ever constructing the  ConPatOuts.ghcDesugar a constructor patternghcDesugar the non-empty Yes of a  .ghc.Desugar a guarded right-hand side to a single GrdTreeghc(Desugar a guard statement to a '[PmGrd]'ghc%Desugar local bindings to a bunch of ! guards. Deals only with simple let or where bindings without any polymorphism, recursion, pattern bindings etc. See Note [Long-distance information for HsLocalBinds].ghcDesugar a pattern guard pat  -e == let x = e; guards for pat <- xghcDesugar a boolean guard e ==> let x = e; True <- x Safe-Inferred )*6ghc7A datatype to accommodate the different call sites of . Used for extracting s from a concrete , through :. Since this is only possible for a couple of well-known ,s, this is a GADT.ghc TypeRep a   Safe-Inferred1' ghcConstruct the functions which will apply the relevant part of the QuoteWrapper to identifiers during desugaring.ghc+Represent result signature of a type familyghcRepresent result signature using a Maybe Kind. Used with data families, where the result signature can be either missing or a kind but never a named result variable.ghc1Represent injectivity annotation of a type familyghcIf a type implicitly quantifies its outermost type variables, return L if the list of implicitly bound type variables is empty. If a type explicitly quantifies its outermost type variables, always return L.This is used in various places to determine if a Template Haskell  should be headed by a ForallT or not.ghcIf a type explicitly quantifies its outermost type variables, return L if the list of explicitly bound type variables is empty. If a type implicitly quantifies its outermost type variables, always return L.This is used in various places to determine if a Template Haskell  should be headed by a ForallT or not.ghc Represent a type variable binderghc#Represent a type wrapped in a Maybeghc:Construct Core expression for Nothing of a given type nameghc5Construct Core expression for Nothing of a given typeghc:Store given Core expression in a Just of a given type nameghc5Store given Core expression in a Just of a given typeghcTrue for a  type data declaration. See Note [Type data declarations] in GHC.Rename.Moduleghc%Name of the TyCon of the element typeghcThe element typeghc%Name of the TyCon of the element typeghcThe element type Safe-Inferred'A Safe-Inferred #(+zghc matchSimply is a wrapper for  which deals with the situation where we want to match a single expression against a single pattern. It returns an expression.ghc'Use this pattern synonym to match on a U.2N.B.: View patterns can occur inside HsExpansions.ghc&The scrutinee the match id is bound toghc Scrutineeghc Match kindghcPattern it should matchghcReturn this if it matchesghcReturn this if it doesn'tghcFor shadowing warning messagesghc0Scrutinee(s) see Note [matchWrapper scrutinees]ghcMatches being desugaredghcResults (usually passed to )ghcVariables rep'ing the exprs we're matching with ^ See Note [Match Ids]^ Note that the Match Ids carry not only a name, but ^ also the multiplicity at which each column has been ^ type checked.ghcType of the case expressionghc.Info about patterns, etc. (type synonym below)ghcDesugared result! Safe-Inferred,0ghc'the desugared rhs of the bind statementghc S in (>>=) :: Q -> (R -> S) -> T Safe-Inferred -,r Safe-Inferred (2eghcReplace the body of the function with this block to test the hsExprType function in GHC.Tc.Utils.Zonk: putSrcSpanDs loc $ do { core_expr <- dsExpr e ; massertPpr (exprType core_expr H& hsExprType e) (ppr e  + dcolon  +6 ppr (hsExprType e) $$ ppr core_expr  + dcolon  +2 ppr (exprType core_expr)) ; return core_expr }ghc4The longest list length which we will desugar using build.This is essentially a magic number and its setting is unfortunate rather arbitrary. The idea here, as mentioned in Note [Desugaring explicit lists], is to avoid deforesting large static data into large(r) code. Ideally we'd want a smaller threshold with larger consumers and vice-versa, but we have no way of knowing what will be consuming our list in the desugaring impossible to set generally correctly.0The effect of reducing this number will be that build fusion is applied less often. From a runtime performance perspective, applying build more liberally on "moderately" sized lists should rarely hurt and will often it can only expose further optimization opportunities; if no fusion is possible it will eventually get rule-rewritten back to a list). We do, however, pay in compile time.ghcThis function desugars >: it eta-expands data constructors to make linear types work. b) where module B where import A -- ** module C where import A import BWhether or not we add or remove the import to A in B affects the orphan hash of B. But it shouldn't really affect the orphan hash of C. If we hashed only direct dependencies, there would be no way to tell that the net effect was a wash, and we'd be forced to recompile C and everything else.ghcCreates cached lookup for the  field of ModIface Hackily, we use "module" as the OccName for any module-level annotationsghc the reason we need to recompile.ghcThe old item, if it exists,, Safe-InferredCghcAre all implicit imports required to be safe for this Safe Haskell mode?ghcFind object files corresponding to the transitive closure of given home modules and direct object files for pkg dependencies Safe-InferredC^ Safe-InferredD0ghc`getCasts from_rep to_rep` gives us a list of primops which when applied in order convert from_rep to to_rep. See Note [PrimRep based casting] Safe-InferredJghcA mapping from binders to the Ids they were expanded/renamed to.x :-> MultiVal [a,b,c] in rhoiff x's typePrimRep is not a singleton, or equivalently x's type is an unboxed tuple, sum or void.x :-> UnaryVal x'iff x's RepType is UnaryRep or equivalently x's type is not unboxed tuple, sum or void.So x :-> MultiVal [a] in rho means x is represented by singleton tuple.*x :-> MultiVal [] in rho means x is void.INVARIANT: OutStgArgs in the range only have NvUnaryTypes (i.e. no unboxed tuples, sums or voids)ghcExtend the environment, checking the UnariseEnv invariant. The id is mapped to one or more things. See Note [UnariseEnv]ghcMake alternatives that match on the tag of a sum (i.e. generate LitAlts for the tag)ghc:Build a unboxed sum term from arguments of an alternative.3Example, for (# x | #) :: (# (# #) | Int #) we call0mkUbxSum (# _ | #) [ (# #), Int ] [ voidPrimId ] which returns  1#, rubbish ghc/Return a rubbish value for the given slot type.We use the following rubbish values: * Literals: 0 or 0.0 * Pointers: `ghc-prim:GHC.Prim.Panic.absentSumFieldError`(See Note [aBSENT_SUM_FIELD_ERROR_ID] in  GHC.Core.Makeghc:MultiVal a function argument. Never returns an empty list.ghcMultiVal a DataCon argument. Returns an empty list when argument is void. Safe-Inferred L ghcOptional Stg-to-Stg passes.ghc Common subexpression eliminationghcLambda lifting closure variables, trading stack/register allocation for heap allocationghcMandatory unarise pass, desugaring unboxed tuple and sum bindersghc$Mandatory when compiling to bytecodeghcUseful for building up  getStgToDoghcInformation to be exposed in interface files which is produced by the stg2stg passes.ghc$Spec of what stg-to-stg passes to doghc9Should we lint the STG at various stages of the pipeline?ghcextra vars in scope from GHCighcmodule being compiledghc input program Safe-InferredO|ghcFully instantiate an interface. Adds fingerprints and potentially code generator produced information.CmmCgInfos is not available when not generating code (-fno-code), or when not generating interface pragmas (-fomit-interface-pragmas). See also Note [Conveying CAF-info and LFInfo between modules] in GHC.StgToCmm.Types.ghcMake an interface from the results of typechecking only. Useful for non-optimising compilation, or where we aren't generating any object code at all ( NoBackend). Safe-InferredR}ghcPretty-prints a d8 (type/data family instance) with its defining location.ghcPretty-prints a  with its defining location.ghcPretty-prints the  header. For functions and data constructors the function is equivalent to  but for type constructors and classes it prints only the header part of the declaration.ghcPretty-prints a  in context: that is, if the entity is a data constructor, record selector, or class method, then the entity's parent declaration is pretty-printed with irrelevant parts omitted.ghcLike !, but adds the defining location.ghcPretty-prints a . Safe-Inferred`ghcCompares two things for equivalence between boot-file and normal code, reporting an error if they don't match up.ghc3How should we infer a type? See Note [TcRnExprMode]ghc-Instantiate inferred quantifiers only (:type)ghcInstantiate all quantifiers, and do eager defaulting (:type +d)ghc9A plan is an attempt to lift some code into the IO monad.ghc1Top level entry point for typechecker and renamerghcRuns TH finalizers and renames and typechecks the top-level declarations that they could introduce.ghcCompares the two things for equivalence between boot-file and normal code. Returns Nothing on success or !Just "some helpful info for user"; failure. If the difference will be apparent to the user,  Just empty is perfectly suitable.ghc%Combines two potential error messagesghc9If the test in the first parameter is True, succeed with Nothing'; otherwise, return the provided checkghcRun the check provided for every pair of elements in the lists. The provided SDoc should name the element type, in the plural.ghc9If the test in the first parameter is True, succeed with Nothing'; otherwise, fail with the given SDoc.ghcA more perspicuous name for Nothing, for  checkBootDecl and friends.ghcWarn on local definitions of names that would clash with future Prelude elements.A name clashes if the following criteria are met: 1. It would is imported (unqualified) from Prelude 2. It is locally defined in the current module 3. It has the same literal name as the reference function 4. It is not identical to the reference functionghcGet the unqualified name of the function to use as the "main" for the main module. Either returns the default name or the one configured on the command line with -main-isghcThe returned [Id] is the list of new Ids bound by this statement. It can be used to extend the InteractiveContext via extendInteractiveContext.The returned TypecheckedHsExpr is of type IO [ () ], a list of the bound values, coerced to ().ghcTry the plans in order. If one fails (by raising an exn), try the next. If one succeeds, take it.ghcTypecheck (and lift4) a stmt entered by the user in GHCi into the GHCi  environment.By lift and 'environment we mean that the code is changed to execute properly in an IO monad. See Note [Interactively-bound Ids in GHCi] in GHC.Driver.Env for more details. We do this lifting by trying different ways (plans) of lifting the code into the IO monad and type checking each plan until one succeeds.ghcTypecheck the statements given and then return the results of the statement in the form 'IO [()]'.ghcGenerate a typed ghciStepIO expression (ghciStep :: Ty a -> IO a)ghc:tcRnExpr just finds the type of an expression for :typeghc)ASSUMES that the module is either in the HomePackageTable or is a package module with an interface on disk. If neither of these is true, then the result will be an error indicating the interface could not be found.ghc8Find all the Names that this RdrName could mean, in GHCighc!Dump, with a banner, if -ddump-rnghc.Extract the renamed information from TcGblEnv.ghcTrue  =& an hs-boot file (could also be a sig)ghcInstances of this ...ghc should also be instances of this##0 Safe-Inferred aghc"Main entry point to the desugarer. Safe-Inferred")*/17hughcUsed to collect type infoghcThe main worker class See Note [Updating HieAst for changes in the GHC AST] for more information on how to add/modify instances for this.ghcconveniently calculate locations for things without locations attachedghcFirst scope remains constant Second scope is used to build up the scope of a tyvar over things to its right, ala RScopedghc Pattern scopeghcScope spans over everything to the right of a, (mostly) not including a itself (Includes a in a few special cases like recursive do bindings) or let/where bindingsghccontext for type signaturesghc#context for pattern synonym fields.ghccontext for imports/exportsghccontext for imports/exportsghccontext for record fieldsghc Construct an % from the outputs of the typechecker.ghc Construct an  from the outputs of the typechecker but don't read the source file again from disk.ghc2Each element scopes over the elements to the rightghc specialised to  thingsghc specialised to Tghc specialised to  thingsghc!This instance tries to construct  nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.7See Note [Computing the type of every node in the tree]ghcuse site of the patternghc*pattern to the right of a, not including a Safe-Inferredipghc4Initialize STG pretty-printing options from DynFlagsghc;Which Stg-to-Stg passes to run. Depends on flags, ways etc.ghcAre we preparing for bytecode? Safe-Inferred ')*'ghc/Initialize HscEnv from an optional top_dir pathghcThe binutils linker on ARM emits unnecessary R_ARM_COPY relocations which breaks tables-next-to-code in dynamically linked modules. This check should be more selective but there is currently no released version where this bug is fixed. See  5https://sourceware.org/bugzilla/show_bug.cgi?id=16177 and 9https://gitlab.haskell.org/ghc/ghc/issues/4210#note_78333ghclog warning in the monad, and if there are errors then throw a SourceError exception.ghcLog warnings and throw errors, assuming the messages contain at least one error (e.g. coming from PFailed)ghcSet module to unsafe and (potentially) wipe trust information.Make sure to call this method to set a module to inferred unsafe, it should be a central and single failure method. We only wipe the trust information when we aren't in a specific Safe Haskell mode.While we only use this for recording that a module was inferred unsafe, we may call it on modules using Trustworthy or Unsafe flags so as to allow warning flags for safety to function correctly. See Note [Safe Haskell Inference].ghc.Figure out the final correct safe haskell modeghcRun Core2Core simplifier. The list of String is a list of (Core) plugin module names added via TH (cf  addCorePlugin).ghcRun Core2Core simplifier. The list of String is a list of (Core) plugin module names added via TH (cf  addCorePlugin).ghcGenerate a stripped down interface file, e.g. for boot files or when ghci generates interface files. See Note [simpleTidyPgm - mkBootModDetailsTc]ghcCompile to hard-code.ghc9Compile a stmt all the way to an HValue, but don't run itWe return Nothing to indicate an empty statement (or comment only), not a parse error.ghc9Compile a stmt all the way to an HValue, but don't run itWe return Nothing to indicate an empty statement (or comment only), not a parse error.ghcCompile a declsghcCompile a declsghcLoad the given static-pointer table entries into the interpreter. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.ghc*Typecheck an expression (but don't run it)ghc-Find the kind of a type, after generalisation ghcKeep renamed source?ghcIs this a simple interface generated after the core pipeline, or one with information from the backend? See: Note [Writing interface files]ghcThe old interface hash, used to decide if we need to actually write the new interface.ghcJust f  = _stub.c is fghc(Bindings come already annotated with fvsghc The statementghc The sourceghc Starting lineghcThe parsed statementghc The statementghc The statementghc The sourceghc Starting lineghcThe expressionghcNormalise the typeghcThe type as a stringghc-Resulting type (possibly normalised) and kind Safe-Inferred')*3Tghc(Releases the external interpreter state.ghc*A type variable with kind * -> * named "m"ghc For a type m , emit the constraint 'Quote m'.ghcCompute the expected type of a quotation, and also the QuoteWrapper in the case where it is an overloaded quotation. All quotation forms are overloaded aprt from Variable quotations ('foo)ghc4Typechecking a pending splice from a untyped bracketghcForce the contents of the Serialized value so weknow it doesn't contain any bottomsghcLooks up documentation for a declaration in first the current module, otherwise tries to find it in another module via .ghcLike , looks up documentation for a function argument. If it can't find any documentation for a function in this module, it tries to find it in another module.ghc;Returns the module a Name belongs to, if it is isn't local.ghcFind the GHC name of the first instance that matches the TH typeghc8Adds a mod finalizer reference to the local environment.ghccommunicate with a remotely-running TH computation until it finishes. See Note [Remote Template Haskell] in librariesghci GHCi/TH.hs.ghc+Read a value of type QResult from the iservghcRetrieve (or create, if it hasn't been created already), the remote TH state. The TH state is a remote reference to an IORef QState living on the server, and we have to pass this to each RunTH call we make.>The TH state is stored in tcg_th_remote_state in the TcGblEnv.ghcWe only want to produce warnings for TH-splices if the user requests so. See Note [Warnings for TH splices].ghcAnnotate (with TH.SigT) a type if the first parameter is True and if the type contains a free variable. This is used to annotate type patterns for poly-kinded tyvars in reifying class and type instances. See 5Note [Reified instances and explicit kind signatures].ghcFor every argument type that a type constructor accepts, report whether or not the argument is poly-kinded. This is used to eventually feed into . See 5Note [Reified instances and explicit kind signatures].ghcReturns M in the case that the instances were found to be class instances, or N if they are family instances. Safe-Inferred %&LghcFailure modes for .ghc& returned J.ghcThe module was loaded without -haddock,ghcThe  was defined interactively.ghc,Finds the enclosing top level function name ghc=Update fixity environment in the current interactive context.ghcdefault ExecOptionsghc3Run a statement in the current interactive context.ghcLike , but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).ghcRun some declarations and return any user-visible names that were brought into scope.ghcLike , but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).ghc'Set the interactive evaluation context.(setContext imports) sets the ic_imports field (which in turn determines what is in scope at the prompt) to imports9, and updates the icReaderEnv environment to reflect it.We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)ghcGet the interactive evaluation context, consisting of a pair of the set of modules from which we take the full top-level scope, and the set of modules from which we take just the exports respectively.ghcReturns True if the specified module is interpreted, and hence has its full top-level scope available.ghcLooks up an identifier in the current interactive context (for :info) Filter the instances by the ones whose tycons (or classes resp) are in scope (qualified or otherwise). Otherwise we list a whole lot too many! The exact choice of which ones to show, and which to hide, is a judgement call. (see #1581)ghc=Returns all names in scope in the current interactive contextghc Returns all +s in scope in the current interactive context, excluding any that are internally-generated.ghc:Parses a string as an identifier, and returns the list of s that the identifier can refer to in the current interactive context.ghcGet the type of an expression Returns the type as described by ghcGet the kind of a typeghcParse an expression, the parsed expression can be further processed and passed to compileParsedExpr.ghcCompile an expression, run it, and deliver the resulting HValue.ghcCompile an expression, run it, and deliver the resulting HValue.ghcCompile a parsed expression (before renaming), run it, and deliver the resulting HValue.ghcCompile an expression, run it and return the result as a Dynamic.ghcL: The module was compiled. I: The module was :loaded.ghc a statement (bind or expression)cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc Safe-Inferred')* ghcThe default mechanism to run a pipeline, see Note [The Pipeline Monad]ghc5Default interpretation of each phase, in terms of IO.ghc!Run the JS Backend postHsc phase.ghc5Deal with foreign JS files (embed them into .o files)ghcCalculate the ModLocation from the provided DynFlags. This function is only used in one-shot mode and therefore takes into account the effect of -o/-ohi flags (which do nothing in --make mode)ghcComputes the next output filename for something in the compilation pipeline. This is controlled by several variables: >!: the last phase to be run (e.g.  stopPhase). This is used to tell if we're in the last phase or not, because in that case flags like -o may be important.P: is this intended to be a P or P build output? Temporary files just go in a fresh temporary name.:3: what was the basename of the original input file?t: the obvious thing>8: the phase we want to determine the output filename of.Maybe ModLocation: the  of the module we're compiling; this can be used to override the default output of an object file. (TODO: do we actually need this?)ghcLLVM Options. These are flags to be passed to opt and llc, to ensure consistency we list them in pairs, so that they form groups.ghcWhat phase to run after one of the backend code generators has runghcSee Note [Object merging].ghcThe next phaseghc8A ModLocation, if we are compiling a Haskell source fileghcpairs of (opt, llc) arguments!! Safe-Inferred'(/ghcJust preprocess a file, put the result in a temp. file (used by the compilation manager during the summary phase).We return the augmented DynFlags, because they contain the result of slurping in the OPTIONS pragmasghcCompileCompile a single module, under the control of the compilation manager.This is the interface between the compilation manager and the compiler proper (hsc), where we deal with tedious details like reading the OPTIONS pragma from the source file, converting the C or assembly that GHC produces into an object file, and compiling FFI stub files.NB. No old interface can also mean that the source has changed.ghcCheck if the start is *before* the current phase, otherwise skip with a defaultghcThe preprocessor pipelineghc7The complete compilation pipeline, from start to finishghcEverything after preprocessghcinput filenameghc8optional buffer to use instead of reading the input fileghcstarting phaseghc!summary for module being compiledghc module N ...ghc... of Mghcold interface, if we have oneghcold linkable, if we have oneghc'the complete HomeModInfo, if successfulghc!summary for module being compiledghc module N ...ghc... of Mghcold interface, if we have oneghc'the complete HomeModInfo, if successfulghcinteractive or batchghcLoggerghc dynamic flagsghcunit environmentghcattempt linking in batch mode?ghc what to linkghc dynamic flagsghcunit environmentghcattempt linking in batch mode?ghc what to link<PPPPPPPPPPP<PPPPPPPPPPP Safe-Inferred%&')*469:;'ghc Convenience named arguments for 5 only used to make code more readable, not exported.ghc(Environment used when compiling a moduleghcAbstraction over the operations of a semaphore which allows usage with the -j1 caseghc;Simple wrapper around MVar which allows a functor instance.ghcA  is the result of attempting to linearise a single strongly-connected component of the module graph.ghcA simple, single module all alone (which *might* have an hs-boot file, if it isn't part of a cycle)ghc-A resolved cycle, linearised by hs-boot filesghc7An actual cycle, which wasn't resolved by hs-boot filesghcA ModuleGraphNode which also has a hs-boot file, and the list of nodes on any path from module to its boot file.ghc>Describes which modules of the module graph need to be loaded.ghc&Load all targets and its dependencies.ghc0Load only the given module and its dependencies.ghcLoad only the dependencies of the given module, but not the module itself.ghcPerform a dependency analysis starting from the current targets and update the session with the new module graph.(Dependency analysis entails parsing the import directives and may therefore require running certain preprocessors.Note that each ΍ in the module graph caches its t . These t are determined by the current session t and the OPTIONS and LANGUAGE pragmas of the parsed module. Thus if you want changes to the t to take effect you need to call this function again. In case of errors, just throw them.ghc$Perform dependency analysis like in . In case of errors, the errors and an empty module graph are returned.ghc!Perform dependency analysis like  but return a partial module graph even in the face of problems with some modules.Modules which have parse errors in the module header, failing preprocessors or other issues preventing them from being summarised will simply be absent from the returned module graph.Unlike  this function will not update  with the new module graph.ghc5Collect the instantiations of dependencies to create  work graph nodes. These are used to represent the type checking that is done after all the free holes (sigs in current package) relevant to that instantiation are compiled. This is necessary to catch some instantiation errors.In the future, perhaps more of the work of instantiation could be moved here, instead of shoved in with the module compilation nodes. That could simplify backpack, and maybe hs-boot too.ghcTry to load the program. See  for the different modes.+This function implements the core of GHC's --make mode. It preprocesses, compiles and loads the specified modules, avoiding re-compilation wherever possible. Depending on the backend (see  field) compiling and loading may result in files being created on disk. Calls the > after each compiling each module, whether successful or not.If errors are encountered during dependency analysis, the module  returns together with the errors an empty ModuleGraph. After processing this empty ModuleGraph, the errors of depanalE are thrown. All other errors are reported using the .ghcGeneralized version of  which also supports a custom  (for reporting progress) and ! (generally produced by calling .ghcFinish up after a load.ghcIf there is no -o option, guess the name of target executable by using top-level source file name as a base.ghcPrune the HomePackageTable+Before doing an upsweep, we can throw away:all ModDetails, all linked codeall unlinked code that is out of date with respect to the source fileThis is VERY IMPORTANT otherwise we'll end up requiring 2x the space at the end of the upsweep, because the topmost ModDetails of the old HPT holds on to the entire type environment from the previous compilation. Note [GHC Heap Invariants]ghc Unloadingghc Block until the result is ready.ghcGiven the build plan, creates a graph which indicates where each NodeKey should get its direct dependencies from. This might not be the corresponding build action if the module participates in a loop. This step also labels each node with a number for the output. See Note [Upsweep] for a high-level description.ghcCompile a single module. Always produce a Linkable for it if successful. If no compilation happened, return the old Linkable.ghcAdd the entries from a BCO linkable to the SPT table, see See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.ghc$Topological sort of the module graphCalculate SCCs of the module graph, possibly dropping the hi-boot nodes The resulting list of strongly-connected-components is in topologically sorted order, starting with the module(s) at the bottom of the dependency graph (ie compile them first) and ending with the ones at the top.'Drop hi-boot nodes (first boolean arg)?False: treat the hi-boot summaries as nodes of the graph, so the graph must be acyclicTrue: eliminate the hi-boot nodes, and instead pretend the a source-import of Foo is an import of Foo The resulting graph has no hi-boot nodes, but can be cyclicghcIf there are {-# SOURCE #-} imports between strongly connected components in the topological sort, then those imports can definitely be replaced by ordinary non-SOURCE imports: if SOURCE were necessary, then the edge would be part of a cycle.ghcDownsweep (dependency analysis)Chase downwards from the specified root set, returning summaries for all home modules encountered. Only follow source-import links.We pass in the previous collection of summaries, which is used as a cache to avoid recalculating a module summary if the source is unchanged.The returned list of [ModSummary] nodes has one node for each home-package module, plus one for any hs-boot files. The imports of these nodes are all there, including the imports of non-home-package modules.ghcUpdate the every ModSummary that is depended on by a module that needs template haskell. We enable codegen to the specified target, disable optimization and change the .hi and .o file locations to be temporary files. See Note [-fno-code mode]ghcHelper used to implement . In particular, this enables unoptimized code generation for all modules that meet some condition (first parameter), or are dependencies of those modules. The second parameter is a condition to check before marking modules for code generation.ghc3Populate the Downsweep cache with the root modules.ghc.Wrap an action to catch and handle exceptions.ghcWait for some dependencies to finish and then read from the given MVar.ghc?Wait for dependencies to finish, and then return their results.ghcBuild and run a pipelineghc;Run the given actions and then wait for them all to finish.ghcExecute each action in order, limiting the amount of parallelism by the given semaphore. ghc*The module itself (not the hs-boot module)ghcThe modules in between the module and its hs-boot file, not including the hs-boot file itself.ghcexcluded modulesghcallow duplicate rootsghcexcluded modulesghcallow duplicate rootsghcexcluded modulesghcallow duplicate rootsghcpossibly empty Bag of errors and a module graph.ghc0The number of workers we wish to run in parallelghc3The base HscEnv, which is augmented for each moduleghc7A cache to incrementally write final interface files toghcDrop hi-boot nodes? (see below)ghcRoot module name. If Nothing, use the full graph.ghc Old summariesghcMap of old summariesghc1optional source code buffer and modification timeghc)The HPT in this HscEnv needs rehydrating.ghc+These are the modules we want to rehydrate.ghcHow many capabilities to useghcThe basic HscEnv which is augmented with specific info for each moduleghc2Optional custom messager to use to report progressghc'The build plan for all the module nodes6  6   Safe-Inferred '(=ghc?An error thrown if the GHC API is used in an incorrect fashion.ghc"Container for information about a  .ghc.A CoreModule consists of just the fields of a  that are needed for the  interface.ghc Module nameghc2Type environment for types declared in this moduleghc DeclarationsghcSafe Haskell modeghcThe result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.ghcThe result of successful typechecking. It also contains the parser result.ghc!The result of successful parsing.ghcInstall some default exception handlers and run the inner computation. Unless you want to handle exceptions yourself, you should wrap this around the top level of your program. The default handlers output the error message(s) to stderr and exit cleanly.ghcThis function is no longer necessary, cleanup is now done by runGhc/runGhcT.ghcRun function for the  monad.0It initialises the GHC session and warnings via . Each call to this function will create a new session which should not be shared among several threads."Any errors not handled inside the ) action are propagated as IO exceptions.ghcRun function for  monad transformer.0It initialises the GHC session and warnings via . Each call to this function will create a new session which should not be shared among several threads.ghcInitialise a GHC session.If you implement a custom  you must call this function in the monad run function. It will initialise the session variable and clear all warnings.The first argument should point to the directory where GHC's library files reside. More precisely, this should be the output of ghc --print-libdir of the version of GHC the module using this API is compiled with. For portability, you should use the  ghc-paths package, available at  ,http://hackage.haskell.org/package/ghc-paths.ghcSets the program t. Note: this invalidates the internal cached module graph, causing more work to be done the next time  is called.Returns a boolean indicating if preload units have changed and need to be reloaded.ghcReturns the program t.ghcSet the t used to evaluate interactive expressions. Also initialise (load) plugins.9Note: this cannot be used for changes to packages. Use , or  and then copy the  unitState into the interactive DynFlags.ghcGet the t* used to evaluate interactive expressions.ghcParse command line arguments that look like files. First normalises its arguments and then splits them into source files and object files. A source file can be turned into a } via ghcSplitting arguments into source files and object files. This is where we interpret the -x  suffix option, and attach a (Maybe Phase) to each source file indicating the phase specified by the -x option in force, if any.ghcTo simplify the handling of filepaths, we normalise all filepaths right away. Note the asymmetry of FilePath.normalise: Linux: p/q -> p/q; p\q -> p\q Windows: p/q -> p\q; p\q -> p\q #12674: Filenames starting with a hyphen get normalised from ./-foo.hs to -foo.hs. We have to re-prepend the current directory.ghcChecks the set of new DynFlags for possibly erroneous option combinations when invoking  and friends, and if found, returns a fixed copy (if possible).ghcSets the targets for this session. Each target may be a module name or a filename. The targets correspond to the set of root modules for the program/library. Unloading the current program is achieved by setting the current set of targets to be empty, followed by .ghc"Returns the current set of targetsghcAdd another target.ghcRemove a targetghcAttempts to guess what Target a string refers to. This function implements the --make(/GHCi command-line syntax for filenames:if the string looks like a Haskell source filename, then interpret it as suchif adding a .hs or .lhs suffix yields the name of an existing file, then use that/otherwise interpret the string as a module nameghcUnwrap   or retrieve the   of the current .ghcInform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).ghc Return the ΍! of a module with the given name.1The module must be part of the module graph (see  and 9). If this is not the case, this function will throw a .This function ignores boot modules and requires that there is only one non-boot module with the given name.ghcParse a module. Throws a  on parse error.ghc%Typecheck and rename a parsed module. Throws a  if either fails.ghcDesugar a typechecked module.ghcThis is the way to get access to the Core bindings corresponding to a module.  compileToCore parses, typechecks, and desugars the module, then returns the resulting Core module (consisting of the module name, type declarations, and function declarations) if successful.ghcLike compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.ghc Get the module dependency graph.ghcReturn True <==> module is loaded.ghc8Return the bindings for the current interactive session.ghc9Return the instances for the current interactive session.ghc#Request information about a loaded  ghc2The list of top-level entities defined in a moduleghcReturns the instances defined by the specified module. Warning: currently unimplemented for package modules.ghc!Retrieve module safe haskell modeghcLooks up a global name: that is, any top-level name in any visible module. Unlike , lookupGlobalName does not use the interactive context, and therefore does not require a preceding .ghc"get the GlobalRdrEnv for a sessionghcRetrieve all type and family instances in the environment, indexed by . Each name's lists will contain every instance in which that name is mentioned in the instance head.ghcprint a 0, adding parentheses if the name is an operator.ghc9Return module source as token stream, including comments.A   can be turned into a ΍ using 2 if your session is fully initialised. Throws a  on parse error.ghc.Give even more information on the source than  This function allows reconstructing the source completely with .ghcGiven a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.ghc/Take a rich token stream such as produced from  and return source code almost identical to the original code (except for insignificant whitespace.)ghcTakes a   and possibly a  , and consults the filesystem and package database to find the corresponding  +, using the algorithm that is used for an import declaration.ghcLike , but differs slightly when the module refers to a source file, and the file has not been loaded via . In this case, / will throw an error (module not loaded), but  will check to see whether the module can also be found in a package, and if so, that package   will be returned. If not, the usual module-not-found error will be thrown.ghcCheck that a module is safe to import (according to Safe Haskell).We return True to indicate the import is safe and False otherwise although in the False case an error may be thrown first.ghcReturn if a module is trusted and the pkgs it depends on to be trusted.ghc.Set the monad GHCi lifts user statements into.;Checks that a type (in string form) is an instance of the GHC.GHCi.GHCiSandboxIO type class. Sets it to be the GHCi monad if it is, throws an error otherwise.ghc.Get the monad GHCi lifts user statements into.ghc Returns the  for a . The 2 may refer to any entity known to GHC, including s defined using runStmt.ghc&A pure interface to the module parser.ghc,Find the package environment (if one exists)We interpret the package environment as a set of package flags; to be specific, if we find a package environment file like clear-package-db global-package-db package-db blah/package.conf.d package-id id1 package-id id2we interpret this as [ -hide-all-packages , -clear-package-db , -global-package-db , -package-db blah/package.conf.d , -package-id id1 , -package-id id2 ]There's also an older syntax alias for package-id, which is just an unadorned package id id1 id2ghcSee argument to .ghcThe action to perform.ghcSee argument to .ghcThe action to perform.ghcvisible modules. An orphan instance will be returned if it is visible from at least one module in the list.ghcmodules to load. If this is not specified, we load modules for everything that is in scope unqualified.ghc6Haskell module source text (full Unicode is supported)ghc the flagsghc#the filename (for source locations)OtttttuutttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuNNNNPvPPPPPtttttttttttNNOO}}}}}}}}}> !! ΍ύЍэҍӍԍՍ֍׍؍ٍڍۍ܍ݍލ؋ًڋۋ܋݋ދߋ cccccccccccccccccccccccccccccccccqqqqqqqqq  &&&+++```'''``````a`AAABBAAAAAAABBBC###SSSSSSSS@@@@@@z{{{dGGLLLLaaaaYYYYYYY UUUUUUUUUUUUUUUUUUUUYTWWWVVVVWWWVVVVVWWWWW////,-------,,,----------------------------------------------------------------------------------------------,,,,SSSSSS,VVVVVVVVVV/ ZZZZZZZZ ////XXXXXXXXXXXXXXXXXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWVVVVVVVVVVVVWWWWVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWVVVVVVVVVVUVVVVVVVVVUUUUUUUUUUUUWWWWWWWWWWWXXXXXX/////////////////////////////UUUUU//UUU~~UUUUUUUUUUUUUUU~~~~~~~~~~~~~~UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU YYYZYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZ ~~~~~~~U~~~~~~~~TTUTTTTTTTTTTTTTTTTTTZZZZZSSTTTTSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTsTTTTTTTTTTTsTTTTTTTTTTTTTTTTTTTTTTTTTTTTTssssTTTTTTTTTSSSTTTTTTTTTSSSSSsTSSSSSSSSSSSSSSSSSSSSSSSځ܁ہ݁ށ߁,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+,,,,,,,,YYY 0 YYYY YYYYYUWWW XXX0GGGGGHHHHHHHHHH /YYYYYYYYYYYYZXXXXXXXXXXXXXXXXXXXXXXXXXZ߀ـڀۀ܀݀ހU 0000000000/////00000000000YYYUGGGGGXXYXYXYYYYYYYYYYYYYYYYYYYY YYY/////0000000//009999999999999GGGGUUUUUUUUUUZZZYYYYYZZZZYYYYYXXXXXXYYXXXXXYYYYYYYYYYYYYYYYYYYXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX~~~~~~~~~~~~~~~~~~~~~~׀؀рҀӀԀՀր̀̀΀πЀȀɀʀˀ€ÀĀŀƀǀ~. ZZZUXXXXXXXXXXXXXXXXXZ/////UUUUZTTssssssTssssssTssssssssssTssssssssssTsTssssssssssssssssssssssssssssTsssssssssssׂւłĂƂǂȂ͂˂̂ɂʂ΂тЂՂς҂ӂԂ‚؂قڂ܂߂ۂނ݂-------.-...-------------------.................................. XX /////999999999999HUUUUUUUUUZZZZZZZZZZ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~OtttttuutttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuNNNNPvPPPPPtttttttttttNNOO}}}}}}}}}> !! ΍ύЍэҍӍԍՍ֍׍؍ٍڍۍ܍ݍލ؋ًڋۋ܋݋ދߋ cccccccccccccccccccccccccccccccccqqqqqqqqq  &&&+++```'''``````a`ABABAAAAAAABBBAC###SSSSSSSS@@@@@@z{{{dGGLLLLaaaa,-------,,,----------------------------------------------------------------------------------------------,,,, Safe-InferredghcThe :print & friends commandsghcGive names, and bind in the interactive environment, to all the suspensions included (inductively) in a term Safe-Inferred Safe-Inferred ",rghc&Backpack environment. NB: this has a  and not an &, because we are going to update the  as we go.ghc The sessionghc,The filename of the bkp file we're compilingghc2Table of source units which we know how to compileghcWhen a package we are compiling includes another package which has not been compiled, we bump the level and compile that.ghcBackpack monad is a 7 which also maintains a little extra state beyond the , c.f. .ghc9Tiny enum for all types of Backpack operations we may do.ghcA compilation operation which will result in a runnable executable being produced.ghcA type-checking operation which produces only interface files, no object files.ghcA compilation operation which produces both interface files and object files.ghc'Entry point to compile a Backpack file.ghcCreate a temporary Session to do some sort of type checking or compilation.ghcCompute the dependencies with instantiations of a syntactic HsUnit; e.g., wherever you see dependency p[A= A] in a unit file, return the   corresponding to p[A= A]. The  include_sigs4 parameter controls whether or not we also include dependency signature" declarations in this calculation.%Invariant: this NEVER returns UnitId.ghc=Register a new virtual unit database containing a single unitghcGet the current .ghc:Get the nesting level, when recursively compiling modules.ghcRun a 0 computation, with the nesting level bumped one.ghcUpdate the EPS from a (. TODO move to appropriate library spot.ghcGet the EPS from a .ghcRun  in .ghcPrint a compilation progress message, but with indentation according to level (for nested compilation).ghc Creates a ? for Backpack compilation; this is basically a carbon copy of  but calling , which handles indentation.ghc  for Backpack messages; here we usually want the module to be qualified (so we can tell how it was instantiated.) But we try not to qualify packages so we can use simple names for them.ghc2Message when we initially process a Backpack unit.ghc,Message when we instantiate a Backpack unit.ghc(Message when we include a Backpack unit.ghcThis is our version of GHC.Driver.Make.downsweep, but with a few modifications: Every module is required to be mentioned, so we don't do any funny business with targets or recursively grabbing dependencies. (We could support this in principle).We support inline modules, whose summary we have to synthesize ourself.We don't bother trying to support GHC.Driver.Make for now, it's more trouble than it's worth for inline modules.ghcUp until now, GHC has assumed a single compilation target per source file. Backpack files with inline modules break this model, since a single file may generate multiple output files. How do we decide to name these files? Should there only be one output file? This function our current heuristic, which is we make a "fake" module and use that.ghc>Create a new, externally provided hashed unit id from a hash.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""#################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%&&&&&&'''''''''(((((()))))))***************************************************************************************************************************************************************************************************************************************************************************************************************************************************+++++++++++++++++++++++++++++++++,,,,,,-.........//000000111111111111111111111111111222222223333333333444444455567777777888;;;;;;;;;;;;;;;;;;====== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????@@@@@    AAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFGGGGGGGGHIIIIIIIJJJJJJJJJKKKKKKKKKKKKKLLLLLLLLLMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOO OOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQRRRRRRRRRRRRSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVV VVVVVVVWWWWWWWWWWXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_________________`````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee e e fff f f f f f f f f f f fffg g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g!g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#h#h#h#h#h#h#h#i#i#i#i#i#i#i#i#i#j#j#j#j#j#j#j#j#j#k#k#k#k#k#k#k#k#l#l#l#l#l#l#l#l#l#l#l#l#l#l#l#l#l#l#l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$)$)$)$)$)$)$)$)$)$)$))$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$))$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)$)%)%)%)%)%)%)%)%)%)%)%)%)%m%m%m%m%m%m%m%m%m%m%m%m%m%m%m%m%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%n%o%o%o%o%o%o%o%o%o%o%o%o%o%o%p%p%ppp%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&p&q&q&q&q&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&r&s&s&s&s&s&s&s&s&s&s&s&s&s&t&t&t&t&t&t&t&t&t&t&t&t&u&u&u&u&v&v&v&v&v&v&v&v&v&v&v&v&w&w&x&x&x&x&x&x&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)y)z)z)z)z)z)z)z)z)z)z)z)z)z)z)z)z)z)z){){){){){){){){){){){){){){){){){){){){){){){){){){){){){){){){){){){*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*{*y*y*y*y*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(*(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+(+|+|+|+|+|+|+|+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,~,~,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3-3-3*3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3.3.3.3.3.3.3.3.3.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:..................................................................................................../////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////000000000000000000000000000000000000000000000000.0...0000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333344444444,4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC C C C C C C C C C C C C C C C C C C C D D D D D D D D'DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9E9EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE7E7E7E7E7E7E7E7E7E7E7E7E7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7&7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F77F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7-7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7G7GGGGGGGG;;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;H;HHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK:K:K:K:K:K:K:K:K:K::K:K:K:K:K:K:K:K:K:K:K:K:K:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L::L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:L:M:M:M:M:M:M:M:M:M:MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&M&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOO<O<O<O<O<O<O<O<O<O<O<O<O<OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q=Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9Q9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9R9RRRRRRRRRRRR2RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWPWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWzWzWzWzWzWzWzWzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXzXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwYwZwZwZwZwZwZwZwZwZwZwZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ5ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[,[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\EE\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\x\x\x\x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]xx]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]xx]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x&x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]x]xx]x]x]x]x]x]x]x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^xMxMx^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x&x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^x^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________``````````````````````````````````````````````````````````````````````````````````5`5`55`5`5`5`5`55`555`5`55`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5`5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a55a5a5a5a5a5a5V555a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5bbbbbbbbbbWWbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb]bbbbbbbbbbbbbbbbbbbbbbbbb'bcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddd,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,-,d,-,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d6d6d6d6d6d6d6d6d6d6-6-6d6-6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e8e{e{e{e{e{e{e{e{e{e{e{e{e{e{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{f{g{g{g{g{g{g{g{g{gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-h-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-i-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-j-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-k-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-m-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-n-nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo.o.o.o.o.o.o.o.o.o.p.p..p.p.p.p.p.p.p.p.p.p.p.p.p.p.p.p.ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~q~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssstttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuu@uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuccccuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv4vvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4z4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}b}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~O€ÀĀŀƀǀȀɀʀˀ̀̀΀πЀрҀӀԀՀՀր׀؀ـڀۀ܀݀ހ ߀ ߀                                     ÁāŁƁǁȁɁʁˁ́́΁ρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂^ƒÃăŃƃǃȃɃʃ˃̃̓΃σgЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃4„ÄĄńƄDŽȄɄʄ˄̄̈́΄τЄф҄ӄԄՄքׄ؄لڄۄ܄݄ބ߄…ÅąŅƅDžȅɅʅ˅̅ͅ΅υЅх҅ӅԅՅօׅ؅مڅۅ܅݅ޅ߅†ÆĆņƆdžȆɆʆˆ̆͆ΆφІц҆ӆԆՆֆ׆؆نچۆ܆݆ކ߆‡ÇćŇƇLJȇɇʇˇ͇̇·χЇч҇ӇԇՇևׇ؇هڇۇ܇݇އ߇''''''''''''''''''''''''''''''''''''''''''''''''''ˆ'È'Ĉ'ň'ƈ'Lj'Ȉ'Ɉ'ʈ'ˈ'̈'͈'Έ'ψ'Ј'ш'҈'ӈ'Ԉ'Ո'ֈ'׈'؈'و'ڈ'ۈ'܈'݈'ވ'߈''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''‰'É'ĉ'ʼn'Ɖ'lj'ȉ'ɉ'ʉ'ˉ'̉'͉'Ή'ω'Љ'щ'҉'Ӊ'ԉ'Չ'։׉׉؉ىډۉ܉݉މ߉ŠÊĊŊƊNJȊɊʊˊ̊͊ΊϊЊъҊӊԊՊ֊׊؊يڊۊ܊݊ފߊ‹ËċŋƋNjȋɋʋˋ̋͋΋ϋЋыҋӋԋՋ֋׋؋ًڋۋ܋݋ދߋŒÌČŌƌnjȌɌʌʌˌ̌͌ΌόЌьҌӌԌՌ֌׌،ٌڌی܌݌ތߌÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍԍՍ֍׍؍ٍڍۍ܍ݍލߍߍŽÎĎŎƎǎȎɎʎˎ͎̎ΎώЎюҎӎԎԎՎ֎׎؎َڎێ܎ݎގߎÏďŏƏǏȏɏʏˏ̏͏ΏϏЏяҏӏԏՏ֏׏؏ُڏۏ܏ݏޏߏÐĐŐƐǐȐɐʐː̐͐ΐϐАѐҐӐԐՐ֐אِؐڐېܐݐސߐ‘ÑđőƑǑȑɑʑˑ̑͑ΑϑБёґӑԑՑ֑בّؑڑۑܑݑޑߑ’ÒĒŒƒǒȒȒɒʒ˒˒̒͒ΒϒВђҒҒӒԒՒ֒גْؒڒےܒݒܒޒߒ“ÓēœƓǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓړۓܓݓޓޓߓ”ÔĔŔƔǔȔɔʔ˔͔̔ΔϔДєҔӔԔՔ֔הؔٔڔ۔ܔݔޔߔa•ÕĕŕƕǕȕɕʕ˕͕̕ΕϕЕѕҕӕԕՕ֕וٕؕڕەܕݕޕߕ–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖӖԖՖ֖֖זזٖؖږۖܖݖޖߖ—×ėŗƗǗȗɗʗ˗̗͗͗ΗΗϗЗїҗӗԗԗ՗֗חؗٗڗۗܗݗޗߗDD˜ØĘŘƘǘȘɘʘ˘̘͘ΘϘИјҘӘԘ՘֘טؘ٘ژۘܘݘޘߘTTTT////////////™ÙęřƙǙșəʙ˙̙͙ΙϙЙљҙәԙՙ֙יؙٙڙۙܙݙޙߙšÚĚĚŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚҚԚԚ՚֚ךؚٚښۚܚݚޚߚu›ÛěśśƛǛțɛʛ˛̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛpKKqKKKKcœÜĜŜƜǜȜɜʜ˜̜͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝٝڝ۝ܝݝޝߝߝ|žÞĞŞƞǞȞɞʞ˞̞͞ΞϞОўҞӞԞ՞֞מ؞ٞڞ۞ܞݞޞߞŸßğşƟǟȟɟʟ˟̟͟ΟϟПџҟӟԟ՟֟ן؟ٟڟ۟ܟݟޟߟ|ٝ à0Ġ0Š0Ơ0Ǡ0Ƞ0ɠ0ʠ0ˠ0̠0͠0Π0Ϡ0Р0Ѡ0ҠӠӠԠՠ֠נؠ٠ڠ۠ܠݠޠߠ¡áġġšơǡȡɡʡˡ̡͡ΡϡСѡҡӡԡա֡סء١ڡۡܡݡޡߡ//¢âĢŢƢƢǢȢɢʢˢ̢͢΢ϢmТѢҢӢԢբ֢עآ٢ڢۢܢݢޢߢ£ãģţƣǣȣɣʣˣ̣ͣΣϣУѣңӣԣգ֣ףأ٣ڣۣܣݣޣߣ+++++++¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤߤ@¥åĥťƥǥȥɥʥ˥̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥ¦æĦŦƦǦȦɦʦ˦̦ͦΦϦЦѦҦӦӦԦզ֦צئ٦ڦۦܦݦަߦ/ߡ§çħŧKKKpppƧǧpȧɧʧ˧̧ͧͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧݧާߧ00cc¨èĨŨƨǨǨȨȨɨɨʨʨ˨̨ͨΨϨШѨҨӨԨը֨רب٨ڨۨܨݨިߨ©éĩũƩǩȩɩʩ˩̩ͩΩϩЩѩҩөԩթ֩שة٩ک۩ܩݩީߩªêĪŪƪǪȪɪʪ˪̪ͪΪϪЪѪҪӪԪժ֪תت٪ڪ۪ܪݪުߪH«ëīūƫǫȫɫʫ˫̫ͫΫϫЫѫҫӫԫի֫׫ث٫ګ۫ܫݫޫ߫b¬ìĬŬƬǬȬɬʬˬ̬ͬάϬЬѬҬӬԬլ֬׬ج٬ڬ۬ܬݬެ߬­íĭŭƭǭȭɭʭ˭̭ͭέϭЭѭҭӭԭխ֭׭ح٭ڭۭܭݭޭ߭®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ֮׮خٮڮۮܮݮޮ߮¯ïįůƯǯȯɯʯ˯̯ͯίϯЯѯүӯԯկ֯ׯدٯگۯܯݯޯ߯°ðİŰưǰȰɰʰ˰̰ͰΰϰаѰҰӰ԰հְװذٰڰ۰ܰݰް߰ VV±ñıűƱDZȱɱʱ˱̱ͱαϱбѱұӱұԱձֱױرٱڱ۱ܱݱޱ߱²òIJŲƲDzȲȲɲɲʲʲ˲̲ͲβϲвѲҲӲԲղֲײزٲڲ۲ܲݲ޲߲³óijųƳdzȳɳʳ˳̳ͳγϳгѳҳӳԳճֳ׳سٳڳ۳ܳݳ޳߳'´ôĴŴƴǴȴɴʴ˴̴ʹδϴдѴҴӴԴմִ״شٴڴ۴ܴݴ޴ߴaµõĵŵƵǵȵɵʵ˵̵͵εϵеѵϱҵӵԵյֵ׵صٵڵ۵ܵݵ޵ߵر۱ܱݱޱ߱¶öĶŶƶǶȶɶʶ˶̶Ͷζ϶жѶҶӶԶնֶ׶ضٶڶ۶ܶݶ޶߶·÷ķŷƷǷȷɷʷ˷̷ͷηϷзѷҷӷӷccԷշַ׷׷طٷڷ۷ܷݷ޷u߷¸۱ܱݱޱ߱رøĸŸƸǸȸɸʸ˸̸͸θϸиѸҸӸԸոָ׸ظٸڸ۸ܸݸ޸߸ٷ¹ùĹŹƹǹȹɹʹ˹̹͹ιϹйѹҹӹԹչֹ׹عٹڹ۹ܹݹ޹߹ºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٺںۺܺݺ޺ߺV»ûĻŻƻǻȻɻʻ˻̻ͻλϻлѻһӻԻջֻ׻ػٻڻۻܻݻ޻߻ٷŹȹ¼üļżƼƼǼȼɼʼ˼Ź̼ͼμϼмѼҼӼԼռּ׼ؼټڼۼܼݼ޼߼½ýĽŽƽǽȽɽʽ˽̽ͽνϽнѽҽӽԽսֽ׽ؽٽڽ۽ܽݽ޽߽ĵ¾þľžƾǾȾɾʾ˾̾;ξϾоѾҾӾԾվ־׾ؾپھ۾ܾݾ޾߾,̾;߾ؾܾݾվԾ־žƾ¿ÿĿſƿǿȿɿʿ˿̿ͿοϿпѿҿӿԿտֿ׿ؿٿڿۿܿݿ޿߿ٷȹ¹ŹŹȼɼμϼȼɼȼɼg        N5P̾pV                                                      ȡ]oh;n.      !!!!+K AAAAAHNPTT```1BBYYkkzkUU)^ea (22223333777777{7777777777777777777777 ::::::::::: &&&&&&&&&&999999999 ĚzzĵV5,,,,3{{{{{{{{{{  ........ 4444b̵''' ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~u~~~~~~~~~~-a ùĹƹг2                      ÜghcGHC.Prelude.BasicGHC.Utils.TraceGHC.Utils.MonadGHC.Driver.PluginsGHC.Utils.FingerprintGHC.Utils.Misc GHC.PlatformGHC.Utils.Exception GHC.Unit.InfoGHC.Core.TyCo.FVsGHC.Data.IOEnvGHC.HsToCore.MonadGHC.Core.Opt.SpecConstrGHC.Data.Graph.Directed GHC.SysToolsGHC.Data.MaybeGHC.SysTools.BaseDirGHC.ByteCode.AsmGHC.Types.BasicGHCGHC.Runtime.InterpreterGHC.Data.List.InfiniteGHC.Platform.ConstantsGHC.Data.FastMutInt GHC.Data.BoolGHC.Settings.ConfigGHC.Utils.ConstantsGHC.Utils.GlobalVarsGHC.Utils.IO.UnsafeGHC.Utils.Panic.PlainGHC.Data.FastStringGHC.Utils.BufHandle GHC.Utils.PprGHC.Utils.Ppr.ColourLanguage.Haskell.Syntax.Basic!Language.Haskell.Syntax.Extension#Language.Haskell.Syntax.Module.NameGHC.Iface.TypeGHC.Tc.Types.OriginGHC.Types.Name.OccurrenceGHC.Unit.TypesGHC.Utils.OutputableGHC.Utils.PanicGHC.Types.Id.InfoGHC.Builtin.PrimOpsGHC.Core.UnfoldGHC.Core.Opt.CallerCCGHC.Driver.HooksGHC.Types.UniqueGHC.Types.Name GHC.Types.VarGHC.Tc.Utils.TcTypeGHC.Core GHC.Types.IdGHC.Core.TyConGHC.Types.TyThingGHC.Core.Coercion GHC.Core.TypeGHC.Core.TyCo.RepGHC.Core.MultiplicityGHC.Core.TyCo.PprGHC.Types.Unique.FMGHC.Data.StrictGHC.Data.FiniteMapGHC.Utils.LexemeGHC.Types.Unique.Supply Language.Haskell.Syntax.ConcreteGHC.Settings.ConstantsGHC.Cmm.Dataflow.CollectionsGHC.Utils.CliOptionGHC.Types.ProfAutoGHC.SysTools.TerminalGHC.Driver.Plugins.ExternalGHC.Driver.Backend.InternalGHC.Utils.Monad.State.StrictGHC.Types.HpcInfoGHC.Data.SmallArrayGHC.Data.StringBufferGHC.Data.StreamGHC.Cmm.Dataflow.BlockGHC.Data.UnboxedGHC.CmmToAsm.CFG.WeightGHC.Utils.JsonGHC.Types.SrcLocGHC.Utils.BinaryGHC.Data.EnumSetGHC.Utils.Binary.TypeableGHC.Iface.Ext.FieldsGHC.Types.Unique.DFMGHC.Data.FastString.EnvGHC.Types.CostCentre.StateGHC.Types.Unique.SetGHC.Types.Unique.DSetGHC.Types.SourceTextGHC.Types.SafeHaskellGHC.Data.OrdListGHC.Types.FieldLabelGHC.Data.List.SetOps GHC.Data.BagGHC.Types.FixityGHC.Hs.DocString GHC.Data.PairGHC.Driver.Flags GHC.Unit.PprGHC.Parser.Errors.BasicGHC.Tc.Types.RankGHC.Types.Unique.SDFMGHC.Types.Unique.MapGHC.Unit.Module.LocationGHC.Unit.Module.EnvGHC.Unit.ModuleGHC.Types.ForeignCallGHC.Types.BreakInfo GHC.Unit.HomeGHC.Types.PkgQualGHC.Types.SourceFileGHC.Unit.ParserGHC.Driver.Env.KnotVarsLanguage.Haskell.Syntax.PatLanguage.Haskell.Syntax.ExprGHC.Builtin.UniquesGHC.Core.DataConGHC.Builtin.TypesGHC.Platform.Reg.ClassGHC.Platform.RegGHC.Cmm.CLabelGHC.Types.Var.Set GHC.Utils.FVGHC.Data.Graph.UnVarGHC.Stg.InferTags.TagSigGHC.Types.Var.EnvGHC.Types.Name.SetGHC.Types.Name.EnvGHC.Types.AvailGHC.Types.Name.ReaderGHC.Unit.Module.ImportedGHC.Parser.AnnotationGHC.Data.BooleanFormulaGHC.Hs.Extension GHC.Hs.DocLanguage.Haskell.Syntax.ImpExpGHC.Unit.Module.WarningsGHC.Types.CostCentreGHC.Builtin.NamesGHC.Types.AnnotationsGHC.Iface.Recomp.BinaryGHC.Types.Fixity.Env GHC.Hs.ImpExpGHC.Core.Rules.Config GHC.Cmm.TypeGHC.Types.ForeignStubsGHC.Platform.WaysGHC.Platform.Profile GHC.Cmm.RegGHC.Cmm.MachOp GHC.SettingsGHC.Driver.PhasesGHC.Linker.Static.UtilsGHC.CmmToLlvm.ConfigGHC.Driver.LlvmConfigCacheGHC.Core.Coercion.AxiomGHC.Core.ClassGHC.Types.Id.MakeGHC.CoreToIfaceGHC.Builtin.Types.PrimGHC.Core.TyCo.SubstGHC.Core.TyCo.TidyLanguage.Haskell.Syntax.LitGHC.Core.TyCo.CompareGHC.Types.TickishGHC.Core.UsageEnvGHC.Types.LiteralGHC.Data.TrieMapGHC.Cmm.Dataflow.LabelGHC.Cmm.BlockIdGHC.Cmm.Dataflow.GraphGHC.Core.TyCon.EnvGHC.Core.TyCon.RecWalkGHC.Core.RoughMapGHC.Types.HintGHC.Types.ErrorGHC.Utils.LoggerGHC.Utils.ErrorGHC.Utils.TmpFsGHC.Driver.Pipeline.MonadGHC.Driver.BackendGHC.Cmm.SwitchGHC.StgToCmm.ConfigGHC.Driver.CmdLineGHC.Core.Opt.StatsGHC.Core.Map.TypeGHC.Core.UnifyGHC.Core.PredicateLanguage.Haskell.Syntax.Type GHC.Hs.PatLanguage.Haskell.Syntax.BindsLanguage.Haskell.Syntax.Decls GHC.Hs.ExprLanguage.Haskell.SyntaxGHC.Types.DemandGHC.Types.RepType GHC.Types.CprGHC.Core.SimpleOptGHC.Core.Map.ExprGHC.Core.ReductionGHC.Core.PatSynGHC.Core.ConLikeGHC.Types.CompleteMatchGHC.Runtime.Heap.LayoutGHC.StgToCmm.TypesGHC.Types.Name.CacheGHC.Core.StatsGHC.Runtime.Eval.Types GHC.Core.Ppr GHC.Core.FVsGHC.Core.FamInstEnvGHC.Types.TypeEnvGHC.Core.Opt.ConstantFoldGHC.Core.UtilsGHC.Stg.Syntax GHC.Core.SeqGHC.Core.SubstGHC.Core.Opt.ArityGHC.Core.Opt.OccurAnalGHC.Core.Unfold.Make GHC.Core.Make GHC.Types.IPEGHC.Iface.Syntax!GHC.Unit.Module.WholeCoreBindings GHC.Cmm.ExprGHC.ByteCode.TypesGHC.Platform.X86_64GHC.Platform.X86GHC.Platform.Wasm32GHC.Platform.S390XGHC.Platform.RISCV64GHC.Platform.PPCGHC.Platform.NoRegsGHC.Platform.LoongArch64GHC.Platform.ARMGHC.Platform.AArch64GHC.Platform.Regs GHC.Hs.TypeGHC.Driver.Session GHC.Tc.TypesGHC.Tc.Errors.Hole.FitTypesGHC.Tc.Types.EvidenceGHC.Core.Coercion.OptGHC.Core.InstEnvGHC.Unit.Module.ModDetailsGHC.Unit.StateGHC.Unit.Module.DepsGHC.Linker.TypesGHC.Runtime.Interpreter.TypesGHC.Types.TargetGHC.Unit.Finder.TypesGHC.Driver.PprGHC.Driver.Config.Logger GHC.Core.TidyGHC.Builtin.PrimOps.Ids GHC.Hs.Lit GHC.Hs.BindsGHC.Parser.Types GHC.Hs.Decls GHC.Hs.UtilsGHC.Types.Hint.PprGHC.Hs.InstancesGHC.HsGHC.Tc.Types.ConstraintGHC.Tc.Solver.TypesGHC.Tc.Solver.InertSetGHC.HsToCore.Pmc.Solver.TypesGHC.HsToCore.Pmc.TypesGHC.HsToCore.Pmc.PprGHC.Unit.Module.ModGutsGHC.Core.RulesGHC.Unit.Module.ModIfaceGHC.Unit.ExternalGHC.Unit.Home.ModInfo GHC.Unit.EnvGHC.Types.Name.PprGHC.Unit.Module.StatusGHC.Runtime.ContextGHC.Core.Lint.InteractiveGHC.Unit.Module.ModSummaryGHC.Unit.Module.GraphGHC.Parser.Errors.TypesGHC.Tc.Errors.TypesGHC.HsToCore.Errors.TypesGHC.Driver.Errors.TypesGHC.Driver.Env.TypesGHC.Types.Error.CodesGHC.Parser.Errors.PprGHC.Tc.Errors.PprGHC.HsToCore.Errors.PprGHC.Driver.Errors.PprGHC.Types.SourceErrorGHC.Driver.ErrorsGHC.Driver.Config.DiagnosticGHC.Driver.EnvGHC.Core.Opt.MonadGHC.Driver.MonadGHC.Types.Meta GHC.Cmm.NodeGHC.CmmGHC.Core.Opt.Simplify.MonadGHC.Core.Opt.Simplify.EnvGHC.Core.Opt.Simplify.UtilsGHC.Core.Opt.Simplify.Iteration GHC.Core.LintGHC.Core.Opt.SimplifyGHC.Core.Opt.Pipeline.TypesGHC.Driver.Config.Core.LintGHC.Driver.Pipeline.PhasesGHC.SysTools.ArGHC.Linker.ConfigGHC.Data.UnionFindGHC.CmmToAsm.X86.CondGHC.CmmToAsm.CFG.DominatorsGHC.CmmToAsm.AArch64.CondGHC.Parser.CharClassGHC.Data.Graph.Inductive.Graph%GHC.Data.Graph.Inductive.PatriciaTreeGHC.CmmToAsm.PPC.CondGHC.Types.Unique.MemoFunGHC.Data.Graph.Base GHC.JS.SyntaxGHC.JS.Transform GHC.CmmToAsm.Reg.Linear.StackMapGHC.CmmToAsm.Reg.Graph.BaseGHC.CmmToAsm.Reg.Graph.X86 GHC.Utils.AsmGHC.Settings.IOGHC.CmmToLlvm.ManglerGHC.CmmToAsm.Reg.Utils$GHC.CmmToAsm.Reg.Graph.TrivColorable GHC.JS.PprGHC.StgToJS.Printer GHC.JS.MakeGHC.StgToJS.RegsGHC.Stg.Lift.ConfigGHC.Data.BitmapGHC.Cmm.ConfigGHC.Data.Graph.PprGHC.Data.Graph.OpsGHC.Data.Graph.Color GHC.Hs.StatsGHC.CmmToAsm.CPrimGHC.StgToJS.SymbolsGHC.CmmToAsm.Config GHC.Hs.Dump GHC.Stg.SubstGHC.Data.Graph.CollapseGHC.Core.TyCon.SetGHC.StgToJS.TypesGHC.StgToJS.Rts.TypesGHC.StgToJS.ObjectGHC.StgToJS.Linker.TypesGHC.StgToJS.HeapGHC.StgToJS.ExprCtxGHC.StgToJS.UtilsGHC.StgToJS.MonadGHC.StgToJS.ProfilingGHC.StgToJS.PrimGHC.StgToJS.CoreUtilsGHC.StgToJS.SinkerGHC.StgToJS.IdsGHC.StgToJS.StackGHC.StgToJS.LiteralGHC.StgToJS.DepsGHC.StgToJS.ClosureGHC.StgToJS.DataConGHC.StgToJS.ArgGHC.StgToJS.FFI GHC.Stg.Utils GHC.Stg.Stats GHC.Stg.FVs GHC.Stg.DebugGHC.Stg.BcPrepGHC.HsToCore.Foreign.UtilsGHC.Builtin.Names.THGHC.StgToJS.StgUtilsGHC.StgToJS.ApplyGHC.StgToJS.Rts.RtsGHC.Stg.InferTags.TypesGHC.CmmToAsm.InstrGHC.Cmm.LRegSet GHC.Stg.CSEGHC.StgToJS.StaticPtrGHC.HsToCore.TicksGHC.HsToCore.CoverageGHC.SysTools.ElfGHC.StgToCmm.SequelGHC.CmmToAsm.X86.RegsGHC.CmmToAsm.Reg.Linear.X86_64GHC.CmmToAsm.Reg.Linear.X86GHC.CmmToAsm.Wasm.UtilsGHC.CmmToAsm.Wasm.TypesGHC.Wasm.ControlFlowGHC.CmmToAsm.UtilsGHC.CmmToAsm.TypesGHC.CmmToAsm.PprGHC.Llvm.TypesGHC.Llvm.MetaDataGHC.Llvm.Syntax GHC.Llvm.PprGHC.CmmToLlvm.RegsGHC.CmmToAsm.FormatGHC.CmmToAsm.X86.RegInfoGHC.CmmToAsm.PPC.RegsGHC.CmmToAsm.Reg.Linear.PPCGHC.CmmToAsm.Dwarf.ConstantsGHC.CmmToAsm.CFGGHC.CmmToAsm.Reg.LivenessGHC.CmmToAsm.Reg.Linear.BaseGHC.CmmToAsm.Reg.Linear.StatsGHC.CmmToAsm.Reg.Linear.State!GHC.CmmToAsm.Reg.Graph.SpillCleanGHC.CmmToAsm.Reg.Graph.SpillGHC.CmmToAsm.Reg.Graph.Coalesce GHC.CmmToAsm.Reg.Graph.SpillCostGHC.CmmToAsm.AArch64.RegsGHC.CmmToAsm.Reg.TargetGHC.CmmToAsm.Reg.Graph.StatsGHC.CmmToAsm.Reg.GraphGHC.CmmToAsm.Reg.Linear.AArch64GHC.CmmToAsm.AArch64.InstrGHC.CmmToAsm.AArch64.RegInfoGHC.CmmToAsm.AArch64.Ppr GHC.Cmm.UtilsGHC.StgToCmm.ClosureGHC.StgToCmm.ArgRepGHC.Stg.InferTags.RewriteGHC.StgToCmm.CgUtilsGHC.Cmm.Switch.Implement GHC.Cmm.OptGHC.Cmm.InitFini GHC.CmmToCGHC.Cmm.DebugBlockGHC.CmmToAsm.X86.InstrGHC.CmmToAsm.X86.PprGHC.CmmToAsm.MonadGHC.CmmToAsm.BlockLayoutGHC.CmmToAsm.Dwarf.TypesGHC.CmmToAsm.DwarfGHC.Cmm.DataflowGHC.Cmm.Liveness GHC.Cmm.SinkGHC.Cmm.DominatorsGHC.Wasm.ControlFlow.FromCmmGHC.CmmToAsm.Wasm.FromCmmGHC.CmmToAsm.Wasm.AsmGHC.CmmToAsm.WasmGHC.Cmm.ReducibilityGHC.Cmm.CallConv GHC.Cmm.Lint GHC.Cmm.GraphGHC.StgToCmm.MonadGHC.StgToCmm.ExtCodeGHC.StgToCmm.EnvGHC.StgToCmm.LitGHC.StgToCmm.UtilsGHC.StgToCmm.HpcGHC.Cmm.ThreadSanitizerGHC.StgToCmm.InfoTableProvGHC.Cmm.ContFlowOptGHC.Cmm.CommonBlockElim GHC.Cmm.InfoGHC.StgToCmm.TagCheckGHC.CmmToAsm.PPC.Instr GHC.CmmToAsm.Reg.Linear.FreeRegs%GHC.CmmToAsm.Reg.Linear.JoinToTargetsGHC.CmmToAsm.Reg.LinearGHC.CmmToAsm.PPC.RegInfoGHC.CmmToAsm.PPC.PprGHC.CmmToAsm.PICGHC.CmmToAsm.X86.CodeGenGHC.CmmToAsm.X86GHC.CmmToAsm.PPC.CodeGenGHC.CmmToAsm.PPCGHC.CmmToAsm.AArch64.CodeGenGHC.CmmToAsm.AArch64GHC.Cmm.ProcPoint GHC.Stg.LintGHC.Driver.Pipeline.LogQueueGHC.Tc.Instance.FunDepsGHC.Hs.Syn.TypeGHC.Stg.Lift.MonadGHC.Core.Opt.LiberateCaseGHC.Core.Opt.StaticArgsGHC.Core.Opt.ExitifyGHC.Core.Opt.CSEGHC.StgToJS.ExprGHC.StgToJS.CodeGen GHC.CoreToStgGHC.Core.Opt.CallArityGHC.Iface.Tidy.StaticPtrTableGHC.Core.Opt.SetLevelsGHC.Core.Opt.FloatOutGHC.Core.Opt.FloatInGHC.Core.Opt.WorkWrap.UtilsGHC.Core.Opt.DmdAnalGHC.Core.Opt.CprAnalGHC.Core.Opt.WorkWrapGHC.Tc.Types.EvTermGHC.SysTools.ProcessGHC.SysTools.InfoGHC.SysTools.TasksGHC.StgToJS.Linker.UtilsGHC.Stg.InferTagsGHC.Iface.Recomp.FlagsGHC.Driver.Config.StgToJSGHC.Driver.Config.StgToCmmGHC.Driver.Config.Stg.PprGHC.Driver.Config.Stg.LiftGHC.Driver.Config.Stg.DebugGHC.Driver.Config.Linker GHC.Driver.Config.HsToCore.TicksGHC.Driver.Config.HsToCoreGHC.Driver.Config.FinderGHC.Driver.Config.CoreToStgGHC.Driver.Config.Core.Rules'GHC.Driver.Config.Core.Opt.LiberateCase GHC.Driver.Config.Core.Opt.ArityGHC.Driver.Config.CmmToLlvmGHC.Driver.Config.CmmToAsmGHC.Driver.Config.CmmGHC.Unit.FinderGHC.HsToCore.BreakpointsGHC.Driver.Config#GHC.Driver.Config.Core.Opt.WorkWrapGHC.ByteCode.LinkerGHC.Linker.UnitGHC.Linker.MacOSGHC.Linker.ExtraObjGHC.SysTools.CppGHC.StgToJS.Linker.LinkerGHC.Linker.WindowsGHC.Linker.DynamicGHC.Linker.StaticGHC.CmmToLlvm.BaseGHC.CmmToLlvm.DataGHC.CmmToLlvm.PprGHC.CmmToLlvm.CodeGen GHC.CmmToLlvm GHC.CmmToAsmGHC.Driver.CodeOutputGHC.StgToCmm.ProfGHC.StgToCmm.ForeignGHC.StgToCmm.TickyGHC.StgToCmm.LayoutGHC.Stg.Lift.Analysis GHC.Stg.LiftGHC.ByteCode.InstrGHC.ByteCode.InfoTableGHC.StgToByteCodeGHC.StgToCmm.HeapGHC.Cmm.Info.BuildGHC.StgToCmm.PrimGHC.Cmm.LayoutStackGHC.Cmm.PipelineGHC.Driver.GenerateCgIPEStubGHC.Builtin.Types.LiteralsGHC.Builtin.UtilsGHC.StgToCmm.DataConGHC.StgToCmm.BindGHC.StgToCmm.Expr GHC.StgToCmmGHC.Iface.Ext.TypesGHC.Iface.Ext.UtilsGHC.Iface.Ext.DebugGHC.Iface.Ext.BinaryGHC.Iface.ErrorsGHC.Parser.LexerGHC.Parser.PostProcess GHC.ThToHsGHC.Parser.HaddockLexGHC.Cmm.Parser.ConfigGHC.Cmm.Parser.MonadGHC.Driver.Config.ParserGHC.Driver.Config.Cmm.ParserGHC.Core.Opt.Specialise GHC.Cmm.LexerGHC.Cmm.ParserGHC.HsToCore.DocsGHC.HsToCore.Types#GHC.Driver.Config.Core.Opt.Simplify'GHC.Driver.Config.Core.Lint.InteractiveGHC.Core.LateCCGHC.Core.Opt.PipelineGHC.Driver.Backpack.Syntax GHC.ParserGHC.Parser.PostProcess.HaddockGHC.Parser.UtilsGHC.Parser.HeaderGHC.Driver.Pipeline GHC.Tc.ModuleGHC.Tc.Gen.MatchGHC.Rename.ExprGHC.Tc.Errors.HoleGHC.Tc.Gen.SpliceGHC.IfaceToCoreGHC.Tc.Gen.ExprGHC.Tc.Utils.UnifyGHC.Tc.Utils.EnvGHC.Tc.Utils.MonadGHC.Iface.Load GHC.Iface.EnvGHC.Rename.SpliceGHC.Tc.Utils.TcMTypeGHC.Tc.Utils.ConcreteGHC.Tc.TyCl.BuildGHC.Types.Name.ShapeGHC.Iface.RenameGHC.Iface.BinaryGHC.HsToCore.Usage GHC.Driver.Config.HsToCore.UsageGHC.Rename.UnboundGHC.Rename.FixityGHC.Tc.Gen.AnnotationGHC.HsToCore.ExprGHC.HsToCore.MatchGHC.HsToCore.BindsGHC.HsToCore.UtilsGHC.HsToCore.Pmc.UtilsGHC.HsToCore.GuardedRHSsGHC.HsToCore.Foreign.CallGHC.Iface.RecompGHC.Linker.LoaderGHC.HsToCore.Foreign.PrimGHC.HsToCore.Foreign.JavaScriptGHC.Tc.Utils.ZonkGHC.HsToCore.Match.LiteralGHC.HsToCore.Pmc.DesugarGHC.Tc.Utils.InstantiateGHC.Tc.Instance.FamilyGHC.Tc.Instance.TypeableGHC.Rename.UtilsGHC.Rename.EnvGHC.Tc.Instance.ClassGHC.Tc.Solver.MonadGHC.Tc.Solver.RewriteGHC.Tc.Solver.CanonicalGHC.Tc.Solver.InteractGHC.Rename.DocGHC.Rename.HsTypeGHC.Rename.Pat GHC.Tc.Errors GHC.Tc.SolverGHC.HsToCore.Pmc.SolverGHC.HsToCore.Pmc.CheckGHC.HsToCore.PmcGHC.HsToCore.Match.ConstructorGHC.HsToCore.ListCompGHC.HsToCore.QuoteGHC.HsToCore.ArrowsGHC.Tc.ValidityGHC.Tc.Gen.HsTypeGHC.Rename.NamesGHC.Rename.BindGHC.Rename.ModuleGHC.Runtime.LoaderGHC.Tc.Gen.SigGHC.Tc.TyCl.PatSynGHC.Tc.Gen.PatGHC.Tc.Gen.BindGHC.Tc.TyCl.UtilsGHC.Tc.Gen.HeadGHC.Tc.Gen.AppGHC.Tc.Gen.Arrow GHC.PluginsGHC.Builtin.PrimOps.CastsGHC.Stg.UnariseGHC.Stg.PipelineGHC.Iface.MakeGHC.Types.TyThing.PprGHC.Iface.Ext.AstGHC.Driver.Config.Stg.PipelineGHC.Tc.Gen.ExportGHC.Tc.Utils.BackpackGHC.Tc.TyCl.ClassGHC.Tc.Deriv.GenerateGHC.Tc.Deriv.FunctorGHC.Tc.Deriv.GenericsGHC.Tc.Deriv.UtilsGHC.Tc.Deriv.Infer GHC.Tc.DerivGHC.Tc.TyCl.Instance GHC.Tc.TyClGHC.Tc.Gen.RuleGHC.Tc.Gen.ForeignGHC.Tc.Gen.DefaultGHC.Iface.TidyGHC.HsToCore.Foreign.CGHC.HsToCore.Foreign.Decl GHC.HsToCoreGHC.Driver.Config.TidyGHC.CoreToStg.Prep GHC.Driver.Config.CoreToStg.PrepGHC.Driver.MainGHC.Driver.Pipeline.ExecuteGHC.Runtime.Heap.Inspect GHC.Tc.PluginGHC.Runtime.EvalGHC.Driver.MakeGHC.Runtime.DebuggerGHC.Driver.MakeFileGHC.Driver.Backpack GhcExceptionSDocpprWithUnitState GHC.Prelude GHC.Linker Data.Listunconsheadtailnull AnnKeywordIdAnnOpen AnnHeaderAnnValAnnClose cc_flavour.^.!putIfaceTopBndrgetIfaceTopBndrAnnType AnnBackquoteAnnTildeMxexports_from_availAnnDeclHsImpExpIE AnnPattern Annotation AnnDotdotAnnComma AnnModule AnnImportAnnSafe AnnQualifiedAnnPackageNameAnnAs AnnHidingAnnSemi mkTyConTy ModBreaksCoreMapGHC.Data.Graph.Inductive* Data.KindTypeDriverUnexpectedSignature PsWarnTabPsWarnOperatorWhitespaceDsMaxPmCheckModelsReachedDataKindPsWarnStarIsTypePsWarnImportPreQualifiedPsErrEmptyDoubleQuotesPsErrIllegalRoleNamePsWarnStarBinderPsErrInvalidTypeSignatureTcRnOrphanInstanceDerivBadErrConstructorTcRnForallIdentifierTcRnIncorrectNameSpaceTcRnTypeCannotBeMarshaled GHC.UtilsError AnnDcolon AnnForallAnnDot AnnDarrow AnnRarrowAnnBangAnnUnitAnnEqualAnnAt AnnDefaultAnnInfix AnnInstanceAnnVbar AnnLarrowAnnWhere tcMonoBindsAnnFunIdAnnRole AnnForeign AnnExport AnnDerivingAnnStock AnnAnyClass AnnNewtypeAnnData AnnNewTypeAnnCLose AnnFamilyAnnOpenP AnnClosePAnnClassAnnThenAnnByAnnGroupAnnUsingAnnLetAnnRec Annlarrowtail Annrarrowtail AnnLarrowtail AnnRarrowtailAnnOpenB AnnCloseBAnnLamAnnCaseAnnOfAnnCasesAnnIfAnnElseAnnInAnnDoAnnColonAnnMinusAnnOpenE AnnOpenEQ AnnCloseQAnnProc AnnStaticHsExprRdrNamesUniqueRdrNameId mkCoreApps mkCoreConApps mkIntExpr mkWordExpr mkCharExpr mkStringExpr mkFloatExpr mkDoubleExpr mkCoreLams mkCoreLetsSubst NoExtFieldmakeIdentForId mkCoreLetConfigFloatOutSwitches setDumpPrefixrunGhcData.MapStrictGHC.UnittypeLevity_maybecvBindsAndSigs prettyBlock' GHC.StgToJShs StgToJS.Expr loadRetArgsGHC.JS Transform StgToJSConfigcsRuntimeAssert StgToJS.Stack pushOptimizedgenPrimLanguage.Haskell.TH.SyntaxaddModFinalizertopSortModuleGraphInertSet ConPatOut mkErrorReportcheckTypeHasFixedRuntimeRep GHC.Tc.UtilsMonadHeader GHC.DriverMakeexpandTypeSynonyms GHC.Core.PrepmkFloat SourceNoteCoreSynGHC.LlvmArraytabulateGHC.STGDebug idPrimRepliftedIdsExpander HscNoRecompBitsshiftR imp_dep_modsSessiontcg_type_env_varTcGblEnv initGhcMonadMaincheckClosedInStaticFormdecideGeneralisationPlaninitializePlugins newFamInstControl.Monad.STSTrunSTcheckConsistentFamInst singletoninferConstraints simplifyInfer GHC.Types addExternal rnImportDeclDynFlagsbackend SourceErrorbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint otherwise Debug.Tracetracemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.FixmfixControl.Monad.Failfail fromIntegral realToFrac toInteger toRationalmemptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowMonadFix MonadFail Applicative Data.FoldableFoldableData.Traversable Traversable SemigroupMonoidBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeOrderingRational~IOWord Data.EitherEitherPluginFrontendPluginFalseNothingJustTrueLeftRightLTEQGTGHC.Fingerprint.Type Fingerprintcompare<<=>maxmin/=&&||notGHC.Stack.Types HasCallStack GHC.ByteOrder ByteOrder BigEndian LittleEndianGHC.Exception.Type SomeExceptionGHC.ErrerrorerrorWithoutStackTrace undefinedliftA2<*<$=<<idconst.flip$!untilasTypeOf Data.VersionVersion+abssignumsubtract Data.Maybemaybelastinitfoldl1'scanlscanl1scanrscanr1iteraterepeat replicatecycle takeWhile dropWhiletakedropsplitAtspanbreakreverselookup!!zip3zipWithzipWith3unzipunzip3 showsPrecshowshowListShowSshowsshowChar showString showParensuccpredtoEnumfromEnumminBoundmaxBoundproperFractiontruncateroundceilingfloor/recipquotremdivmodquotRemdivModevenodd^^^gcdlcmGHC.Bits FiniteBits finiteBitSizecountLeadingZeroscountTrailingZeros.&..|.xor complementshiftrotatezeroBitsbitsetBitclearBit complementBittestBit bitSizeMaybebitSizeisSigned unsafeShiftL unsafeShiftRrotateLrotateRpopCount bitDefaulttestBitDefaultpopCountDefaulttoIntegralSized floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2piexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanh Data.Tuplefstsndcurryuncurry Data.Functor<$>Text.ParserCombinators.ReadPReadS readsPrecreadList readParenlexGHC.FingerprintfingerprintStringfingerprintFingerprintseither Text.ReadreadsreadData.Semigroup.InternalEndoappEndofoldMapfoldrfoldlfoldl'foldr1foldl1lengthelemmaximumminimumsumproductfoldrMfoldlMmapM_ sequence_concat concatMapandoranyallnotElemArithExceptionOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominator Exception toException fromExceptiondisplayException Data.OldListlinesunlineswordsunwords GHC.Exception ErrorCallErrorCallWithLocationthrowGHC.IO.ExceptionIOError IOException userErrorGHC.IO MaskingStateUnmaskedMaskedInterruptibleMaskedUninterruptibleFilePathcatchthrowIO interruptiblegetMaskingStatemask_maskuninterruptibleMask_uninterruptibleMaskevaluate GHC.IORefIORefArrayExceptionIndexOutOfBoundsUndefinedElementAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptSomeAsyncExceptionAssertionFailedCompactionFailedAllocationLimitExceededDeadlockBlockedIndefinitelyOnSTMBlockedIndefinitelyOnMVarasyncExceptionToExceptionasyncExceptionFromExceptionioError GHC.Conc.SyncthrowToControl.Exception.BaseNestedAtomicallyNonTermination TypeError NoMethodError RecUpdError RecConError RecSelErrorPatternMatchFail catchJusthandle handleJust mapExceptiontrytryJust onExceptionbracketfinallybracket_bracketOnErrorControl.ExceptionHandlercatchesallowInterruptputCharputStrputStrLngetChargetLine getContentsinteractreadFile writeFile appendFilereadLnreadIOtraverse sequenceAmapMsequence versionBranch versionTags Control.Monad mapAndUnzipM fingerprint0fingerprintData getFileHashControl.Monad.IO.ClassMonadIOliftIO Data.Data mkNoRepTypeGHC.ExtsSpecConstrAnnotation NoSpecConstrForceSpecConstrsortWithcontainers-0.6.7 Data.GraphSCC AcyclicSCC CyclicSCC flattenSCCs flattenSCCdirectory-1.3.8.1System.DirectorycopyFiletransformers-0.6.1.0Control.Monad.Trans.MaybeMaybeTghc-boot-9.6.3 GHC.BaseDir expandTopDirGHC.Data.SizedSeqSizedSeqssEltssizeSSGHC.Platform.ArchOSOS OSUnknownOSLinuxOSDarwin OSSolaris2 OSMinGW32 OSFreeBSD OSDragonFly OSOpenBSDOSNetBSD OSKFreeBSDOSHaikuOSQNXNTOOSAIXOSHurdOSWasiOSGhcjs PPC_64ABIELF_V1ELF_V2ArmABISOFTSOFTFPHARD ArmISAExtVFPv2VFPv3VFPv3D16NEONIWMMX2ArmISAARMv5ARMv6ARMv7Arch ArchUnknownArchX86 ArchX86_64ArchPPC ArchPPC_64 ArchS390XArchARM ArchAArch64 ArchAlpha ArchMipseb ArchMipsel ArchRISCV64ArchLoongArch64ArchJavaScript ArchWasm32ArchOS archOS_arch archOS_OSGHC.Unit.DatabaseGenericUnitInfounitIdunitInstanceOfunitInstantiations unitPackageIdunitPackageNameunitPackageVersionunitComponentName unitAbiHash unitDependsunitAbiDependsunitImportDirs unitLibrariesunitExtDepLibsSysunitExtDepLibsGhcunitLibraryDirsunitLibraryDynDirsunitExtDepFrameworksunitExtDepFrameworkDirsunitLinkerOptions unitCcOptions unitIncludesunitIncludeDirsunitHaddockInterfacesunitHaddockHTMLsunitExposedModulesunitHiddenModulesunitIsIndefinite unitIsExposed unitIsTrustedghc-boot-th-9.6.3GHC.ForeignSrcLang.TypeForeignSrcLangLangCLangCxxLangObjc LangObjcxxLangAsmLangJs RawObject ghci-9.6.3GHCi.RemoteTypes ForeignHValueHValue GHCi.Message EvalResult EvalException EvalSuccess EvalStatus_ EvalComplete EvalBreak EvalStatusEvalExprEvalThisEvalAppMessageShutdown RtsRevertCAFs InitLinker LookupSymbol LookupClosureLoadDLL LoadArchiveLoadObj UnloadObjAddLibrarySearchPathRemoveLibrarySearchPath ResolveObjsFindSystemLibrary CreateBCOsFreeHValueRefs AddSptEntry MallocData MallocStringsPrepFFIFreeFFIMkConInfoTableEvalStmt ResumeStmt AbandonStmt EvalStringEvalStringToStringEvalIO MkCostCentresCostCentreStackInfo NewBreakArraySetupBreakpointBreakpointStatusGetBreakpointVarStartTHRunTHRunModFinalizers GetClosureSeq ResumeSeq runMaybeTInfiniteInfunfoldrgroupBydropList allListsOftoList$fApplicativeInfinite$fFoldableInfinite$fFunctorInfinite$fTraversableInfinitePlatformConstantspc_CONTROL_GROUP_CONST_291pc_STD_HDR_SIZEpc_PROF_HDR_SIZE pc_BLOCK_SIZEpc_BLOCKS_PER_MBLOCKpc_TICKY_BIN_COUNTpc_OFFSET_StgRegTable_rR1pc_OFFSET_StgRegTable_rR2pc_OFFSET_StgRegTable_rR3pc_OFFSET_StgRegTable_rR4pc_OFFSET_StgRegTable_rR5pc_OFFSET_StgRegTable_rR6pc_OFFSET_StgRegTable_rR7pc_OFFSET_StgRegTable_rR8pc_OFFSET_StgRegTable_rR9pc_OFFSET_StgRegTable_rR10pc_OFFSET_StgRegTable_rF1pc_OFFSET_StgRegTable_rF2pc_OFFSET_StgRegTable_rF3pc_OFFSET_StgRegTable_rF4pc_OFFSET_StgRegTable_rF5pc_OFFSET_StgRegTable_rF6pc_OFFSET_StgRegTable_rD1pc_OFFSET_StgRegTable_rD2pc_OFFSET_StgRegTable_rD3pc_OFFSET_StgRegTable_rD4pc_OFFSET_StgRegTable_rD5pc_OFFSET_StgRegTable_rD6pc_OFFSET_StgRegTable_rXMM1pc_OFFSET_StgRegTable_rXMM2pc_OFFSET_StgRegTable_rXMM3pc_OFFSET_StgRegTable_rXMM4pc_OFFSET_StgRegTable_rXMM5pc_OFFSET_StgRegTable_rXMM6pc_OFFSET_StgRegTable_rYMM1pc_OFFSET_StgRegTable_rYMM2pc_OFFSET_StgRegTable_rYMM3pc_OFFSET_StgRegTable_rYMM4pc_OFFSET_StgRegTable_rYMM5pc_OFFSET_StgRegTable_rYMM6pc_OFFSET_StgRegTable_rZMM1pc_OFFSET_StgRegTable_rZMM2pc_OFFSET_StgRegTable_rZMM3pc_OFFSET_StgRegTable_rZMM4pc_OFFSET_StgRegTable_rZMM5pc_OFFSET_StgRegTable_rZMM6pc_OFFSET_StgRegTable_rL1pc_OFFSET_StgRegTable_rSppc_OFFSET_StgRegTable_rSpLimpc_OFFSET_StgRegTable_rHppc_OFFSET_StgRegTable_rHpLimpc_OFFSET_StgRegTable_rCCCS!pc_OFFSET_StgRegTable_rCurrentTSO%pc_OFFSET_StgRegTable_rCurrentNurserypc_OFFSET_StgRegTable_rHpAllocpc_OFFSET_stgEagerBlackholeInfopc_OFFSET_stgGCEnter1pc_OFFSET_stgGCFunpc_OFFSET_Capability_rpc_OFFSET_bdescr_startpc_OFFSET_bdescr_freepc_OFFSET_bdescr_blockspc_OFFSET_bdescr_flagspc_SIZEOF_CostCentreStack#pc_OFFSET_CostCentreStack_mem_alloc pc_REP_CostCentreStack_mem_alloc#pc_OFFSET_CostCentreStack_scc_count pc_REP_CostCentreStack_scc_countpc_OFFSET_StgHeader_ccspc_OFFSET_StgHeader_ldvwpc_SIZEOF_StgSMPThunkHeaderpc_OFFSET_StgEntCounter_allocspc_REP_StgEntCounter_allocspc_OFFSET_StgEntCounter_allocdpc_REP_StgEntCounter_allocd#pc_OFFSET_StgEntCounter_registeredppc_OFFSET_StgEntCounter_link#pc_OFFSET_StgEntCounter_entry_countpc_SIZEOF_StgUpdateFrame_NoHdrpc_SIZEOF_StgMutArrPtrs_NoHdrpc_OFFSET_StgMutArrPtrs_ptrspc_OFFSET_StgMutArrPtrs_size"pc_SIZEOF_StgSmallMutArrPtrs_NoHdr!pc_OFFSET_StgSmallMutArrPtrs_ptrspc_SIZEOF_StgArrBytes_NoHdrpc_OFFSET_StgArrBytes_bytespc_OFFSET_StgTSO_alloc_limitpc_OFFSET_StgTSO_cccspc_OFFSET_StgTSO_stackobjpc_OFFSET_StgStack_sppc_OFFSET_StgStack_stack pc_OFFSET_StgUpdateFrame_updatee"pc_OFFSET_StgFunInfoExtraFwd_aritypc_REP_StgFunInfoExtraFwd_aritypc_SIZEOF_StgFunInfoExtraRev"pc_OFFSET_StgFunInfoExtraRev_aritypc_REP_StgFunInfoExtraRev_aritypc_MAX_SPEC_SELECTEE_SIZEpc_MAX_SPEC_AP_SIZEpc_MIN_PAYLOAD_SIZEpc_MIN_INTLIKEpc_MAX_INTLIKEpc_MIN_CHARLIKEpc_MAX_CHARLIKEpc_MUT_ARR_PTRS_CARD_BITSpc_MAX_Vanilla_REGpc_MAX_Float_REGpc_MAX_Double_REGpc_MAX_Long_REGpc_MAX_XMM_REGpc_MAX_Real_Vanilla_REGpc_MAX_Real_Float_REGpc_MAX_Real_Double_REGpc_MAX_Real_XMM_REGpc_MAX_Real_Long_REGpc_RESERVED_C_STACK_BYTESpc_RESERVED_STACK_WORDSpc_AP_STACK_SPLIM pc_WORD_SIZE pc_CINT_SIZE pc_CLONG_SIZEpc_CLONG_LONG_SIZEpc_BITMAP_BITS_SHIFT pc_TAG_BITS pc_LDV_SHIFTpc_ILDV_CREATE_MASKpc_ILDV_STATE_CREATEpc_ILDV_STATE_USEpc_USE_INLINE_SRT_FIELDparseConstantsHeader$fShowPlatformConstants$fReadPlatformConstants$fEqPlatformConstants$fOrdPlatformConstantsshiftL FastMutInt newFastMutIntreadFastMutIntwriteFastMutIntatomicFetchAddFastMutOverridingBoolAutoNeverAlways overrideWith$fShowOverridingBool$fReadOverridingBool$fEqOverridingBool$fOrdOverridingBool$fEnumOverridingBool$fBoundedOverridingBoolcBuildPlatformStringcHostPlatformString cProjectNamecBooterVersioncStage ghciSupported debugIsOn isWindowsHost isDarwinHostExceptionMonadcatchIOhandleIOtryIOreadHexFingerprintfingerprintByteStringv_unsafeHasPprDebugv_unsafeHasNoDebugOutputv_unsafeHasNoStateHackunsafeHasPprDebugunsafeHasNoDebugOutputunsafeHasNoStateHackglobal consIORefglobalM sharedGlobal sharedGlobalMinlinePerformIOPlainGhcException PlainSignalPlainUsageErrorPlainCmdLineError PlainPanic PlainSorryPlainInstallationErrorPlainProgramErrorshowPlainGhcExceptionpanicsorrypgmError cmdLineErrorcmdLineErrorIO assertPanicassertmassertassertM$fShowPlainGhcException$fExceptionPlainGhcExceptionHasDebugCallStack DirectionForwards BackwardsSuffix applyWhennTimesconst2fstOf3sndOf3thdOf3fst3snd3third3uncurry3 filterOut partitionWith chkAppendzipEqual zipWithEqual zipWith3Equal zipWith4Equal filterByList filterByListspartitionByListstretchZipWithmapFstmapSnd mapAndUnzip mapAndUnzip3zipWithAndUnzip zipAndUnzipatLength lengthExceeds lengthAtLeastlengthIs lengthIsNot lengthAtMostlengthLessThan listLengthCmp equalLength compareLengthleLengthltLength isSingletonnotNullonly expectOnly chunkListholes changeLastmapLastM whenNonEmpty mergeListsBy isSortedByminWithnubSortordNubordNubOntransitiveClosurefoldl2all2count countWhiletakeList splitAtListdropTaildropWhileEndLEspanEndlast2 lastMaybeonJustsnocViewsplit capitaliseisEqual removeSpaces<&&><||> fuzzyMatch fuzzyLookup unzipWithseqList strictMap strictZipWithstrictZipWith3looksLikeModuleNamelooksLikePackageName exactLog2 readRationalreadSignificandExponentPairreadHexRationalreadHexSignificandExponentPairdoesDirNameExistgetModificationUTCTimemodificationTimeIfExistsfileHashIfExistswithAtomicRenamesplitLongestPrefix escapeSpacesreslashmakeRelativeToabstractConstrabstractDataTypecharToC hashString mapMaybe' PtrStringLexicalFastStringNonDetFastString FastStringuniqn_charsfs_sbsfs_zenc FastZStringbytesFSfastStringToByteStringfastStringToShortByteStringfastZStringToByteStringunsafeMkByteStringhPutFZSzString zStringTakeN lengthFZSlexicalCompareFS uniqCompareFS mkFastString#mkFastStringBytesmkFastStringByteStringmkFastStringShortByteString mkFastStringmkFastStringByteListlengthFSnullFSunpackFS zEncodeFSappendFSconcatFSconsFSunconsFS uniqueOfFSnilFSgetFastStringTablegetFastStringZEncCounterhPutFS mkPtrString#unpackPtrStringunpackPtrStringTakeNlengthPSfsLit$fNFDataFastString$fDataFastString$fShowFastString$fMonoidFastString$fSemigroupFastString$fIsStringFastString$fEqFastString$fOrdNonDetFastString$fOrdLexicalFastString$fEqLexicalFastString$fShowLexicalFastString$fDataLexicalFastString$fEqNonDetFastString$fShowNonDetFastString$fDataNonDetFastString$fNFDataFastZString BufHandle newBufHandlebPutCharbPutStrbPutFSbPutFZS bPutPtrString bPutReplicatebFlushModePageMode ZigZagModeLeftMode OneLineMode asciiSpaceStylemode lineLengthribbonsPerLine TextDetailsChrStrPStrZStrLStrRStrDocchartextftextptextztext sizedText zeroWidthText emptyTextemptyisEmptydocHeadsemicommacolonspaceequalslparenrparenlbrackrbracklbracerbraceintintegerfloatdoublerationalhexquotessquotesquote doubleQuotesparensbracketsbraces maybeParenshcathsepvcatnesthang hangNotEmpty punctuate$$$+$<><+>sepcatfcatfsepstyle renderStyle txtPrinter fullRenderprintDoc printDoc_printLeftRender bufLeftRender $fShowDocSchemesHeadersMessagesWarningsErrorsFatalsMargin PprColour renderColourrenderColourAfresh colCustomcolResetcolBold colBlackFgcolRedFg colGreenFg colYellowFg colBlueFg colMagentaFg colCyanFg colWhiteFg defaultScheme parseScheme$fMonoidPprColour$fSemigroupPprColourSrcUnpackedness SrcUnpack SrcNoUnpack NoSrcUnpack SrcStrictnessSrcLazy SrcStrict NoSrcStrictRoleNominalRepresentationalPhantomFieldLabelString field_labelConTagSumWidthBoxityBoxedUnboxedisBoxed$fEqSrcUnpackedness$fDataSrcUnpackedness$fEqSrcStrictness$fDataSrcStrictness$fEqRole $fOrdRole $fDataRole$fDataFieldLabelString$fEqFieldLabelString$fNFDataFieldLabelString $fEqBoxity $fDataBoxityNoGhcTcXXIEWrappedNameXIEType XIEPatternXIENameXXIE XIEDocNamedXIEDocXIEGroupXIEModuleContents XIEThingWith XIEThingAll XIEThingAbsXIEVarImportDeclPkgQual XXImportDecl XCImportDecl XXFieldOcc XCFieldOccXXConDeclField XConDeclField XXTyVarBndr XKindedTyVar XUserTyVarXXHsForAllTelescopeXHsForAllInvis XHsForAllVisXXTyLitXCharTyXStrTyXNumTyXXType XWildCardTyXTyLitXExplicitTupleTyXExplicitListTyXRecTyXBangTyXDocTy XSpliceTyXKindSigXStarTy XIParamTyXParTyXOpTyXSumTyXTupleTyXListTyXFunTy XAppKindTyXAppTyXTyVarXQualTy XForAllTyXXHsPatSigTypeXHsPSXXHsWildCardBndrsXHsWC XXHsSigTypeXHsSigXXHsOuterTyVarBndrsXHsOuterExplicitXHsOuterImplicit XXLHsQTyVarsXHsQTvs XHsFieldBindXXPatXCoPatXSigPat XNPlusKPatXNPatXLitPat XSplicePatXViewPatXConPatXSumPat XTuplePatXListPatXBangPatXParPatXAsPatXLazyPatXVarPatXWildPat XXOverLitXOverLitXXLit XHsDoublePrim XHsFloatPrimXHsRat XHsInteger XHsWord64Prim XHsInt64Prim XHsWordPrim XHsIntPrimXHsInt XHsStringPrim XHsString XHsCharPrimXHsCharXXApplicativeArgXApplicativeArgManyXApplicativeArgOneXXParStmtBlock XParStmtBlockXXCmdXCmdWrapXCmdDoXCmdLetXCmdIf XCmdLamCaseXCmdCaseXCmdParXCmdLamXCmdApp XCmdArrForm XCmdArrAppXXStmtLRXRecStmt XTransStmtXParStmtXLetStmt XBodyStmtXApplicativeStmt XBindStmt XLastStmtXXGRHSXCGRHSXXGRHSsXCGRHSsXXMatchXCMatch XXMatchGroupXMGXXCmdTopXCmdTopXXQuoteXVarBrXTypBrXDecBrGXDecBrLXPatBrXExpBrXXUntypedSplice XQuasiQuoteXUntypedSpliceExprXXTupArgXMissingXPresentXXAmbiguousFieldOcc XAmbiguous XUnambiguousXXPragEXSCC XXDotFieldOcc XCDotFieldOccXXExprXPragEXBinTickXTickXStaticXProcXUntypedSplice XTypedSpliceXUntypedBracket XTypedBracket XArithSeqXExprWithTySig XProjection XGetField XRecordUpd XRecordCon XExplicitListXDoXLetXMultiIfXIfXCase XExplicitSumXExplicitTuple XSectionR XSectionLXParXNegAppXOpApp XAppTypeEXAppXLamCaseXLamXLitE XOverLitEXIPVar XOverLabelXRecSel XUnboundVarXVarXXModuleXCModuleXXInjectivityAnnXCInjectivityAnnXXRoleAnnotDeclXCRoleAnnotDecl XXAnnDecl XHsAnnotation XXWarnDeclXWarning XXWarnDecls XWarnings XXRuleBndr XRuleBndrSig XCRuleBndr XXRuleDeclXHsRule XXRuleDecls XCRuleDeclsXXForeignExportXCExportXXForeignImportXCImport XXForeignDeclXForeignExportXForeignImport XXDefaultDecl XCDefaultDecl XViaStrategyXNewtypeStrategyXAnyClassStrategyXStockStrategy XXDerivDecl XCDerivDecl XXInstDecl XTyFamInstD XDataFamInstD XClsInstD XXClsInstDecl XCClsInstDeclXXTyFamInstDeclXCTyFamInstDeclXXFamEqnXCFamEqn XXConDecl XConDeclH98 XConDeclGADTXXDerivClauseTys XDctMulti XDctSingleXXHsDerivingClauseXCHsDerivingClause XXHsDataDefn XCHsDataDefn XXFamilyDecl XCFamilyDeclXXFamilyResultSig XTyVarSig XCKindSigXNoSig XXTyClGroup XCTyClGroupXXFunDepXCFunDep XXTyClDecl XClassDecl XDataDeclXSynDeclXFamDecl XXSpliceDecl XSpliceDecl XXHsGroup XCHsGroupXXHsDecl XRoleAnnotDXDocDXSpliceDXRuleDXAnnD XWarningDXForDXDefD XKindSigDXSigDXValDXDerivDXInstDXTyClDXXStandaloneKindSigXStandaloneKindSig XXFixitySig XFixitySigXXSigXCompleteMatchSig XSCCFunSig XMinimalSig XSpecInstSigXSpecSig XInlineSigXFixSigXIdSig XClassOpSig XPatSynSigXTypeSigXXIPBindXCIPBind XXHsIPBindsXIPBinds XXPatSynBindXPSB XXHsBindsLR XPatSynBindXVarBindXPatBindXFunBind XXValBindsLR XValBindsXXHsLocalBindsLRXEmptyLocalBinds XHsIPBinds XHsValBindsLIdPIdPWrapXRecwrapXRecMapXRecmapXRecUnXRecunXRecAnnoXRecDataConCantHappen noExtFielddataConCantHappen$fDataDataConCantHappen$fEqDataConCantHappen$fOrdDataConCantHappen$fDataNoExtField$fEqNoExtField$fOrdNoExtField ModuleNamestableModuleNameCmp moduleNameFSmoduleNameString mkModuleNamemkModuleNameFSmoduleNameSlashesmoduleNameColonsparseModuleName$fNFDataModuleName$fDataModuleName$fOrdModuleName$fShowModuleName$fEqModuleName IfaceBndr IfaceCoercion IfaceTyLit IfaceTyCon IfaceType IfaceAppArgs ClsInstOrQC IsClsInstIsQCCtOriginFixedRuntimeRepOriginFixedRuntimeRepContext SkolemInfoSkolemInfoAnonunkSkol HasOccNameoccNameOccName mkVarOccFSmkRecFldSelOcc occNameFSIsBootInterfaceNotBootIsBootUnitModuleGenUnit GenModuleUnitId moduleUnit moduleNameIsDocLinelinelines_dualDocIsLinedualLineIsOutputdocWithContextHDocHLineOutputableBndrpprBndr pprPrefixOcc pprInfixOccbndrIsJoin_maybe BindingSite LambdaBindCaseBind CasePatBindLetBindPDoc OutputablePpdoc Outputableppr SDocContextSDC sdocStyle sdocColSchemesdocLastColoursdocShouldUseColorsdocDefaultDepthsdocLineLengthsdocCanUseUnicodesdocHexWordLiterals sdocPprDebugsdocPrintUnicodeSyntaxsdocPrintCaseAsLetsdocPrintTypecheckerElaborationsdocPrintAxiomIncompssdocPrintExplicitKindssdocPrintExplicitCoercionssdocPrintExplicitRuntimeRepssdocPrintExplicitForallssdocPrintPotentialInstancessdocPrintEqualityRelationssdocSuppressTickssdocSuppressTypeSignaturessdocSuppressTypeApplicationssdocSuppressIdInfosdocSuppressCoercionssdocSuppressCoercionTypessdocSuppressUnfoldingssdocSuppressVarKindssdocSuppressUniquessdocSuppressModulePrefixessdocSuppressStgExtssdocSuppressStgRepssdocErrorSpanssdocStarIsTypesdocLinearTypessdocListTuplePunssdocPrintTypeAbbreviationssdocUnitIdForUser QualifyName NameUnqualNameQualNameNotInScope1NameNotInScope2IsEmptyOrSingleton PromotedItemPromotedItemListSyntaxPromotedItemTupleSyntaxPromotedItemDataConPromotionTickContext PromTickCtxptcListTuplePunsptcPrintRedundantPromTicksQueryPromotionTickQueryQualifyPackageQueryQualifyModuleQueryQualifyName NamePprCtx QueryQualifyqueryQualifyNamequeryQualifyModulequeryQualifyPackagequeryPromotionTickDepth AllTheWayPartWay DefaultDepthPprStylePprUserPprDumpPprCodeisListEmptyOrSingletonreallyAlwaysQualifyNamesalwaysQualifyNamesneverQualifyNamesalwaysQualifyModulesneverQualifyModulesalwaysQualifyPackagesneverQualifyPackagesalwaysPrintPromTickreallyAlwaysQualify alwaysQualify neverQualifydefaultUserStyledefaultDumpStyle mkDumpStyledefaultErrStyle mkErrStylecmdlineParserStyle mkUserStyle withUserStyle withErrStylesetStyleColouredrunSDocdefaultSDocContexttraceSDocContext withPprStyle pprDeeper pprDeeperList pprSetDepth getPprStylesdocWithContext sdocOptionupdSDocContextqualName qualModule qualPackagepromTick queryQual codeStyle dumpStyle userStyle getPprDebug ifPprDebug whenPprDebug printSDoc printSDocLnbufLeftRenderSDocpprCoderenderWithContextshowSDocOneLineshowSDocUnsafe showPprUnsafepprDebugAndThen docToSDocword doublePrec angleBracketscparen blankLinedcolonarrowlollipoplarrowdarrowarrowtlarrowtarrowttlarrowttlambda underscoredotvbar forAllLitbullet unicodeSyntaxppWhenppUnless ppWhenOptionppUnlessOptioncolouredkeyword pprModuleName pprHsChar pprHsString pprHsBytesprimCharSuffixprimFloatSuffix primIntSuffixprimDoubleSuffixprimWordSuffixprimInt8SuffixprimWord8SuffixprimInt16SuffixprimWord16SuffixprimInt32SuffixprimWord32SuffixprimInt64SuffixprimWord64Suffix pprPrimChar pprPrimInt pprPrimWord pprPrimInt8 pprPrimInt16 pprPrimInt32 pprPrimInt64 pprPrimWord8 pprPrimWord16 pprPrimWord32 pprPrimWord64 pprPrefixVar pprInfixVarpprFastFilePathpprFilePathString pprWithCommas pprWithBarsspaceIfSingleQuote interppSP interpp'SP interpp'SP' pprQuotedListquotedListWithOrquotedListWithNor intWithCommasspeakNthspeakNspeakNOfpluralsingularisOrAredoOrDoes itsOrTheir thisOrThese hasOrHavebPutHDoc$fOutputableModuleName$fOutputableIntMap$fOutputableMap$fOutputableIntSet$fOutputableSet$fOutputableNonEmpty$fOutputableList$fOutputableDouble$fOutputableFloat$fOutputableWord$fOutputableWord64$fOutputableWord32$fOutputableWord16$fOutputableWord8$fOutputableInteger$fOutputableInt$fOutputableInt64$fOutputableInt32$fOutputableInt16$fOutputableInt8$fOutputableSDoc$fOutputablePenvVoid$fOutputablePenvSDoc$fOutputablePenvSCC$fOutputablePenvMap$fOutputablePenv(,,)$fOutputablePenv(,)$fOutputablePenvMaybe$fOutputablePenvList$fOutputablePenvPDoc$fIsOutputHDoc$fIsOutputHLine$fIsOutputSDoc $fIsLineHLine $fIsLineSDoc$fOutputablePenvSet$fOutputableExtension$fOutputableSerialized$fOutputableFingerprint$fOutputableFastString$fOutputable(,,,,,,)$fOutputable(,,,,,)$fOutputable(,,,,)$fOutputable(,,,)$fOutputable(,,)$fOutputableEither$fOutputableMaybe$fOutputable(,)$fOutputableUTCTime$fOutputable()$fOutputableOrdering$fOutputableBool$fIsStringSDoc$fOutputablePprStyle$fOutputableQualifyName $fIsDocHDoc $fIsDocSDoc$fOutputableSCC$fEqBindingSite$fOutputableLexicalFastString$fOutputableNonDetFastStringSignal UsageError CmdLineErrorPanicPprPanicSorryPprSorryInstallationError ProgramErrorPprProgramError showExceptionsafeShowExceptionshowGhcExceptionUnsafeshowGhcExceptionthrowGhcExceptionthrowGhcExceptionIOhandleGhcExceptionpprPanicpanicDocsorryDoc pgmErrorDoctryMostwithSignalHandlers callStackDocprettyCallStackDocassertPprPanic assertPprassertPprMaybe massertPpr assertPprM$fShowGhcException$fExceptionGhcExceptionpprTrace pprTraceM pprTraceDebug pprTraceWith pprTraceItpprTraceException pprSTrace warnPprTracepprTraceUserWarning IdDetailsIdInfo pprIdDetailsisCoVarDetails coVarDetails vanillaIdInfoPrimOp UnfoldingOptsupdateCaseScalingupdateCaseThresholdupdateVeryAggressiveupdateDictDiscountupdateFunAppDiscountupdateUseThresholdupdateCreationThresholddefaultUnfoldingOptsCallerCcFilterparseCallerCcFilter StaticPlugin LoadedPluginPlugins emptyPlugins ContainsHooks extractHooksHasHooksgetHooksHooks emptyHooks Uniquable getUnique uNIQUE_BITSmkUniqueGrimilygetKey incrUnique stepUnique mkLocalUniqueminLocalUniquemaxLocalUnique newTagUniquemkUnique unpkUniqueisValidKnownKeyUniquehasKeyeqUniqueltUniquenonDetCmpUniquepprUniqueAlways $fShowUnique$fOutputableUnique $fEqUnique$fUniquableUnique$fUniquableModuleName$fUniquableInt$fUniquableFastString NamedThing getOccNamegetNameName tidyNameOcc nameOccName setNameUnique nameUnique InvisTVBinderTcTyVarTyCoVarTyVar SpecificityVarBndrVar FunTyFlag ForAllTyFlagTcTyVarDetails MetaDetailsisConcreteTyVarisTyConableTyVar isMetaTyVarvanillaSkolemTvUnkpprTcTyVarDetailsCoreExprCoreBndrExpridName TyConRepNameTyCon tyConNamemkPrelTyConRepNametyConRepName_maybeisUnboxedTupleTyCon isTupleTyConTyThingmkAnIdmkATyCon MCoercionN CoercionN ThetaTypeRuntimeRepTypePredTypeMultScaled MCoercionTyLitUnivCoProvenanceCoSelCoercion mkNakedFunTymkNakedTyConTy mkForAllTy scaledThingpprTyVarpprTyLitpprCopprKind debugPprTypepprTypenoFreeVarsOfType NonDetUniqFM getNonDetUniqFMemptyUFM isNullUFMunitUFMunitDirectlyUFMzipToUFM listToUFMlistToUFM_DirectlylistToIdentityUFM listToUFM_CaddToUFM addListToUFMaddListToUFM_DirectlyaddToUFM_Directly addToUFM_C addToUFM_Acc addToUFM_LalterUFMaddListToUFM_C adjustUFMadjustUFM_Directly delFromUFMdelListFromUFMdelListFromUFM_DirectlydelFromUFM_DirectlyplusUFM plusUFM_C plusUFM_CD plusUFM_CD2mergeUFMplusMaybeUFM_C plusUFMListsequenceUFMListminusUFM minusUFM_C intersectUFMintersectUFM_C disjointUFMfoldUFMmapUFM mapMaybeUFMmapUFM_Directly filterUFMfilterUFM_Directly partitionUFMsizeUFMelemUFMelemUFM_Directly lookupUFMlookupUFM_DirectlylookupWithDefaultUFMlookupWithDefaultUFM_DirectlyufmToSet_DirectlyanyUFMallUFM seqEltsUFM nonDetEltsUFM nonDetKeysUFMnonDetStrictFoldUFMnonDetStrictFoldUFM_DirectlyMnonDetStrictFoldUFM_DirectlynonDetUFMToList ufmToIntMapunsafeIntMapToUFMunsafeCastUFMKey equalKeysUFM pprUniqFMpprUFMpprUFMWithKeys pluralUFM$fOutputableUniqFM$fMonoidUniqFM$fSemigroupUniqFM$fTraversableNonDetUniqFM$fFoldableNonDetUniqFM$fFunctorNonDetUniqFM $fDataUniqFM $fEqUniqFM$fFunctorUniqFMPairAnd fromMaybe$fAlternativeMaybe$fApplicativeMaybe $fMonoidMaybe$fSemigroupMaybe$fEqPair $fOrdPair $fShowPair $fFunctorPair$fFoldablePair$fTraversablePair $fDataPair $fEqMaybe $fOrdMaybe $fShowMaybe$fFunctorMaybe$fFoldableMaybe$fTraversableMaybe $fDataMaybe insertListinsertListWith deleteList foldRightfoldRightWithKey GHC.Lexeme startsConId startsConSym startsVarId startsVarSymisLexConisLexVarisLexIdisLexSym isLexConId isLexVarId isLexConSym isLexVarSymokVarOccokConOccokTcOcc okVarIdOcc okVarSymOcc okConIdOcc okConSymOccMaybeErr SucceededFailed firstJust firstJusts firstJustsM expectJust whenIsJustorElse rightToMaybe liftMaybeT tryMaybeT isSuccessfailME$fMonadMaybeErr$fApplicativeMaybeErr$fFunctorMaybeErr zipWith3M zipWith3M_ zipWith4MzipWithAndUnzipM mapAndUnzip3M mapAndUnzip4M mapAndUnzip5M mapAccumLMmapSndM concatMapM mapMaybeManyMallMorMfoldlM_whenMunlessM filterOutM partitionM MonadUniquegetUniqueSupplyM getUniqueM getUniquesMUniqSM UniqSupplymkSplitUniqSupplyinitUniqSupply uniqFromMasksplitUniqSupplylistSplitUniqSupplyuniqFromSupplyuniqsFromSupplytakeUniqFromSupplyinitUsinitUs_$fMonadFixUniqSM$fMonadFailUniqSM$fApplicativeUniqSM $fMonadUniqSM$fFunctorUniqSM$fMonadUniqueUniqSM LayoutInfoExplicitBraces VirtualBraces NoLayoutInfo HsUniToken HsNormalTok HsUnicodeTokHsTokenHsTok LHsUniTokenLHsToken$fDataHsUniToken $fDataHsToken hiVersionmAX_TUPLE_SIZEmAX_CTUPLE_SIZE mAX_SUM_SIZEmAX_REDUCTION_DEPTHmAX_SOLVER_ITERATIONS wORD64_SIZE fLOAT_SIZE dOUBLE_SIZEtARGET_MAX_CHAR UniqueMap UniqueSetIsMapKeyOfmapNullmapSize mapMember mapLookupmapFindWithDefaultmapEmpty mapSingleton mapInsert mapInsertWith mapDeletemapAlter mapAdjustmapUnionmapUnionWithKey mapDifferencemapIntersection mapIsSubmapOfmapMap mapMapWithKeymapFoldlmapFoldrmapFoldlWithKeymapFoldMapWithKey mapFiltermapFilterWithKeymapElemsmapKeys mapToList mapFromListmapFromListWithIsSetElemOfsetNullsetSize setMembersetEmpty setSingleton setInsert setDeletesetUnion setDifferencesetIntersection setIsSubsetOf setFiltersetFoldlsetFoldrsetElems setFromList setInsertList setDeleteList setUnions mapInsertList mapDeleteList mapUnions$fIsSetUniqueSet$fIsMapUniqueMap $fEqUniqueMap$fOrdUniqueMap$fShowUniqueMap$fFunctorUniqueMap$fFoldableUniqueMap$fTraversableUniqueMap $fEqUniqueSet$fOrdUniqueSet$fShowUniqueSet$fSemigroupUniqueSet$fMonoidUniqueSetOption FileOptionshowOpt $fEqOptionProfAuto NoProfAuto ProfAutoAll ProfAutoTopProfAutoExports ProfAutoCalls $fEqProfAuto$fEnumProfAutostderrSupportsAnsiColors expandToolDir findTopDir tryFindTopDir findToolDirExternalPluginSpecesp_lib esp_unit_id esp_moduleesp_argsparseExternalPluginSpec BackendNameNCGLLVMViaC JavaScript Interpreter NoBackend$fEqBackendName$fShowBackendNameStatestategetgetsputmodify evalState execStaterunState $fMonadState$fApplicativeState$fFunctorState AnyHpcUsageHpcInfo NoHpcInfohpcInfoTickCount hpcInfoHashhpcUsed emptyHpcInfo isHpcUsedSmallMutableArray SmallArray newSmallArraywriteSmallArrayfreezeSmallArrayunsafeFreezeSmallArrayindexSmallArray listToArray StringBufferbuflencurhGetStringBufferhGetStringBufferBlockhPutStringBufferappendStringBuffersstringToStringBufferstringBufferFromByteStringnextCharbidirectionalFormatCharscontainsBidirectionalFormatChar currentCharprevCharstepOn offsetBytesbyteDiffatEndfingerprintStringBufferatLinelexemeToStringlexemeToFastStringdecodePrevNCharsparseUnsignedInteger$fShowStringBufferStreamSYieldDoneEffectStreamrunStreamInternal runStreamyieldcollectconsumefromList mapAccumL_$fMonadStreamS$fApplicativeStreamS$fMonadIOStream $fMonadStream$fApplicativeStream$fFunctorStream$fFunctorStreamSBlockBlockCOBlockCCBlockOCBNilBMiddleBCatBSnocBConsMaybeOJustONothingO IndexedCOCO ExtensibilityOpenClosed isEmptyBlock emptyBlock blockCons blockSnoc blockJoinHead blockJoinTail blockJoin blockAppend blockConcat firstNodelastNodeblockSplitHeadblockSplitTail blockSplit blockToList blockFromListreplaceFirstNodereplaceLastNodemapBlock mapBlock' mapBlock3'foldBlockNodesFfoldBlockNodesB3foldBlockNodesB$fFunctorMaybeOMaybeUB NothingUBJustUB fromMaybeUB apMaybeUB fmapMaybeUBmaybeUBWeights uncondWeightcondBranchWeight switchWeight callWeightlikelyCondWeightunlikelyCondWeightinfoTablePenalty backEdgeBonusdefaultWeights parseWeightsToJsonjsonJsonDocJSNullJSBoolJSIntJSStringJSArrayJSObject renderJSONescapeJsonString $fToJsonInt $fToJsonList PsLocatedPsSpan psRealSpan psBufSpanPsLoc psRealLocpsBufPos RealLocatedLocated GenLocatedLUnhelpfulSpanReasonUnhelpfulNoLocationInfoUnhelpfulWiredInUnhelpfulInteractiveUnhelpfulGeneratedUnhelpfulOtherSrcSpan RealSrcSpan UnhelpfulSpanBufSpan bufSpanStart bufSpanEnd srcSpanFileSrcLoc RealSrcLoc UnhelpfulLocBufPosbufPosmkSrcLoc mkRealSrcLocleftmostColumn getBufPosnoSrcLocgeneratedSrcLocinteractiveSrcLocmkGeneralSrcLoc srcLocFile srcLocLine srcLocCol advanceSrcLoc advanceBufPos sortLocatedsortRealLocated lookupSrcLoc lookupSrcSpan removeBufSpan getBufSpan noSrcSpanwiredInSrcSpaninteractiveSrcSpangeneratedSrcSpanisGeneratedSrcSpan isNoSrcSpanmkGeneralSrcSpan srcLocSpanrealSrcLocSpan mkRealSrcSpan mkSrcSpancombineSrcSpanscombineRealSrcSpanscombineBufSpanssrcSpanFirstCharacter isGoodSrcSpan isOneLineSpanisZeroWidthSpan containsSpansrcSpanStartLinesrcSpanEndLinesrcSpanStartCol srcSpanEndCol srcSpanStart srcSpanEndrealSrcSpanStartrealSrcSpanEndsrcSpanFileName_maybesrcSpanToRealSrcSpanunhelpfulSpanFSpprUnhelpfulSpanReason pprUserSpanpprUserRealSpanunLocgetLocnoLocmkGeneralLocated combineLocsaddCLoc eqLocated cmpLocated cmpBufSpan pprLocatedpprLocatedAlwaysrightmost_smallestleftmost_smallestleftmost_largestspans isSubspanOfisRealSubspanOfgetRealSrcSpan unRealSrcSpanpsLocatedToLocated advancePsLocmkPsSpan psSpanStart psSpanEnd mkSrcSpanPs$fShowRealSrcLoc$fOutputableRealSrcLoc$fOutputableSrcLoc$fOutputableRealSrcSpan$fShowRealSrcSpan$fOrdRealSrcSpan$fToJsonRealSrcSpan$fDataRealSrcSpan$fSemigroupBufSpan$fOutputableUnhelpfulSpanReason$fOutputableSrcSpan$fNFDataSrcSpan$fToJsonSrcSpan $fDataSrcSpan$fOutputableGenLocated$fNFDataGenLocated$fOutputableGenLocated0 $fEqPsSpan $fOrdPsSpan $fShowPsSpan $fDataPsSpan $fEqPsLoc $fOrdPsLoc $fShowPsLoc$fEqGenLocated$fOrdGenLocated$fShowGenLocated$fDataGenLocated$fFunctorGenLocated$fFoldableGenLocated$fTraversableGenLocated $fEqSrcSpan $fShowSrcSpan$fEqUnhelpfulSpanReason$fShowUnhelpfulSpanReason $fEqBufSpan $fOrdBufSpan $fShowBufSpan $fDataBufSpan$fEqRealSrcSpan $fEqSrcLoc $fShowSrcLoc $fEqBufPos $fOrdBufPos $fShowBufPos $fDataBufPos$fEqRealSrcLoc$fOrdRealSrcLoc BinSrcSpan unBinSrcSpanBinSpan unBinSpan BinLocated unBinLocated SymbolTableFSTable DictionaryUserData ud_get_name ud_get_fsud_put_nonbinding_nameud_put_binding_name ud_put_fsFixedLengthEncoding unFixedLengthBinaryput_Bin BinHandleBinData dataHandle handleData getUserData setUserData withBinBufferunsafeUnpackBinBuffercastBinputAtgetAt openBinMemtellBinseekBin writeBinMem readBinMem readBinMemNfoldGetputBytegetByte putULEB128 getULEB128 putSLEB128 getSLEB128 forwardPut forwardPut_ forwardGetlazyPutlazyGet lazyPutMaybe lazyGetMaybe newReadState newWriteState noUserData putDictionary getDictionarygetDictFastString initFSTableputDictFastStringputFS$fNFDataBinData$fBinaryIntMap$fBinaryUnhelpfulSpanReason$fBinaryModuleName$fBinaryFingerprint$fBinaryFastString$fBinaryByteString $fBinaryBin $fBinaryRatio$fBinaryInteger$fBinaryDiffTime $fBinaryDay$fBinaryUTCTime$fBinaryEither $fBinaryMaybe$fBinaryMaybe0$fBinary(,,,,,,)$fBinary(,,,,,)$fBinary(,,,,) $fBinary(,,,) $fBinary(,,) $fBinary(,) $fBinaryArray$fBinaryNonEmpty $fBinarySet $fBinaryList $fBinaryInt $fBinaryChar $fBinaryBool $fBinary() $fBinaryInt64 $fBinaryInt32 $fBinaryInt16 $fBinaryInt8$fBinaryWord64$fBinaryWord32$fBinaryWord16 $fBinaryWord8$fBinaryFixedLengthEncoding$fBinaryFixedLengthEncoding0$fBinaryFixedLengthEncoding1$fBinaryFixedLengthEncoding2$fBinaryBinData$fBinaryBinSpan$fBinaryBinSrcSpan$fBinaryBinLocated$fEqFixedLengthEncoding$fOrdFixedLengthEncoding$fShowFixedLengthEncoding$fEqBin$fOrdBin $fShowBin $fBoundedBin$fBinaryLexicalFastString$fBinaryNonDetFastStringEnumSetmemberinsertdelete difference$fBinaryEnumSet$fSemigroupEnumSet$fMonoidEnumSet$fNFDataEnumSetgetSomeTypeRep$fBinarySerialized$fBinaryTypeLitSort$fBinaryKindRep$fBinaryRuntimeRep$fBinaryVecElem$fBinaryVecCount$fBinaryTypeRep$fBinarySomeTypeRep $fBinaryTyConExtensibleFieldsgetExtensibleFields FieldNameemptyExtensibleFields readField readFieldWith writeFieldwriteFieldWith deleteField$fNFDataExtensibleFields$fBinaryExtensibleFieldsUniqDFM emptyUDFMunitUDFM addToUDFMaddToUDFM_DirectlyaddToUDFM_C_Directly addToUDFM_C addListToUDFM delFromUDFM plusUDFM_CplusUDFM lookupUDFMlookupUDFM_DirectlyelemUDFMfoldUDFMnonDetStrictFoldUDFMeltsUDFM filterUDFMfilterUDFM_DirectlyudfmRestrictKeysudfmRestrictKeysSet udfmToList equalKeysUDFM isNullUDFMsizeUDFM intersectUDFMudfmIntersectUFM disjointUDFMdisjointUdfmUfm minusUDFM udfmMinusUFM ufmMinusUDFM partitionUDFMdelListFromUDFM udfmToUfm listToUDFMlistToUDFM_Directly adjustUDFMadjustUDFM_Directly alterUDFMmapUDFM mapMaybeUDFManyUDFMallUDFMalwaysUnsafeUfmToUdfmunsafeCastUDFMKey pprUniqDFMpprUDFM $fEqTaggedVal$fOutputableUniqDFM$fTraversableUniqDFM$fFoldableUniqDFM $fDataUniqDFM$fFunctorUniqDFM$fDataTaggedVal$fFunctorTaggedVal$fFoldableTaggedVal$fTraversableTaggedValDFastStringEnv FastStringEnv emptyFsEnv unitFsEnv extendFsEnvextendFsEnvList lookupFsEnv alterFsEnvmkFsEnv elemFsEnv plusFsEnv plusFsEnv_C extendFsEnv_CmapFsEnvextendFsEnv_AccextendFsEnvList_C delFromFsEnvdelListFromFsEnv filterFsEnvlookupFsEnv_NF emptyDFsEnv dFsEnvEltsmkDFsEnv lookupDFsEnvCostCentreIndexunCostCentreIndexCostCentreStatenewCostCentreState getCCIndex$fEqCostCentreIndex$fOrdCostCentreIndex$fDataCostCentreIndex$fBinaryCostCentreIndexUniqSet emptyUniqSet unitUniqSet mkUniqSetaddOneToUniqSetaddListToUniqSetdelOneFromUniqSetdelOneFromUniqSet_DirectlydelListFromUniqSetdelListFromUniqSet_Directly unionUniqSetsunionManyUniqSets minusUniqSetintersectUniqSetsdisjointUniqSetsrestrictUniqSetToUFMuniqSetMinusUFMuniqSetMinusUDFMelementOfUniqSetelemUniqSet_Directly filterUniqSetfilterUniqSet_DirectlypartitionUniqSet uniqSetAny uniqSetAll sizeUniqSetisEmptyUniqSet lookupUniqSetlookupUniqSet_DirectlynonDetEltsUniqSetnonDetKeysUniqSetnonDetStrictFoldUniqSet mapUniqSet getUniqSetunsafeUFMToUniqSet pprUniqSet$fOutputableUniqSet $fEqUniqSet $fDataUniqSet$fSemigroupUniqSet$fMonoidUniqSetUniqDSet emptyUniqDSet unitUniqDSet mkUniqDSetaddOneToUniqDSetaddListToUniqDSetdelOneFromUniqDSetdelListFromUniqDSetunionUniqDSetsunionManyUniqDSets minusUniqDSetuniqDSetMinusUniqSetintersectUniqDSetsuniqDSetIntersectUniqSetnonDetStrictFoldUniqDSetelementOfUniqDSetfilterUniqDSet sizeUniqDSetisEmptyUniqDSetlookupUniqDSetuniqDSetToListpartitionUniqDSet mapUniqDSet getUniqDSet pprUniqDSet$fOutputableUniqDSet $fEqUniqDSet$fDataUniqDSet StringLiteralsl_stsl_fssl_tcFractionalExponentBaseBase2Base10 FractionalLitFLfl_textfl_negfl_signifl_exp fl_exp_base IntegralLitILil_textil_negil_value SourceText NoSourceTextpprWithSourceText mkIntegralLitnegateIntegralLitmkFractionalLitfractionalLitFromRationalrationalFromFractionalLitmkTHFractionalLitnegateFractionalLitintegralFractionalLitmkSourceFractionalLit$fBinarySourceText$fOutputableSourceText$fOutputableIntegralLit$fOrdIntegralLit$fEqIntegralLit$fOutputableFractionalLit$fOrdFractionalLit$fEqFractionalLit$fBinaryStringLiteral$fOutputableStringLiteral$fEqStringLiteral$fDataStringLiteral$fDataFractionalLit$fShowFractionalLit$fEqFractionalExponentBase$fOrdFractionalExponentBase$fDataFractionalExponentBase$fShowFractionalExponentBase$fDataIntegralLit$fShowIntegralLit$fDataSourceText$fShowSourceText$fEqSourceTextIfaceTrustInfoSafeHaskellModeSf_None Sf_UnsafeSf_TrustworthySf_SafeSf_SafeInferred Sf_Ignore IsSafeImport getSafeMode setSafeModenoIfaceTrustInfo$fOutputableSafeHaskellMode$fShowSafeHaskellMode$fBinaryIfaceTrustInfo$fOutputableIfaceTrustInfo$fEqSafeHaskellModeOrdListSnocOLConsOLNilOLnilOLunitOLsnocOLconsOLconcatOLheadOLlastOLisNilOLappOLfromOL fromOLReversemapOLmapOL'foldrOLfoldlOLtoOL reverseOL strictlyEqOL strictlyOrdOL$fTraversableOrdList$fFoldableOrdList$fMonoidOrdList$fSemigroupOrdList$fOutputableOrdList$fFunctorOrdListEdgeTypeForwardCrossBackwardSelfLoopNode DigraphNode node_payloadnode_keynode_dependenciesGraphgraphFromEdgedVerticesOrdgraphFromEdgedVerticesUniq findCyclestronglyConnCompG$stronglyConnCompFromEdgedVerticesOrd%stronglyConnCompFromEdgedVerticesUniq%stronglyConnCompFromEdgedVerticesOrdR&stronglyConnCompFromEdgedVerticesUniqRtopologicalSortG reachableG outgoingG reachablesG allReachableallReachableCyclic hasVertexG verticesGedgesG transposeGemptyG classifyEdgesgraphFromVerticesAndAdjacency$fOutputableEdge$fOutputableNode$fOutputableGraph$fOutputableEdgeType$fEqTime $fOrdTime $fNumTime$fOutputableTime $fEqEdgeType $fOrdEdgeTypeFieldSelectorsNoFieldSelectorsDuplicateRecordFieldsNoDuplicateRecordFields FieldLabelflLabelflHasDuplicateRecordFieldsflHasFieldSelector flSelector FieldLabelEnvfieldSelectorOccNamefieldLabelPrintableNameflIsOverloaded$fUniquableFieldLabelString$fOutputableFieldLabelString$fNFDataDuplicateRecordFields!$fOutputableDuplicateRecordFields$fBinaryDuplicateRecordFields$fNFDataFieldSelectors$fOutputableFieldSelectors$fBinaryFieldSelectors$fBinaryFieldLabel$fNFDataFieldLabel$fOutputableFieldLabel$fHasOccNameFieldLabel$fDataFieldLabel$fEqFieldLabel$fShowFieldSelectors$fEqFieldSelectors$fDataFieldSelectors$fShowDuplicateRecordFields$fEqDuplicateRecordFields$fDataDuplicateRecordFieldsAssocgetNth unionListsOrd unionLists minusListassocDefaultUsingassoc assocDefault assocUsing assocMaybe hasNoDups equivClasses removeDupsnubOrdBy findDupsEqisInisn'tInBagemptyBagunitBag lengthBagelemBag unionManyBags unionBagsconsBagsnocBag isEmptyBagisSingletonBag filterBag filterBagMallBaganyBaganyBagM concatBag catBagMaybes partitionBagpartitionBagWithfoldBagmapBag concatMapBagconcatMapBagPair mapMaybeBagmapBagMmapBagM_ flatMapBagMflatMapBagPairMmapAndUnzipBagM mapAccumBagL mapAccumBagLM listToBag nonEmptyToBag bagToListunzipBag headMaybe $fMonoidBag$fSemigroupBag $fIsListBag $fDataBag$fOutputableBag $fFoldableBag $fFunctorBag$fTraversableBag LexicalFixityPrefixInfixFixityDirectionInfixLInfixRInfixNFixity maxPrecedence minPrecedence defaultFixity negateFixity funTyFixity compareFixity$fBinaryFixityDirection$fOutputableFixityDirection$fBinaryFixity $fEqFixity$fOutputableFixity$fOutputableLexicalFixity$fDataLexicalFixity$fEqLexicalFixity $fDataFixity$fEqFixityDirection$fDataFixityDirectionHsDocStringChunkLHsDocStringChunkHsDocStringDecoratorHsDocStringNextHsDocStringPreviousHsDocStringNamedHsDocStringGroup HsDocStringMultiLineDocStringNestedDocStringGeneratedDocString LHsDocStringpprWithDocStringmkHsDocStringChunk mkHsDocStringChunkUtf8ByteString unpackHDSCmkGeneratedHsDocStringisEmptyDocStringdocStringChunkspprHsDocStringpprHsDocStringsexactPrintHsDocStringrenderHsDocStringrenderHsDocStrings$fBinaryHsDocStringDecorator$fNFDataHsDocStringDecorator $fOutputableHsDocStringDecorator$fOutputableHsDocStringChunk$fBinaryHsDocStringChunk$fBinaryHsDocString$fNFDataHsDocString$fOutputableHsDocString$fEqHsDocString$fDataHsDocString$fShowHsDocString$fEqHsDocStringChunk$fOrdHsDocStringChunk$fDataHsDocStringChunk$fShowHsDocStringChunk$fNFDataHsDocStringChunk$fEqHsDocStringDecorator$fOrdHsDocStringDecorator$fShowHsDocStringDecorator$fDataHsDocStringDecoratorpFstpSndunPairtoPairswappLiftFstpLiftSnd$fOutputablePair $fMonoidPair$fSemigroupPair$fApplicativePair WarningFlagOpt_WarnDuplicateExportsOpt_WarnDuplicateConstraintsOpt_WarnRedundantConstraintsOpt_WarnHiShadowsOpt_WarnImplicitPreludeOpt_WarnIncompletePatternsOpt_WarnIncompleteUniPatterns Opt_WarnIncompletePatternsRecUpdOpt_WarnOverflowedLiteralsOpt_WarnEmptyEnumerationsOpt_WarnMissingFieldsOpt_WarnMissingImportListOpt_WarnMissingMethodsOpt_WarnMissingSignaturesOpt_WarnMissingLocalSignaturesOpt_WarnNameShadowingOpt_WarnOverlappingPatternsOpt_WarnTypeDefaultsOpt_WarnMonomorphismOpt_WarnUnusedTopBindsOpt_WarnUnusedLocalBindsOpt_WarnUnusedPatternBindsOpt_WarnUnusedImportsOpt_WarnUnusedMatchesOpt_WarnUnusedTypePatternsOpt_WarnUnusedForallsOpt_WarnUnusedRecordWildcardsOpt_WarnRedundantBangPatterns Opt_WarnRedundantRecordWildcardsOpt_WarnWarningsDeprecationsOpt_WarnDeprecatedFlags!Opt_WarnMissingMonadFailInstancesOpt_WarnSemigroupOpt_WarnDodgyExportsOpt_WarnDodgyImportsOpt_WarnOrphansOpt_WarnAutoOrphansOpt_WarnIdentities Opt_WarnTabsOpt_WarnUnrecognisedPragmasOpt_WarnMisplacedPragmasOpt_WarnDodgyForeignImportsOpt_WarnUnusedDoBindOpt_WarnWrongDoBind)Opt_WarnAlternativeLayoutRuleTransitionalOpt_WarnUnsafe Opt_WarnSafeOpt_WarnTrustworthySafeOpt_WarnMissedSpecsOpt_WarnAllMissedSpecs%Opt_WarnUnsupportedCallingConventionsOpt_WarnUnsupportedLlvmVersionOpt_WarnMissedExtraSharedLibOpt_WarnInlineRuleShadowingOpt_WarnTypedHolesOpt_WarnPartialTypeSignatures!Opt_WarnMissingExportedSignatures$Opt_WarnUntickedPromotedConstructorsOpt_WarnDerivingTypeableOpt_WarnDeferredTypeErrors#Opt_WarnDeferredOutOfScopeVariables"Opt_WarnNonCanonicalMonadInstances&Opt_WarnNonCanonicalMonadFailInstances#Opt_WarnNonCanonicalMonoidInstances'Opt_WarnMissingPatternSynonymSignatures Opt_WarnUnrecognisedWarningFlags$Opt_WarnSimplifiableClassConstraintsOpt_WarnCPPUndefOpt_WarnUnbangedStrictPatternsOpt_WarnMissingHomeModulesOpt_WarnPartialFieldsOpt_WarnMissingExportListOpt_WarnInaccessibleCodeOpt_WarnStarIsTypeOpt_WarnStarBinderOpt_WarnImplicitKindVarsOpt_WarnSpaceAfterBang!Opt_WarnMissingDerivingStrategies"Opt_WarnPrepositiveQualifiedModuleOpt_WarnUnusedPackagesOpt_WarnInferredSafeImportsOpt_WarnMissingSafeHaskellMode Opt_WarnCompatUnqualifiedImportsOpt_WarnDerivingDefaultsOpt_WarnInvalidHaddock%Opt_WarnOperatorWhitespaceExtConflictOpt_WarnOperatorWhitespaceOpt_WarnAmbiguousFieldsOpt_WarnImplicitLiftOpt_WarnMissingKindSignatures/Opt_WarnMissingExportedPatternSynonymSignatures Opt_WarnRedundantStrictnessFlagsOpt_WarnForallIdentifier,Opt_WarnUnicodeBidirectionalFormatCharactersOpt_WarnGADTMonoLocalBindsOpt_WarnTypeEqualityOutOfScope%Opt_WarnTypeEqualityRequiresOperatorsOpt_WarnLoopySuperclassSolve GeneralFlagOpt_DumpToFileOpt_DumpWithWaysOpt_D_dump_minimal_importsOpt_DoCoreLintingOpt_DoLinearCoreLintingOpt_DoStgLintingOpt_DoCmmLintingOpt_DoAsmLintingOpt_DoAnnotationLintingOpt_DoBoundsCheckingOpt_NoLlvmMangler Opt_FastLlvmOpt_NoTypeableBindsOpt_DistinctConstructorTablesOpt_InfoTableMapOpt_InfoTableMapWithFallbackOpt_InfoTableMapWithStackOpt_WarnIsErrorOpt_ShowWarnGroupsOpt_HideSourcePathsOpt_PrintExplicitForallsOpt_PrintExplicitKindsOpt_PrintExplicitCoercionsOpt_PrintExplicitRuntimeRepsOpt_PrintEqualityRelationsOpt_PrintAxiomIncompsOpt_PrintUnicodeSyntaxOpt_PrintExpandedSynonymsOpt_PrintPotentialInstances Opt_PrintRedundantPromotionTicksOpt_PrintTypecheckerElaboration Opt_CallArityOpt_ExitificationOpt_StrictnessOpt_LateDmdAnalOpt_KillAbsenceOpt_KillOneShotOpt_FullLaziness Opt_FloatInOpt_LocalFloatOutOpt_LocalFloatOutTopLevelOpt_LateSpecialiseOpt_SpecialiseOpt_SpecialiseAggressivelyOpt_CrossModuleSpecialiseOpt_PolymorphicSpecialisationOpt_InlineGenericsOpt_InlineGenericsAggressively Opt_StaticArgumentTransformationOpt_CSE Opt_StgCSEOpt_StgLiftLamsOpt_LiberateCaseOpt_SpecConstrOpt_SpecConstrKeenOpt_DoLambdaEtaExpansionOpt_IgnoreAssertsOpt_DoEtaReduction Opt_CaseMergeOpt_CaseFoldingOpt_UnboxStrictFieldsOpt_UnboxSmallStrictFieldsOpt_DictsCheapOpt_EnableRewriteRulesOpt_EnableThSpliceWarnings Opt_RegsGraphOpt_RegsIterativeOpt_PedanticBottoms Opt_LlvmTBAAOpt_LlvmFillUndefWithGarbageOpt_IrrefutableTuples Opt_CmmSinkOpt_CmmStaticPredOpt_CmmElimCommonBlocksOpt_CmmControlFlowOpt_AsmShortcuttingOpt_OmitYieldsOpt_FunToThunkOpt_DictsStrictOpt_DmdTxDictSelOpt_LoopificationOpt_CfgBlocklayoutOpt_WeightlessBlocklayout Opt_CprAnalOpt_WorkerWrapperOpt_WorkerWrapperUnliftOpt_SolveConstantDictsOpt_AlignmentSanitisationOpt_CatchNonexhaustiveCasesOpt_NumConstantFoldingOpt_CoreConstantFoldingOpt_FastPAPCallsOpt_DoTagInferenceChecksOpt_SimplPreInliningOpt_IgnoreInterfacePragmasOpt_OmitInterfacePragmasOpt_ExposeAllUnfoldingsOpt_WriteInterface Opt_WriteHieOpt_AutoSccsOnIndividualCafsOpt_ProfCountEntriesOpt_ProfLateInlineCcsOpt_ProfLateCcsOpt_ProfManualCcsOpt_PpOpt_ForceRecompOpt_IgnoreOptimChangesOpt_IgnoreHpcChangesOpt_ExcessPrecisionOpt_EagerBlackHoling Opt_NoHsMainOpt_SplitSections Opt_StgStatsOpt_HideAllPackagesOpt_HideAllPluginPackagesOpt_PrintBindResult Opt_HaddockOpt_HaddockOptionsOpt_BreakOnExceptionOpt_BreakOnErrorOpt_PrintEvldWithShowOpt_PrintBindContentsOpt_GenManifestOpt_EmbedManifestOpt_SharedImplibOpt_BuildingCabalPackageOpt_IgnoreDotGhciOpt_GhciSandboxOpt_GhciHistoryOpt_GhciLeakCheckOpt_ValidateHieOpt_LocalGhciHistoryOpt_NoItOpt_HelpfulErrorsOpt_DeferTypeErrorsOpt_DeferTypedHolesOpt_DeferOutOfScopeVariablesOpt_PICOpt_PIEOpt_PICExecutableOpt_ExternalDynamicRefs Opt_TickyOpt_Ticky_Allocd Opt_Ticky_LNEOpt_Ticky_Dyn_Thunk Opt_Ticky_Tag Opt_Ticky_APOpt_CmmThreadSanitizer Opt_RPathOpt_RelativeDynlibPathsOpt_CompactUnwindOpt_HpcOpt_FamAppCacheOpt_ExternalInterpreterOpt_OptimalApplicativeDoOpt_VersionMacrosOpt_WholeArchiveHsLibsOpt_SingleLibFolderOpt_ExposeInternalSymbols Opt_KeepCAFs Opt_KeepGoing Opt_ByteCodeOpt_ByteCodeAndObjectCode Opt_LinkRtsOpt_ErrorSpansOpt_DeferDiagnosticsOpt_DiagnosticsShowCaretOpt_PprCaseAsLetOpt_PprShowTicksOpt_ShowHoleConstraintsOpt_ShowValidHoleFitsOpt_SortValidHoleFitsOpt_SortBySizeHoleFitsOpt_SortBySubsumHoleFitsOpt_AbstractRefHoleFitsOpt_UnclutterValidHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowDocsOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowMatchesOfHoleFitsOpt_ShowLoadedModulesOpt_HexWordLiteralsOpt_SuppressCoercionsOpt_SuppressCoercionTypesOpt_SuppressVarKindsOpt_SuppressModulePrefixesOpt_SuppressTypeApplicationsOpt_SuppressIdInfoOpt_SuppressUnfoldingsOpt_SuppressTypeSignaturesOpt_SuppressUniquesOpt_SuppressStgExtsOpt_SuppressStgRepsOpt_SuppressTicksOpt_SuppressTimestampsOpt_SuppressCoreSizesOpt_ShowErrorContextOpt_AutoLinkPackagesOpt_ImplicitImportQualifiedOpt_KeepHscppFilesOpt_KeepHiDiffsOpt_KeepHcFilesOpt_KeepSFilesOpt_KeepTmpFilesOpt_KeepRawTokenStreamOpt_KeepLlvmFilesOpt_KeepHiFilesOpt_KeepOFilesOpt_BuildDynamicTooOpt_WriteIfSimplifiedCore Opt_UseBytecodeRatherThanObjectsOpt_DistrustAllPackagesOpt_PackageTrustOpt_PluginTrustworthyOpt_G_NoStateHackOpt_G_NoOptCoercionDumpFlagOpt_D_dump_cmmOpt_D_dump_cmm_from_stgOpt_D_dump_cmm_rawOpt_D_dump_cmm_verbose_by_procOpt_D_dump_cmm_verboseOpt_D_dump_cmm_cfgOpt_D_dump_cmm_cbeOpt_D_dump_cmm_switchOpt_D_dump_cmm_procOpt_D_dump_cmm_spOpt_D_dump_cmm_sinkOpt_D_dump_cmm_cafOpt_D_dump_cmm_procmapOpt_D_dump_cmm_splitOpt_D_dump_cmm_infoOpt_D_dump_cmm_cpsOpt_D_dump_cmm_thread_sanitizerOpt_D_dump_cfg_weightsOpt_D_dump_asmOpt_D_dump_asm_nativeOpt_D_dump_asm_livenessOpt_D_dump_asm_regallocOpt_D_dump_asm_regalloc_stagesOpt_D_dump_asm_conflictsOpt_D_dump_asm_statsOpt_D_dump_c_backendOpt_D_dump_llvm Opt_D_dump_jsOpt_D_dump_core_statsOpt_D_dump_deriv Opt_D_dump_dsOpt_D_dump_ds_preoptOpt_D_dump_foreignOpt_D_dump_inliningsOpt_D_dump_verbose_inliningsOpt_D_dump_rule_firingsOpt_D_dump_rule_rewritesOpt_D_dump_simpl_traceOpt_D_dump_occur_analOpt_D_dump_parsedOpt_D_dump_parsed_ast Opt_D_dump_rnOpt_D_dump_rn_astOpt_D_dump_simplOpt_D_dump_simpl_iterationsOpt_D_dump_specOpt_D_dump_prepOpt_D_dump_late_ccOpt_D_dump_stg_from_coreOpt_D_dump_stg_unarisedOpt_D_dump_stg_cgOpt_D_dump_stg_tagsOpt_D_dump_stg_finalOpt_D_dump_call_arityOpt_D_dump_exitifyOpt_D_dump_stranalOpt_D_dump_str_signaturesOpt_D_dump_cpranalOpt_D_dump_cpr_signatures Opt_D_dump_tcOpt_D_dump_tc_astOpt_D_dump_hieOpt_D_dump_typesOpt_D_dump_rulesOpt_D_dump_cseOpt_D_dump_worker_wrapperOpt_D_dump_rn_traceOpt_D_dump_rn_statsOpt_D_dump_opt_cmmOpt_D_dump_simpl_statsOpt_D_dump_cs_traceOpt_D_dump_tc_traceOpt_D_dump_ec_traceOpt_D_dump_if_traceOpt_D_dump_splicesOpt_D_th_dec_fileOpt_D_dump_BCOsOpt_D_dump_tickedOpt_D_dump_rttiOpt_D_source_statsOpt_D_verbose_stg2stg Opt_D_dump_hiOpt_D_dump_hi_diffsOpt_D_dump_mod_cyclesOpt_D_dump_mod_mapOpt_D_dump_timings!Opt_D_dump_view_pattern_commoningOpt_D_verbose_core2coreOpt_D_dump_debugOpt_D_dump_jsonOpt_D_ppr_debugOpt_D_no_debug_outputOpt_D_dump_faststringsOpt_D_faststring_statsOpt_D_ipe_statsLanguage Haskell98 Haskell2010GHC2021getDumpFlagFromenabledIfVerboseoptimisationFlags codeGenFlags warnFlagNames warningGroupswarningHierarchiessmallestWarningGroupsstandardWarnings minusWOpts minusWallOptsminusWeverythingOptsminusWcompatOptsunusedBindsFlags$fNFDataLanguage$fBinaryLanguage$fOutputableLanguage$fEqWarningFlag$fOrdWarningFlag$fShowWarningFlag$fEnumWarningFlag$fEqGeneralFlag$fShowGeneralFlag$fEnumGeneralFlag $fEqDumpFlag$fShowDumpFlag$fEnumDumpFlag $fEqLanguage$fEnumLanguage$fShowLanguage$fBoundedLanguage UnitPprInfo unitPprIdunitPprPackageNameunitPprPackageVersionunitPprComponentName$fOutputableUnitPprInfoOperatorWhitespaceOccurrence#OperatorWhitespaceOccurrence_Prefix#OperatorWhitespaceOccurrence_Suffix'OperatorWhitespaceOccurrence_TightInfixOperatorWhitespaceSymbol&OperatorWhitespaceSymbol_PrefixPercent%OperatorWhitespaceSymbol_PrefixDollar+OperatorWhitespaceSymbol_PrefixDollarDollarpprOperatorWhitespaceSymbolRank ArbitraryRank LimitedRankMonoTypeRankZeroMonoTypeTyConArgMonoTypeSynArgMonoTypeConstraintMustBeMonoType$fOutputableRankUniqSDFM emptyUSDFM lookupUSDFM equateUSDFM addToUSDFM traverseUSDFM$fOutputableShared$fOutputableUniqSDFMUniqMap getUniqMap emptyUniqMap isNullUniqMap unitUniqMap listToUniqMaplistToUniqMap_C addToUniqMapaddListToUniqMapaddToUniqMap_CaddToUniqMap_AccaddToUniqMap_L alterUniqMapaddListToUniqMap_C adjustUniqMapdelFromUniqMapdelListFromUniqMap plusUniqMap plusUniqMap_CplusMaybeUniqMap_CplusUniqMapList minusUniqMapintersectUniqMapintersectUniqMap_CdisjointUniqMap mapUniqMap filterUniqMappartitionUniqMap sizeUniqMap elemUniqMap lookupUniqMaplookupWithDefaultUniqMap anyUniqMap allUniqMapnonDetEltsUniqMapnonDetFoldUniqMap$fNFDataUniqMap$fOutputableUniqMap$fMonoidUniqMap$fSemigroupUniqMap $fDataUniqMap $fEqUniqMap$fFunctorUniqMapModuleWithIsBootModuleNameWithIsBoot GenWithIsBootGWIBgwib_mod gwib_isBootDefinite unDefinite DefUnitIdunitIdFSInstantiationsGenInstantiationsInstantiatedUnitGenInstantiatedUnit instUnitFS instUnitKeyinstUnitInstanceOf instUnitInsts instUnitHolesRealUnitVirtUnitHoleUnitUnitKeyIsUnitIdunitFSInstantiatedModuleHomeUnitModuleInstalledModule moduleUnitIdmkModule pprModulepprInstantiatedModule isHoleUnit stableUnitCmppprUnitunitFreeModuleHolesmoduleFreeHolesmkInstantiatedUnit mkVirtUnitmkInstantiatedUnitHashfsToUnit unitString stringToUnit mapGenUnitmapInstantiationstoUnitId virtualUnitIdunitIsDefinite unitIdStringstringToUnitId primUnitId bignumUnitId baseUnitId rtsUnitId thisGhcUnitIdinteractiveUnitIdthUnitIdthUnitprimUnit bignumUnitbaseUnitrtsUnit thisGhcUnitinteractiveUnit mainUnitIdmainUnitisInteractiveModulewiredInUnitIds$fBinaryIsBootInterface$fNFDataGenModule$fBinaryGenModule$fIsUnitIdUnitKey$fOutputableUnitId$fUniquableUnitId $fOrdUnitId $fEqUnitId$fBinaryUnitId$fIsUnitIdUnitId$fOutputableGenModule$fUniquableGenUnit $fEqGenUnit$fOrdGenInstantiatedUnit$fEqGenInstantiatedUnit$fIsUnitIdGenUnit$fBinaryGenInstantiatedUnit$fOutputableGenInstantiatedUnit$fOutputableGenModule0$fBinaryGenUnit $fShowGenUnit$fOutputableGenUnit$fNFDataGenUnit $fDataGenUnit $fOrdGenUnit$fOutputableGenModule1$fUniquableGenModule$fOutputableGenWithIsBoot$fBinaryGenWithIsBoot$fEqGenWithIsBoot$fOrdGenWithIsBoot$fShowGenWithIsBoot$fFunctorGenWithIsBoot$fFoldableGenWithIsBoot$fTraversableGenWithIsBoot$fFunctorDefinite $fEqDefinite $fOrdDefinite$fOutputableDefinite$fBinaryDefinite$fUniquableDefinite$fIsUnitIdDefinite $fDataUnitId $fEqGenModule$fOrdGenModule$fDataGenModule$fFunctorGenModule ModLocation ml_hs_file ml_hi_fileml_dyn_hi_file ml_obj_fileml_dyn_obj_file ml_hie_file addBootSuffixremoveBootSuffixaddBootSuffix_maybeaddBootSuffixLocn_maybeaddBootSuffixLocnaddBootSuffixLocnOut$fOutputableModLocation$fShowModLocationInstalledModuleEnvDModuleNameEnv ModuleNameEnv ModuleSet ModuleEnvfilterModuleEnvmapMaybeModuleEnv elemModuleEnvextendModuleEnvextendModuleEnvWithextendModuleEnvListextendModuleEnvList_CplusModuleEnv_CdelModuleEnvList delModuleEnv plusModuleEnvlookupModuleEnvlookupWithDefaultModuleEnv mapModuleEnvpartitionModuleEnv mkModuleEnvemptyModuleEnv moduleEnvKeys moduleEnvEltsmoduleEnvToList unitModuleEnvisEmptyModuleEnv mkModuleSetextendModuleSetextendModuleSetListemptyModuleSetisEmptyModuleSet moduleSetElts elemModuleSetintersectModuleSetminusModuleSet delModuleSetunionModuleSetunionManyModuleSets unitModuleSetemptyInstalledModuleEnvlookupInstalledModuleEnvextendInstalledModuleEnvfilterInstalledModuleEnvdelInstalledModuleEnvinstalledModuleEnvEltsmergeInstalledModuleEnvplusInstalledModuleEnv $fOrdNDModule$fOutputableNDModule$fOutputableModuleEnv$fOutputableInstalledModuleEnv $fEqNDModule HasModule getModuleContainsModule extractModulemoduleIsDefinitemoduleStableStringstableModuleCmpinstalledModuleEqgetModuleInstantiationgetUnitInstantiationsuninstantiateInstantiatedUnituninstantiateInstantiatedModule isHoleModule mkHoleModuleCType CLabelString CCallConvCApiConv StdCallConv PrimCallConvJavaScriptCallConv CCallTarget StaticTarget DynamicTarget CCallSpec CExportSpec CExportStaticSafetyPlaySafePlayInterruptible PlayRisky ForeignCallCCallisSafeForeignCallplaySafeplayInterruptibleisDynamicTargetdefaultCCallConvccallConvToIntccallConvAttributepprCLabelStringisCLabelString$fBinarySafety$fOutputableSafety$fBinaryCCallConv$fOutputableCCallConv$fBinaryCCallTarget$fBinaryCCallSpec$fOutputableCCallSpec$fBinaryForeignCall$fOutputableForeignCall$fBinaryCExportSpec$fOutputableCExportSpec$fBinaryHeader$fOutputableHeader $fBinaryCType$fOutputableCType $fEqCType $fDataCType $fEqHeader $fDataHeader$fDataCExportSpec$fEqForeignCall $fEqCCallSpec$fEqCCallTarget$fDataCCallTarget $fEqCCallConv$fDataCCallConv$fEnumCCallConv $fEqSafety $fShowSafety $fDataSafety $fEnumSafety BreakInfobreakInfo_modulebreakInfo_numberHomeUnit GenHomeUnitDefiniteHomeUnitIndefiniteHomeUnit homeUnitIdhomeUnitInstantiationshomeUnitInstanceOfhomeUnitInstanceOfMaybehomeUnitAsUnit homeUnitMapisHomeUnitIndefiniteisHomeUnitDefiniteisHomeUnitInstantiating isHomeUnit isHomeUnitId notHomeUnitIdisHomeUnitInstanceOf isHomeModuleisHomeInstalledModulenotHomeInstalledModulenotHomeInstalledModuleMaybe notHomeModulenotHomeModuleMaybe mkHomeModulemkHomeInstalledModulehomeModuleNameInstantiationhomeModuleInstantiationPkgQual NoPkgQualThisPkgOtherPkg RawPkgQual NoRawPkgQual$fOutputableRawPkgQual$fOutputablePkgQual $fDataPkgQual $fOrdPkgQual $fEqPkgQual$fDataRawPkgQual HscSource HsSrcFile HsBootFileHsigFilehscSourceToIsBoothscSourceString isHsBootOrSig isHsigFile$fBinaryHscSource $fEqHscSource$fOrdHscSource$fShowHscSource parseUnit parseUnitIdparseHoleyModule parseModSubstKnotVars NoKnotVars kv_domain kv_lookup emptyKnotVarsknotVarsFromModuleEnv knotVarElemslookupKnotVarsknotVarsWithout$fOutputableKnotVars$fFunctorKnotVarsLPatPatLHsExpr SyntaxExprGRHSs MatchGroupHsUntypedSplice PromotionFlag NotPromoted IsPromoted isPromotedDefaultingStrategyDefaultKindVarsNonStandardDefaultingNonStandardDefaultingStrategyDefaultNonStandardTyVars TryNotToDefaultNonStandardTyVarsTypeOrConstraintTypeLikeConstraintLikeLevityLiftedUnlifted TypeOrKind TypeLevel KindLevel IntWithInfUnfoldingSource VanillaSrc StableUserSrcStableSystemSrc CompulsorySrc InlineSpecInline InlinableNoInlineOpaqueNoUserInlinePrag RuleMatchInfoConLikeFunLike InlinePragmainl_src inl_inlineinl_satinl_actinl_rule Activation AlwaysActive ActiveBefore ActiveAfter FinalActive NeverActive CompilerPhase InitialPhasePhase FinalPhasePhaseNum SuccessFlag DefMethSpec VanillaDM GenericDM TailCallInfoAlwaysTailCalledNoTailCallInfo InsideLam IsInsideLam NotInsideLamInterestingCxt IsInterestingNotInteresting BranchCountOccInfoManyOccsIAmDeadOneOccIAmALoopBreakerocc_tail occ_in_lamocc_n_br occ_int_cxtocc_rules_onlyEPfromEPtoEPUnboxedTupleOrSumUnboxedTupleTypeUnboxedSumType TupleSort BoxedTuple UnboxedTupleConstraintTuplePprPrec OverlapMode NoOverlap Overlappable OverlappingOverlaps Incoherent OverlapFlag overlapMode isSafeOverlapOrigin FromSource GeneratedRecFlag Recursive NonRecursiveCbvMark MarkedCbv NotMarkedCbv TopLevelFlagTopLevel NotTopLevelRuleNameFunctionOrData IsFunctionIsDataSwapFlag NotSwapped IsSwapped OneShotInfo NoOneShotInfo OneShotLam AlignmentalignmentBytesConTagZ FullArgCount JoinArityRepArityArity LeftOrRightCLeftCRightpickLR fIRST_TAG mkAlignment alignmentOf noOneShotInfo isOneShotInfohasNoOneShotInfo worstOneShot bestOneShotflipSwap isSwappedunSwap pprRuleName isNotTopLevel isTopLevel isMarkedCbvisRecisNonRec boolToRecFlag isGeneratedsetOverlapModeMaybehasIncoherentFlaghasOverlappableFlaghasOverlappingFlagtopPrecsigPrecfunPrecopPrecstarPrecappPrecmaxPrec maybeParentupleSortBoxityboxityTupleSort tupleParens sumParenspprAlternativeunboxedTupleOrSumExtension oneBranch noOccInfo isNoOccInfo isManyOccs seqOccInfo tailCallInfozapOccTailCallInfoisAlwaysTailCalledstrongLoopBreakerweakLoopBreakerisWeakLoopBreakerisStrongLoopBreaker isDeadOccisOneOcc zapFragileOcc successIf succeededfailed beginPhase activeAfter nextPhase laterPhaseactivateAfterInitialactivateDuringFinalisActiveactiveInFinalPhase isNeverActiveisAlwaysActive competesWith isConLike isFunLikenoUserInlineSpecdefaultInlinePragmaalwaysInlinePragmaneverInlinePragmaalwaysInlineConLikePragmainlinePragmaSpecinlinePragmaSourceinlineSpecSourcedfunInlinePragmaisDefaultInlinePragmaisInlinePragmaisInlinablePragmaisNoInlinePragmaisAnyInlinePragmaisOpaquePragmainlinePragmaSatinlinePragmaActivationinlinePragmaRuleMatchInfosetInlinePragmaActivationsetInlinePragmaRuleMatchInfoinlinePragmaName pprInlinepprInlineDebugisStableUserSourceisStableSystemSourceisCompulsorySourceisStableSourceinfinity intGtLimit subWithInftreatZeroAsInf mkIntWithInf isTypeLevel isKindLevel mightBeLiftedmightBeUnlifteddefaultNonStandardTyVars$fBinaryBoxity$fOutputableBoxity$fBinaryPromotionFlag$fOutputablePromotionFlag$fBinaryLeftOrRight$fOutputableLeftOrRight$fOutputablePenvAlignment$fOutputableAlignment$fOutputableOneShotInfo$fOutputableSwapFlag$fBinaryFunctionOrData$fOutputableFunctionOrData$fOutputableTopLevelFlag$fBinaryCbvMark$fOutputableCbvMark$fBinaryRecFlag$fOutputableRecFlag$fOutputableOrigin$fBinaryOverlapMode$fOutputableOverlapMode$fBinaryOverlapFlag$fOutputableOverlapFlag$fBinaryTupleSort$fOutputableTupleSort$fOutputableUnboxedTupleOrSum$fMonoidInterestingCxt$fSemigroupInterestingCxt$fMonoidInsideLam$fSemigroupInsideLam$fOutputableTailCallInfo$fOutputableOccInfo$fOutputableDefMethSpec$fOutputableSuccessFlag$fSemigroupSuccessFlag$fOutputableCompilerPhase$fBinaryActivation$fOutputableActivation$fBinaryRuleMatchInfo$fOutputableRuleMatchInfo$fBinaryInlineSpec$fOutputableInlineSpec$fBinaryInlinePragma$fOutputableInlinePragma$fOutputableUnfoldingSource$fBinaryUnfoldingSource$fNumIntWithInf$fOutputableIntWithInf$fOrdIntWithInf$fOutputableTypeOrKind$fOutputableLevity)$fOutputableNonStandardDefaultingStrategy$fOutputableDefaultingStrategy$fEqTypeOrConstraint$fOrdTypeOrConstraint$fDataTypeOrConstraint $fEqLevity$fEqTypeOrKind$fEqIntWithInf$fEqInlinePragma$fDataInlinePragma$fEqInlineSpec$fDataInlineSpec$fShowInlineSpec$fEqRuleMatchInfo$fDataRuleMatchInfo$fShowRuleMatchInfo$fEqActivation$fDataActivation$fEqCompilerPhase $fEqOccInfo$fEqTailCallInfo $fEqInsideLam$fEqInterestingCxt$fEqUnboxedTupleOrSum $fEqTupleSort$fDataTupleSort $fEqPprPrec $fOrdPprPrec $fShowPprPrec$fEqOverlapFlag$fDataOverlapFlag$fEqOverlapMode$fDataOverlapMode $fEqOrigin $fDataOrigin $fEqRecFlag $fDataRecFlag $fEqCbvMark$fDataTopLevelFlag$fEqFunctionOrData$fOrdFunctionOrData$fDataFunctionOrData$fEqOneShotInfo $fEqAlignment$fOrdAlignment$fEqLeftOrRight$fDataLeftOrRightdataConTyRepNameUniquedataConWorkerUniquemkPreludeDataConUniquetyConRepNameUniquemkPreludeTyConUniqueinitExitJoinUniquemkVarOccUniquemkDataOccUnique mkTvOccUnique mkTcOccUniquemkRegSingleUniquemkRegPairUniquemkRegSubUniquemkRegClassUniquemkPseudoUniqueEmkBuiltinUniquemkPreludeMiscIdUniquemkPrimOpWrapperUniquemkPrimOpIdUniquemkPreludeClassUniquemkAlphaTyVarUniquemkTupleDataConUniquemkTupleTyConUniquemkCTupleDataConUniquemkCTupleTyConUniquemkSumDataConUniquemkSumTyConUniqueknownUniqueNameEqSpec DataConRepDataConpromoteDataCon dataConWrapId isTypeDataConisUnboxedSumDataCondataConFullSigdataConStupidThetadataConInstOrigArgTysdataConFieldLabelsdataConSourceAritydataConUserTyVarBindersdataConUserTyVarsdataConExTyCoVars dataConTyCon dataConWorkId dataConNamesumTyCon sumDataConcTupleSelIdNamecTupleTyConNamecTupleDataConName cTupleDataCon tupleTyCon tupleDataConpromotedTupleDataCon integerTy naturalTytupleDataConNametupleTyConName multMulTyConunrestrictedFunTyConmanyDataConTyCon manyDataConTyoneDataConTyCon oneDataConTymultiplicityTymultiplicityTyConunboxedTupleKind anyTypeOfKindint8ElemRepDataConTyint16ElemRepDataConTyint32ElemRepDataConTyint64ElemRepDataConTyword8ElemRepDataConTyword16ElemRepDataConTyword32ElemRepDataConTyword64ElemRepDataConTyfloatElemRepDataConTydoubleElemRepDataConTy vec2DataConTy vec4DataConTy vec8DataConTyvec16DataConTyvec32DataConTyvec64DataConTyintRepDataConTyint8RepDataConTyint16RepDataConTyint32RepDataConTyint64RepDataConTywordRepDataConTyword8RepDataConTyword16RepDataConTyword32RepDataConTyword64RepDataConTyaddrRepDataConTyfloatRepDataConTydoubleRepDataConTyliftedDataConTyunliftedDataConTy liftedRepTy unliftedRepTy zeroBitRepTyvecRepDataConTyContupleRepDataConTyConboxedRepDataConTyConliftedDataConTyCon runtimeRepTylevityTyruntimeRepTyCon levityTyCon vecCountTyCon vecElemTyConconstraintKindliftedRepTyConunliftedRepTyConliftedTypeKindTyConunliftedTypeKindTyConliftedTypeKindunliftedTypeKindzeroBitTypeKindconstraintKindTyConNameliftedTypeKindTyConNameunitTycoercibleTyConheqTyConmkBoxedTupleTycharTytypeSymbolKind listTyConmkCTupleSelIdUniquemkCostCentreUniquemkBoxingTyConUniqueboxingDataConUnique TidyOccEnvOccSetOccEnv occNameSpace NameSpacetcNameclsName tcClsNamedataName srcDataNametvNamevarNameisDataConNameSpaceisTcClsNameSpace isTvNameSpaceisVarNameSpaceisValNameSpace pprNameSpacepprNonVarNameSpacepprNameSpaceBrief pprOccName mkOccName mkOccNameFSmkVarOcc mkDataOcc mkDataOccFS mkTyVarOcc mkTyVarOccFSmkTcOcc mkTcOccFSmkClsOcc mkClsOccFS demoteOccNamepromoteOccName emptyOccEnv unitOccEnv extendOccEnvextendOccEnvList lookupOccEnvmkOccEnv elemOccEnv foldOccEnvnonDetOccEnvElts plusOccEnv plusOccEnv_CextendOccEnv_CextendOccEnv_Acc mapOccEnv mkOccEnv_C delFromOccEnvdelListFromOccEnv filterOccEnv alterOccEnv minusOccEnv minusOccEnv_C pprOccEnv emptyOccSet unitOccSetmkOccSet extendOccSetextendOccSetList unionOccSetsunionManyOccSets minusOccSet elemOccSet isEmptyOccSetintersectOccSet filterOccSet occSetToEnv occNameStringsetOccNameSpaceisVarOccisTvOccisTcOccisValOcc isDataOcc isDataSymOccisSymOcc parenSymOccstartsWithUnderscoreisDerivedOccNameisDefaultMethodOccisTypeableBindOccmkDataConWrapperOcc mkWorkerOcc mkMatcherOcc mkBuilderOccmkDefaultMethodOccmkClassOpAuxOcc mkDictOccmkIPOcc mkSpecOccmkForeignExportOcc mkRepEqOccmkClassDataConOcc mkNewTyCoOcc mkInstTyCoOcc mkEqPredCoOcc mkCon2TagOcc mkTag2ConOcc mkMaxTagOcc mkDataTOcc mkDataCOcc mkTyConRepOccmkGenRmkGen1RmkDataConWorkerOccmkSuperDictAuxOccmkSuperDictSelOcc mkLocalOcc mkInstTyTcOcc mkDFunOcc mkMethodOccemptyTidyOccEnvinitTidyOccEnvdelTidyOccEnvListavoidClashesOccEnv tidyOccName$fBinaryNameSpace$fBinaryOccName$fUniquableOccName$fOutputableBndrOccName$fOutputableOccName$fNFDataOccName $fDataOccName $fOrdOccName $fEqOccName$fHasOccNameOccName$fOutputableOccEnv $fDataOccEnv $fEqNameSpace$fOrdNameSpaceRegClass RcIntegerRcFloatRcDouble$fOutputableRegClass$fUniquableRegClass $fEqRegClassReg RegVirtualRegRealRealReg RealRegSingle VirtualReg VirtualRegI VirtualRegHi VirtualRegF VirtualRegDRegNorenameVirtualRegclassOfVirtualReggetHiVirtualRegFromLogetHiVRegFromLoregNosOfRealReg realRegsAlias regSingle realRegSingle isRealReg takeRealReg isVirtualRegtakeVirtualRegliftPatchFnToRegReg$fOutputableVirtualReg$fUniquableVirtualReg$fOrdVirtualReg$fOutputableRealReg$fUniquableRealReg$fOutputableReg$fUniquableReg$fEqReg$fOrdReg $fShowReg $fEqRealReg $fShowRealReg $fOrdRealReg$fEqVirtualReg$fShowVirtualReg PlatformMisc!platformMisc_targetPlatformStringplatformMisc_ghcWithInterpreterplatformMisc_libFFIplatformMisc_llvmTarget BmiVersionBMI1BMI2 SseVersionSSE1SSE2SSE3SSE4SSE42PlatformWordSizePW4PW8PlatformplatformArchOSplatformWordSizeplatformByteOrderplatformUnregisterisedplatformHasGnuNonexecStackplatformHasIdentDirective platformHasSubsectionsViaSymbolsplatformIsCrossCompilingplatformLeadingUnderscoreplatformTablesNextToCodeplatformHasLibmplatform_constants wordAlignment isSseEnabled isSse2EnabledplatformConstantsgenericPlatformplatformWordSizeInBytesplatformWordSizeInBits platformArch platformOSisARM target32Bit osElfTarget osMachOTargetplatformUsesFrameworksosSubsectionsViaSymbolsplatformMinIntplatformMaxIntplatformMaxWordplatformInIntRangeplatformInWordRangeplatformCConvNeedsExtensionplatformSONameplatformHsSOName platformSOExtlookupPlatformConstants$fReadPlatformWordSize$fShowPlatformWordSize$fEqBmiVersion$fOrdBmiVersion$fEqSseVersion$fOrdSseVersion$fReadPlatform$fShowPlatform $fEqPlatform $fOrdPlatform$fEqPlatformWordSize$fOrdPlatformWordSizeCLabel pprCLabel BuiltInSyntax UserSyntax nameNameSpace nameSrcLoc nameSrcSpan isWiredInName isWiredInwiredInNameTyThing_maybeisBuiltInSyntaxisExternalNameisInternalName isHoleName isDynLinkName nameModulenameModule_maybe namePun_maybenameIsLocalOrFromnameIsExternalOrFromnameIsHomePackagenameIsHomePackageImportnameIsFromExternalPackage isTyVarName isTyConName isDataConName isValName isVarName isSystemNamemkInternalNamemkClonedInternalNamemkDerivedInternalNamemkExternalName mkWiredInName mkSystemNamemkSystemNameAtmkSystemVarName mkSysTvName mkFCallName setNameLoc localiseName stableNameCmppprName pprFullName pprTickyNamepprNameUnqualifiedpprModulePrefix pprDefinedAtpprNameDefnLocnameStableString getSrcLoc getSrcSpan getOccStringgetOccFS pprInfixName pprPrefixName$fNFDataNameSort$fOutputableNameSort$fOutputableBndrName$fOutputableName $fBinaryName $fDataName$fUniquableName $fOrdName$fEqName$fHasOccNameName $fNFDataName$fNamedThingGenLocated$fNamedThingName PiTyVarBinder PiTyBinderNamedAnon ReqTVBinder TyVarBinder ReqTyBinder InvisTyBinderForAllTyBinderBndrFTF_T_TFTF_T_CFTF_C_TFTF_C_C InferredSpec SpecifiedSpec InvisibleRequiredvarTypevarMultOutIdOutCoVarOutTyVarOutVarInIdInCoVarInTyVarInVarJoinIdEqVarIpIdDictIdDFunIdEvVarEvIdKindVarTypeVarTKVarNcIdCoVar SpecifiedInferred nonDetCmpVar varUnique varMultMaybe setVarUnique setVarName setVarType updateVarTypeupdateVarTypeMisVisibleForAllTyFlagisInvisibleForAllTyFlagisInferredForAllTyFlag mkFunTyFlagvisArgvisArgTypeLikevisArgConstraintLikeinvisArginvisArgTypeLikeinvisArgConstraintLikeisInvisibleFunArgisVisibleFunArgisFUNArgfunTyFlagResultTypeOrConstrainttyVarSpecToBinderstyVarSpecToBindertyVarReqToBinderstyVarReqToBinder binderVar binderVars binderFlag binderFlags binderType isTyVarBindermkForAllTyBinder mkTyVarBindermkForAllTyBindersmkTyVarBinders mapVarBndr mapVarBndrsisInvisiblePiTyBinderisVisiblePiTyBinderisNamedPiTyBindernamedPiTyBinder_maybeisAnonPiTyBinderanonPiTyBinderType_maybe isTyBinderpiTyBinderType tyVarName tyVarKindsetTyVarUnique setTyVarName setTyVarKindupdateTyVarKindupdateTyVarKindMmkTyVar mkTcTyVartcTyVarDetailssetTcTyVarDetailsidInfo idDetails mkGlobalVar mkLocalVarmkCoVarmkExportedLocalVar lazySetIdInfo setIdDetails globaliseId setIdExportedsetIdNotExportedupdateIdTypeButNotMultupdateIdTypeAndMultupdateIdTypeAndMultM setIdMultisTyVar isTcTyVar isTyCoVarisIdisCoVar isNonCoVarId isLocalId isLocalVar isGlobalIdmustHaveLocalBinding isExportedId$fHasOccNameVar $fDataVar$fOrdVar$fEqVar$fUniquableVar$fNamedThingVar$fOutputableVar$fBinarySpecificity$fBinaryForAllTyFlag$fOutputableForAllTyFlag$fBinaryFunTyFlag$fOutputableFunTyFlag$fNamedThingVarBndr$fBinaryVarBndr$fOutputableVarBndr$fOutputableVarBndr0$fOutputablePiTyBinder$fDataPiTyBinder $fDataVarBndr $fEqFunTyFlag$fOrdFunTyFlag$fDataFunTyFlag$fEqForAllTyFlag$fOrdForAllTyFlag$fDataForAllTyFlag$fEqSpecificity$fOrdSpecificity$fDataSpecificitychooseFunTyFlagpartitionInvisibleTypes getLevitygetTyVar_maybetyConAppTyCon_maybesplitTyConApp_maybeisLiftedTypeKindisMultiplicityTy isLevityTyisRuntimeRepTycoreViewtypeTypeOrConstrainttypeKind piResultTy mkCoercionTy mkTyConAppmkCastTymkAppTy isCoercionTyisPredTy DTyCoVarSet DTyVarSetDIdSetDVarSet TyCoVarSetCoVarSetTyVarSetIdSetVarSet emptyVarSet unitVarSet extendVarSetextendVarSetListintersectVarSet unionVarSet unionVarSets elemVarSet minusVarSet delVarSet delVarSetList isEmptyVarSetmkVarSetlookupVarSet_Directly lookupVarSetlookupVarSetByName sizeVarSet filterVarSetdelVarSetByKeyelemVarSetByKeypartitionVarSetmapUnionVarSetintersectsVarSetdisjointVarSet subVarSet anyVarSet allVarSet mapVarSetnonDetStrictFoldVarSet fixVarSettransCloVarSet seqVarSet pluralVarSet pprVarSet emptyDVarSet unitDVarSet mkDVarSet extendDVarSet elemDVarSet dVarSetElems subDVarSet unionDVarSet unionDVarSetsmapUnionDVarSetintersectDVarSetdVarSetIntersectVarSetdisjointDVarSetintersectsDVarSetisEmptyDVarSet delDVarSet minusDVarSetdVarSetMinusVarSetnonDetStrictFoldDVarSet anyDVarSet allDVarSet mapDVarSet filterDVarSet sizeDVarSetpartitionDVarSetdelDVarSetList seqDVarSetextendDVarSetListdVarSetToVarSettransCloDVarSetFVInterestingVarFun fvVarList fvDVarSetfvVarSetunitFVemptyFVunionFVdelFVdelFVsfilterFV mapUnionFVunionsFVmkFVs UnVarGraphUnVarSetdomUFMUnVarSet emptyUnVarSet elemUnVarSetisEmptyUnVarSet delUnVarSetdelUnVarSetList mkUnVarSetextendUnVarSetextendUnVarSetList unionUnVarSetunionUnVarSetsemptyUnVarGraphunionUnVarGraphunionUnVarGraphscompleteBipartiteGraph completeGraph neighbors hasLoopAtdelNode$fOutputableUnVarSet$fOutputableUnVarGraph $fEqUnVarSetTagSigTagInfoTagDunnoTagTuple TagProper TagTagged isTaggedSig seqTagSig seqTagInfo$fBinaryTagInfo$fOutputableTagInfo$fBinaryTagSig$fOutputableBndr(,)$fOutputableTagSig $fEqTagSig $fEqTagInfo DTyVarEnvDIdEnvDVarEnvCoVarEnv TyCoVarEnvTyVarEnvIdEnvVarEnvTidyEnvRnEnv2 InScopeSetInScopeemptyInScopeSetgetInScopeVars mkInScopeSetmkInScopeSetListextendInScopeSetextendInScopeSetListextendInScopeSetSet delInScopeSetelemInScopeSet lookupInScopelookupInScope_Directly unionInScope varSetInScopeuniqAwayunsafeGetFreshLocalUniquemkRnEnv2extendRnInScopeSetList rnInScope rnInScopeSetrnEnvLrnEnvRrnBndrs2rnBndr2 rnBndr2_varrnBndrLrnBndrRrnEtaLrnEtaRdelBndrLdelBndrR delBndrsL delBndrsRrnOccLrnOccR rnOccL_maybe rnOccR_maybeinRnEnvLinRnEnvR anyInRnEnvRlookupRnInScope nukeRnEnvL nukeRnEnvRrnSwap emptyTidyEnvmkEmptyTidyEnvdelTidyEnvList elemVarEnvelemVarEnvByKeydisjointVarEnv alterVarEnv extendVarEnvextendVarEnv_CextendVarEnv_AccextendVarEnvList plusVarEnv_C plusVarEnv_CDplusMaybeVarEnv_C delVarEnvList delVarEnv minusVarEnv plusVarEnvplusVarEnvList lookupVarEnvlookupVarEnv_Directly filterVarEnv anyVarEnvlookupWithDefaultVarEnv mapVarEnvmkVarEnvmkVarEnv_Directly emptyVarEnv unitVarEnv isEmptyVarEnvpartitionVarEnv varEnvDomainrestrictVarEnv zipVarEnvlookupVarEnv_NF modifyVarEnvmodifyVarEnv_Directly emptyDVarEnv dVarEnvElts mkDVarEnv extendDVarEnv minusDVarEnv lookupDVarEnv foldDVarEnvnonDetStrictFoldDVarEnv mapDVarEnv filterDVarEnv alterDVarEnv plusDVarEnv plusDVarEnv_C unitDVarEnv delDVarEnvdelDVarEnvListisEmptyDVarEnv elemDVarEnvextendDVarEnv_C modifyDVarEnvpartitionDVarEnvextendDVarEnvList anyDVarEnv$fOutputableInScopeSet NonCaffySet ncs_nameSetDefUsesDefUseUsesDefsFreeVarsNameSetisEmptyNameSet emptyNameSet unitNameSet mkNameSetextendNameSetList extendNameSet unionNameSet unionNameSets minusNameSet elemNameSetdelFromNameSet filterNameSetintersectNameSetdisjointNameSetdelListFromNameSetintersectsNameSet nameSetAny nameSetAllnameSetElemsStable isEmptyFVsemptyFVsplusFVsplusFVaddOneFV intersectFVsemptyDUsusesOnlymkDUsplusDUduDefsallUsesduUsesfindUses$fSemigroupNonCaffySet$fMonoidNonCaffySetDNameEnvNameEnvdepAnalnonDetNameEnvElts emptyNameEnvisEmptyNameEnv unitNameEnv extendNameEnvextendNameEnvList lookupNameEnv alterNameEnv mkNameEnv mkNameEnvWith elemNameEnv plusNameEnv plusNameEnv_CplusNameEnv_CDplusNameEnv_CD2extendNameEnv_C mapNameEnvextendNameEnv_AccextendNameEnvList_CdelFromNameEnvdelListFromNameEnv filterNameEnvmapMaybeNameEnv anyNameEnvdisjointNameEnvseqEltsNameEnvlookupNameEnv_NF emptyDNameEnvisEmptyDNameEnvlookupDNameEnvdelFromDNameEnvfilterDNameEnv mapDNameEnvadjustDNameEnv alterDNameEnvextendDNameEnvextendDNameEnv_C eltsDNameEnv foldDNameEnvplusDNameEnv_CnonDetStrictFoldDNameEnvGreName NormalGreName FieldGreNameAvails AvailInfoAvailAvailTCstableAvailCmpstableGreNameCmpavail availFieldavailTCavailsToNameSetavailsToNameSetWithSelectorsavailsToNameEnvavailExportsDecl availName availGreName availNamesavailNamesWithSelectorsavailNonFldNames availFlds availGreNamesavailSubordinateGreNamesgreNameMangledNamegreNamePrintableNamegreNameSrcSpangreNameFieldLabelpartitionGreNames plusAvail trimAvail filterAvails filterAvail nubAvails$fBinaryGreName $fOrdGreName$fHasOccNameGreName$fNFDataGreName$fOutputableGreName$fNFDataAvailInfo$fBinaryAvailInfo$fOutputableAvailInfo $fEqAvailInfo$fDataAvailInfo $fDataGreName $fEqGreName ImpItemSpecImpAllImpSome is_explicitis_iloc ImpDeclSpecis_modis_asis_qualis_dloc ImportSpecImpSpecis_declis_itemParentNoParentParentIspar_is GlobalRdrEltGREgre_namegre_pargre_lclgre_imp GlobalRdrEnv LocalRdrEnvUnqualQualOrigExact rdrNameOcc rdrNameSpace demoteRdrNamepromoteRdrName mkRdrUnqual mkRdrQualmkOrigmkUnqual mkVarUnqualmkQual getRdrName nameRdrName isRdrDataCon isRdrTyVarisRdrTc isSrcRdrNameisUnqualisQual isQual_maybeisOrig isOrig_maybeisExact isExact_maybeemptyLocalRdrEnvextendLocalRdrEnvextendLocalRdrEnvListlookupLocalRdrEnvlookupLocalRdrOccelemLocalRdrEnvlocalRdrEnvEltsinLocalRdrEnvScopeminusLocalRdrEnvgresFromAvailslocalGREsFromAvail gresFromAvail greOccNamegreMangledNamegrePrintableNamegreDefinitionSrcSpangreDefinitionModulegreQualModName greRdrNames greSrcSpangreParent_maybegresToAvailInfo availFromGREemptyGlobalRdrEnvglobalRdrEnvEltspprGlobalRdrEnvlookupGlobalRdrEnvlookupGRE_RdrNamelookupGRE_RdrName'lookupGRE_NamelookupGRE_GreNamelookupGRE_FieldLabellookupGRE_Name_OccNamegetGRE_NameQualifier_maybes isLocalGRE isRecFldGREisDuplicateRecFldGREisNoFieldSelectorGREisFieldSelectorGRE greFieldLabelunQualOKpickGREspickGREsModExpplusGlobalRdrEnvmkGlobalRdrEnv transformGREsextendGlobalRdrEnv shadowNames bestImport unQualSpecOK qualSpecOK importSpecLocimportSpecModuleisExplicitItempprNameProvenanceopIsAt $fOrdRdrName $fEqRdrName$fOutputableBndrRdrName$fOutputableRdrName$fHasOccNameRdrName$fOutputableLocalRdrEnv$fOutputableParent$fOutputableImportSpec$fOutputableGlobalRdrElt$fHasOccNameGlobalRdrElt$fDataGlobalRdrElt$fEqImportSpec$fDataImportSpec$fEqImpItemSpec$fDataImpItemSpec$fEqImpDeclSpec$fDataImpDeclSpec $fEqParent $fDataParent $fDataRdrNameImportedModsValimv_nameimv_span imv_is_safe imv_is_hidingimv_all_exports imv_qualified ImportedByImportedByUserImportedBySystem ImportedModsimportedByUserNoEpAnnsEpAnnCO AnnSortKey NoAnnSortKey AnnPragmaapr_open apr_closeapr_rest NameAdornment NameParensNameParensHashNameBackquotes NameSquareNameAnn NameAnnCommas NameAnnBars NameAnnOnly NameAnnRArrow NameAnnQuoteNameAnnTrailingnann_adornment nann_open nann_name nann_close nann_trailing nann_commas nann_bars nann_quote nann_quoted AnnContext ac_darrowac_openac_close ParenType AnnParens AnnParensHashAnnParensSquareAnnParen ap_adornmentap_openap_closeAnnList al_anchoral_openal_closeal_rest al_trailing AnnListItem lann_trailing TrailingAnn AddSemiAnn AddCommaAnn AddVbarAnn LocatedAn SrcSpanAnnC SrcSpanAnnP SrcSpanAnnL SrcSpanAnnN SrcSpanAnnALocatedCLocatedPLocatedLLocatedNLocatedASrcAnn SrcSpanAnn' SrcSpanAnnannlocA LEpaComment EpAnnComments EpaCommentsEpaCommentsBalanced priorCommentsfollowingCommentsAnchorOperationUnchangedAnchor MovedAnchorAnchoranchor anchor_opEpAnn EpAnnNotUsedentryannscommentsDeltaPosSameLine DifferentLine deltaColumn deltaLine TokenLocation NoTokenLocTokenLoc EpaLocationEpaSpanEpaDeltaAddEpAnn EpaCommentTok EpaDocComment EpaDocOptionsEpaLineCommentEpaBlockComment EpaEofComment EpaCommentac_tok ac_prior_tokHasENoEIsUnicodeSyntax UnicodeSyntax NormalSyntax AnnAnyclass AnnCloseBU AnnCloseC AnnCloseQU AnnClosePH AnnCloseS AnnCommaTuple AnnDarrowU AnnDcolonU AnnForallU AnnLarrowU AnnLollyUAnnMdoAnnName AnnOpenBUAnnOpenC AnnOpenEQUAnnOpenS AnnOpenPH AnnDollarAnnDollarDollar AnnPercent AnnPercentOne AnnRarrowUAnnSimpleQuote AnnSignature AnnThTyQuote AnnValStrAnnViaAnnlarrowtailUAnnrarrowtailUAnnLarrowtailUAnnRarrowtailU unicodeAnndeltaPos getDeltaLineepaLocationRealSrcSpanepaLocationFromSrcAnn spanAsAnchorrealSpanAsAnchor emptyComments parenTypeKwstrailingAnnToAddEpAnnaddTrailingAnnToLaddTrailingAnnToAaddTrailingCommaToNl2nn2lla2nala2lal2lna2lareLocreLocAreLocLreLocCreLocN realSrcSpan srcSpan2ela2eextraToAnnListreAnnreAnnCreAnnL getLocAnngetLocAnoLocA noAnnSrcSpan noSrcSpanAnoAnnaddAnnsaddAnnsA widenSpan widenAnchor widenAnchorRwidenLocatedAn epAnnAnnsL epAnnAnnsannParen2AddEpAnn epAnnComments sortLocatedAmapLocA combineLocsAcombineSrcSpansAaddCLocA addCLocAAgetFollowingCommentssetFollowingCommentssetPriorComments noCommentsplaceholderRealSpancommentaddCommentsToSrcAnnsetCommentsSrcAnnaddCommentsToEpAnnsetCommentsEpAnn transferAnnsA commentsOnlyAremoveCommentsA$fOutputableAnnKeywordId$fOutputableIsUnicodeSyntax$fOutputableEpaComment$fOutputableDeltaPos$fOutputableAnchorOperation$fOutputableAnchor$fSemigroupAnchor $fOrdAnchor$fOutputableEpAnnComments$fSemigroupEpAnnComments$fOutputableEpAnn $fMonoidEpAnn$fSemigroupEpAnn$fOutputableEpaLocation$fOutputableAddEpAnn$fOutputableBndrGenLocated$fOutputableGenLocated1$fOutputableSrcSpanAnn'$fSemigroupSrcSpanAnn'$fOutputableTrailingAnn$fOutputableAnnListItem$fMonoidAnnListItem$fSemigroupAnnListItem$fOutputableAnnList$fMonoidAnnList$fSemigroupAnnList$fOutputableAnnContext$fOutputableNameAdornment$fOutputableNameAnn$fMonoidNameAnn$fSemigroupNameAnn$fOutputableAnnPragma$fOutputableAnnSortKey$fMonoidAnnSortKey$fSemigroupAnnSortKey$fOutputableNoEpAnns$fSemigroupNoEpAnns$fDataNoEpAnns $fEqNoEpAnns $fOrdNoEpAnns$fDataAnnSortKey$fEqAnnSortKey$fDataAnnPragma $fEqAnnPragma $fDataNameAnn $fEqNameAnn$fEqNameAdornment$fOrdNameAdornment$fDataNameAdornment$fDataAnnContext$fDataAnnParen $fEqParenType$fOrdParenType$fDataParenType $fDataAnnList $fEqAnnList$fDataAnnListItem$fEqAnnListItem$fDataTrailingAnn$fEqTrailingAnn$fDataSrcSpanAnn'$fEqSrcSpanAnn'$fDataAddEpAnn $fEqAddEpAnn$fDataTokenLocation$fEqTokenLocation$fDataEpaLocation$fEqEpaLocation $fDataEpAnn $fEqEpAnn$fFunctorEpAnn$fDataEpAnnComments$fEqEpAnnComments $fDataAnchor $fEqAnchor $fShowAnchor$fDataAnchorOperation$fEqAnchorOperation$fShowAnchorOperation$fShowDeltaPos $fEqDeltaPos $fOrdDeltaPos$fDataDeltaPos$fEqEpaComment$fDataEpaComment$fShowEpaComment$fEqEpaCommentTok$fDataEpaCommentTok$fShowEpaCommentTok$fEqHasE $fOrdHasE $fDataHasE $fShowHasE$fEqIsUnicodeSyntax$fOrdIsUnicodeSyntax$fDataIsUnicodeSyntax$fShowIsUnicodeSyntax$fEqAnnKeywordId$fOrdAnnKeywordId$fDataAnnKeywordId$fShowAnnKeywordIdBooleanFormulaOrParensLBooleanFormulamkVarmkFalsemkTruemkAndmkOrisFalseisTrueevalsimplify isUnsatisfied impliesAtomimpliespprBooleanFormulapprBooleanFormulaNice$fBinaryBooleanFormula$fOutputableBooleanFormula$fEqBooleanFormula$fDataBooleanFormula$fFunctorBooleanFormula$fFoldableBooleanFormula$fTraversableBooleanFormulaOutputableBndrId NoGhcTcPassIdGhcPIsPassghcPassGhcTcGhcRnGhcPsPassParsedRenamed TypecheckedGhcPass IsSrcSpanAnnpprIfPspprIfRnpprIfTcnoHsTok noHsUniTok$fOutputableHsUniToken$fOutputableHsToken$fOutputableDataConCantHappen$fOutputableNoExtField $fDataGhcPass$fMapXRecGhcPass$fUnXRecGhcPass$fIsPassTypechecked$fIsPassRenamed$fIsPassParsed $fDataPass$fDataLayoutInfoExtractedTHDocsethd_mod_headerethd_decl_docs ethd_arg_docsethd_inst_docsDocs docs_mod_hdr docs_decls docs_argsdocs_structuredocs_named_chunksdocs_haddock_opts docs_languagedocs_extensions DocStructureDocStructureItemDsiSectionHeading DsiDocChunkDsiNamedChunkRef DsiExports DsiModExportLHsDocWithHsDocIdentifiers hsDocStringhsDocIdentifiersHsDochsDocIds pprWithDocpprMaybeWithDoc pprHsDocDebug emptyDocs$fBinaryWithHsDocIdentifiers $fOutputableWithHsDocIdentifiers$fNFDataWithHsDocIdentifiers$fNFDataDocStructureItem$fOutputableDocStructureItem$fBinaryDocStructureItem$fOutputableDocs $fBinaryDocs $fNFDataDocs$fEqWithHsDocIdentifiers$fDataWithHsDocIdentifiersLIEWrappedName IEWrappedNameIEName IEPatternIETypeXIEWrappedName IEWildcard NoIEWildcardIEVar IEThingAbs IEThingAll IEThingWithIEModuleContentsIEGroupIEDoc IEDocNamedXIELIEImportListInterpretationExactly EverythingBut ImportDecl XImportDeclideclExt ideclName ideclPkgQual ideclSource ideclSafeideclQualifiedideclAsideclImportListImportDeclQualifiedStyle QualifiedPre QualifiedPost NotQualified LImportDecl$fEqIEWildcard$fDataIEWildcard$fEqImportListInterpretation$fDataImportListInterpretation$fEqIsBootInterface$fOrdIsBootInterface$fShowIsBootInterface$fDataIsBootInterface$fEqImportDeclQualifiedStyle$fDataImportDeclQualifiedStyleWarnings NoWarningsWarnAllWarnSome WarningTxt DeprecatedTxtpprWarningTxtForMsgmkIfaceWarnCacheemptyIfaceWarnCache plusWarns$fBinaryWarningTxt$fOutputableWarningTxt$fBinaryWarnings$fGenericWarningTxt $fEqWarnings$fDataWarningTxt$fEqWarningTxt CollectedCCsCostCentreStack CCFlavourCcName CostCentreNormalCC AllCafsCCcc_namecc_modcc_loc mkCafFlavourmkExprCCFlavourmkDeclCCFlavourmkHpcCCFlavourmkLateCCFlavourmkCallerCCFlavour cmpCostCentreisCafCC isSccCountCC sccAbleCCccFromThisModulemkUserCCmkAutoCC mkAllCafsCCemptyCollectedCCs collectCC currentCCS dontCareCCS isCurrentCCSisCafCCSmaybeSingletonCCSmkSingletonCCSpprCostCentreStack pprCostCentrepprCostCentreCorecostCentreUserNamecostCentreUserNameFScostCentreSrcSpan$fBinaryCCFlavour$fBinaryCostCentre$fOutputableCostCentre$fOrdCostCentre$fEqCostCentre$fOutputableCostCentreStack$fEqCostCentreStack$fOrdCostCentreStack$fDataCostCentre $fEqCCFlavour$fOrdCCFlavour$fDataCCFlavour$fEqIndexedCCFlavour$fOrdIndexedCCFlavour$fDataIndexedCCFlavour$fEnumIndexedCCFlavourallNameStringsallNameStringListitName mkUnboundName isUnboundNamebasicKnownKeyNamesgenericTyConNamespRELUDEgHC_PRIMgHC_PRIM_PANIC gHC_TYPES gHC_MAGICgHC_MAGIC_DICT gHC_CSTRING gHC_CLASSESgHC_PRIMOPWRAPPERSgHC_BASEgHC_ENUMgHC_GHCIgHC_GHCI_HELPERSgHC_SHOWgHC_READgHC_NUM gHC_MAYBEgHC_NUM_INTEGERgHC_NUM_NATURALgHC_NUM_BIGNATgHC_LIST gHC_TUPLEgHC_TUPLE_PRIM dATA_EITHER dATA_LIST dATA_STRING dATA_FOLDABLEdATA_TRAVERSABLEgHC_CONCgHC_IOgHC_IO_ExceptiongHC_STgHC_IX gHC_STABLEgHC_PTRgHC_ERRgHC_REAL gHC_FLOATgHC_TOP_HANDLER sYSTEM_IOdYNAMICtYPEABLEtYPEABLE_INTERNALgENERICS rEAD_PREClEXgHC_INTgHC_WORDmONAD mONAD_FIX mONAD_ZIP mONAD_FAILaRROW gHC_DESUGARrANDOMgHC_EXTS gHC_IS_LISTcONTROL_EXCEPTION_BASE gHC_GENERICS gHC_TYPEERROR gHC_TYPELITSgHC_TYPELITS_INTERNAL gHC_TYPENATSgHC_TYPENATS_INTERNAL dATA_COERCE dEBUG_TRACE uNSAFE_COERCEfOREIGN_C_CONSTPTR gHC_SRCLOC gHC_STACKgHC_STACK_TYPES gHC_STATICPTRgHC_STATICPTR_INTERNALgHC_FINGERPRINT_TYPEgHC_OVER_LABELS gHC_RECORDS rOOT_MAINmkInteractiveModule pRELUDE_NAME mAIN_NAME mkPrimModulemkBignumModule mkBaseModule mkBaseModule_mkThisGhcModulemkThisGhcModule_ mkMainModule mkMainModule_main_RDR_Unqualeq_RDRge_RDRle_RDRlt_RDRgt_RDR compare_RDR ltTag_RDR eqTag_RDR gtTag_RDR eqClass_RDR numClass_RDR ordClass_RDR enumClass_RDRmonadClass_RDRmap_RDR append_RDR foldr_RDR build_RDR returnM_RDR bindM_RDR failM_RDRleft_RDR right_RDR fromEnum_RDR toEnum_RDR enumFrom_RDRenumFromTo_RDRenumFromThen_RDRenumFromThenTo_RDRratioDataCon_RDRintegerAdd_RDRintegerMul_RDR ioDataCon_RDRnewStablePtr_RDR bindIO_RDR returnIO_RDRfromInteger_RDRfromRational_RDR minus_RDR times_RDRplus_RDR toInteger_RDRtoRational_RDRfromIntegral_RDRfromString_RDR fromList_RDR fromListN_RDR toList_RDR compose_RDRand_RDRnot_RDR dataToTag_RDRsucc_RDRpred_RDR minBound_RDR maxBound_RDR range_RDR inRange_RDR index_RDRunsafeIndex_RDRunsafeRangeSize_RDR readList_RDRreadListDefault_RDRreadListPrec_RDRreadListPrecDefault_RDR readPrec_RDR parens_RDR choose_RDRlexP_RDR expectP_RDR readField_RDRreadFieldHash_RDRreadSymField_RDRpunc_RDR ident_RDR symbol_RDRstep_RDRalt_RDR reset_RDRprec_RDR pfail_RDR showsPrec_RDR shows_RDRshowString_RDR showSpace_RDRshowCommaSpace_RDR showParen_RDR error_RDR u1DataCon_RDRpar1DataCon_RDRrec1DataCon_RDR k1DataCon_RDR m1DataCon_RDR l1DataCon_RDR r1DataCon_RDRprodDataCon_RDRcomp1DataCon_RDR unPar1_RDR unRec1_RDRunK1_RDR unComp1_RDRfrom_RDR from1_RDRto_RDRto1_RDRdatatypeName_RDRmoduleName_RDRpackageName_RDRisNewtypeName_RDR selName_RDR conName_RDR conFixity_RDRconIsRecord_RDRprefixDataCon_RDRinfixDataCon_RDRleftAssocDataCon_RDRrightAssocDataCon_RDRnotAssocDataCon_RDRuAddrDataCon_RDRuCharDataCon_RDRuDoubleDataCon_RDRuFloatDataCon_RDRuIntDataCon_RDRuWordDataCon_RDR uAddrHash_RDR uCharHash_RDRuDoubleHash_RDRuFloatHash_RDR uIntHash_RDR uWordHash_RDRfmap_RDR replace_RDRpure_RDRap_RDR liftA2_RDRfoldable_foldr_RDR foldMap_RDRnull_RDRall_RDR traverse_RDR mempty_RDR mappend_RDR varQual_RDR tcQual_RDR clsQual_RDR dataQual_RDR wildCardName runMainIOName runRWNameorderingTyConNameordLTDataConNameordEQDataConNameordGTDataConName specTyConNameeitherTyConNameleftDataConNamerightDataConName voidTyConName v1TyConName u1TyConName par1TyConName rec1TyConName k1TyConName m1TyConName sumTyConName prodTyConName compTyConName rTyConName dTyConName cTyConName sTyConName rec0TyConName d1TyConName c1TyConName s1TyConName repTyConName rep1TyConName uRecTyConNameuAddrTyConNameuCharTyConNameuDoubleTyConNameuFloatTyConName uIntTyConNameuWordTyConNameprefixIDataConNameinfixIDataConNameleftAssociativeDataConNamerightAssociativeDataConNamenotAssociativeDataConNamesourceUnpackDataConNamesourceNoUnpackDataConNamenoSourceUnpackednessDataConNamesourceLazyDataConNamesourceStrictDataConNamenoSourceStrictnessDataConNamedecidedLazyDataConNamedecidedStrictDataConNamedecidedUnpackDataConNamemetaDataDataConNamemetaConsDataConNamemetaSelDataConName divIntName modIntNamecstringLengthName eqStringNameunpackCStringNameunpackCStringAppendNameunpackCStringFoldrNameunpackCStringUtf8NameunpackCStringAppendUtf8NameunpackCStringFoldrUtf8Name inlineIdName eqClassNameeqName ordClassNamegeNamefunctorClassNamefmapNamemonadClassName thenMName bindMName returnMNamemonadFailClassName failMNameapplicativeClassNameapAName pureAName thenANamefoldableClassNametraversableClassNamesemigroupClassName sappendNamemonoidClassName memptyName mappendName mconcatName joinMNamealternativeClassName joinMIdKey apAClassOpKeypureAClassOpKeythenAClassOpKeyalternativeClassKeyconsiderAccessibleName dollarNameotherwiseIdName foldrName buildName augmentNamemapName appendName assertNamefromStringName numClassNamefromIntegerName minusName negateName bnbVarQual bnnVarQual bniVarQualbignatFromWordListName bignatEqNamebignatCompareNamebignatCompareWordNamenaturalToWordNamenaturalPopCountNamenaturalShiftRNamenaturalShiftLNamenaturalAddNamenaturalSubNamenaturalSubThrowNamenaturalSubUnsafeNamenaturalMulNamenaturalQuotRemNamenaturalQuotNamenaturalRemNamenaturalAndNamenaturalAndNotName naturalOrNamenaturalXorNamenaturalTestBitNamenaturalBitNamenaturalGcdNamenaturalLcmNamenaturalLog2NamenaturalLogBaseWordNamenaturalLogBaseNamenaturalPowModNamenaturalSizeInBaseNameintegerFromNaturalNameintegerToNaturalClampNameintegerToNaturalThrowNameintegerToNaturalNameintegerToWordNameintegerToIntNameintegerToWord64NameintegerToInt64NameintegerFromWordNameintegerFromWord64NameintegerFromInt64NameintegerAddNameintegerMulNameintegerSubNameintegerNegateNameintegerAbsNameintegerPopCountNameintegerQuotNameintegerRemNameintegerDivNameintegerModNameintegerDivModNameintegerQuotRemNameintegerEncodeFloatNameintegerEncodeDoubleNameintegerGcdNameintegerLcmNameintegerAndName integerOrNameintegerXorNameintegerComplementNameintegerBitNameintegerTestBitNameintegerShiftLNameintegerShiftRNamerationalTyConNameratioTyConNameratioDataConName realClassNameintegralClassNamerealFracClassNamefractionalClassNamefromRationalName toIntegerNametoRationalNamefromIntegralNamerealToFracNamemkRationalBase2NamemkRationalBase10NamefloatingClassNamerealFloatClassNameintegerToFloatNameintegerToDoubleNamenaturalToFloatNamenaturalToDoubleNamerationalToFloatNamerationalToDoubleName ixClassNametrModuleTyConNametrModuleDataConNametrNameTyConNametrNameSDataConNametrNameDDataConNametrTyConTyConNametrTyConDataConNamekindRepTyConNamekindRepTyConAppDataConNamekindRepVarDataConNamekindRepAppDataConNamekindRepFunDataConNamekindRepTYPEDataConNamekindRepTypeLitSDataConNamekindRepTypeLitDDataConNametypeLitSortTyConNametypeLitSymbolDataConNametypeLitNatDataConNametypeLitCharDataConNametypeableClassNametypeRepTyConNamesomeTypeRepTyConNamesomeTypeRepDataConName typeRepIdName mkTrTypeName mkTrConName mkTrAppName mkTrFunNametypeNatTypeRepNametypeSymbolTypeRepNametypeCharTypeRepNametrGhcPrimModuleNamestarKindRepNamestarArrStarKindRepNamestarArrStarArrStarKindRepNameconstraintKindRepNamewithDictClassNamenonEmptyTyConNameerrorMessageTypeErrorFamNametypeErrorTextDataConNametypeErrorAppendDataConNametypeErrorVAppendDataConNametypeErrorShowTypeDataConNameunsafeEqualityProofNameunsafeEqualityTyConNameunsafeReflDataConNameunsafeCoercePrimName toDynName dataClassNameassertErrorName traceName enumClassName enumFromNameenumFromToNameenumFromThenNameenumFromThenToNameboundedClassName concatName filterNamezipNameisListClassName fromListName fromListNName toListName getFieldName setFieldName showClassName readClassName genClassName gen1ClassNamedatatypeClassNameconstructorClassNameselectorClassNamegenericClassNamesghciIoClassNameghciStepIoMName ioTyConName ioDataConName thenIOName bindIOName returnIOName failIOName printName int8TyConNameint16TyConNameint32TyConNameint64TyConNameword8TyConNameword16TyConNameword32TyConNameword64TyConName ptrTyConNamefunPtrTyConNamestablePtrTyConNamenewStablePtrNamemonadFixClassNamemfixNamearrAName composeAName firstANameappAName choiceAName loopAName guardMName liftMNamemzipNametoAnnotationWrapperNamemonadPlusClassNameisStringClassNameknownNatClassNameknownSymbolClassNameknownCharClassNamefromLabelClassOpName ipClassNamehasFieldClassNamecallStackTyConNameemptyCallStackNamepushCallStackNamesrcLocDataConNamepLUGINSpluginTyConNamefrontendPluginTyConNamemakeStaticNamestaticPtrInfoTyConNamestaticPtrInfoDataConNamestaticPtrTyConNamestaticPtrDataConNamefromStaticPtrNamefingerprintDataConNameconstPtrConNamevarQualtcQualclsQualdcQualmk_known_key_nameboundedClassKey enumClassKey eqClassKeyfloatingClassKeyfractionalClassKeyintegralClassKey monadClassKey dataClassKeyfunctorClassKey numClassKey ordClassKey readClassKey realClassKeyrealFloatClassKeyrealFracClassKey showClassKey ixClassKeytypeableClassKeywithDictClassKeymonadFixClassKeymonadFailClassKeymonadPlusClassKeyrandomClassKeyrandomGenClassKeyisStringClassKeyapplicativeClassKeyfoldableClassKeytraversableClassKey genClassKey gen1ClassKeydatatypeClassKeyconstructorClassKeyselectorClassKeyknownNatClassNameKeyknownSymbolClassNameKeyknownCharClassNameKeyghciIoClassKeysemigroupClassKeymonoidClassKey ipClassKeyhasFieldClassNameKeyaddrPrimTyConKeyarrayPrimTyConKey boolTyConKeybyteArrayPrimTyConKeystringTyConKeycharPrimTyConKey charTyConKeydoublePrimTyConKeydoubleTyConKeyfloatPrimTyConKey floatTyConKey fUNTyConKeyintPrimTyConKey intTyConKeyint8PrimTyConKey int8TyConKeyint16PrimTyConKey int16TyConKeyint32PrimTyConKey int32TyConKeyint64PrimTyConKey int64TyConKeyintegerTyConKeynaturalTyConKey listTyConKeyforeignObjPrimTyConKey maybeTyConKeyweakPrimTyConKeymutableArrayPrimTyConKeymutableByteArrayPrimTyConKeyorderingTyConKeymVarPrimTyConKeyioPortPrimTyConKey ratioTyConKeyrationalTyConKeyrealWorldTyConKeystablePtrPrimTyConKeystablePtrTyConKey eqTyConKey heqTyConKeyctArrowTyConKeyccArrowTyConKeytcArrowTyConKeystatePrimTyConKeystableNamePrimTyConKeystableNameTyConKeyeqPrimTyConKeyeqReprPrimTyConKeyeqPhantPrimTyConKeymutVarPrimTyConKey ioTyConKeywordPrimTyConKey wordTyConKeyword8PrimTyConKey word8TyConKeyword16PrimTyConKeyword16TyConKeyword32PrimTyConKeyword32TyConKeyword64PrimTyConKeyword64TyConKey kindConKey boxityConKey typeConKeythreadIdPrimTyConKeybcoPrimTyConKey ptrTyConKeyfunPtrTyConKeytVarPrimTyConKeycompactPrimTyConKeystackSnapshotPrimTyConKeypromptTagPrimTyConKeyeitherTyConKey voidTyConKeynonEmptyTyConKey dictTyConKeyliftedTypeKindTyConKeyunliftedTypeKindTyConKey tYPETyConKeycONSTRAINTTyConKeyconstraintKindTyConKeylevityTyConKeyruntimeRepTyConKeyvecCountTyConKeyvecElemTyConKeyliftedRepTyConKeyunliftedRepTyConKeyzeroBitRepTyConKeyzeroBitTypeTyConKeypluginTyConKeyfrontendPluginTyConKeytrTyConTyConKeytrModuleTyConKeytrNameTyConKeykindRepTyConKeytypeLitSortTyConKey v1TyConKey u1TyConKey par1TyConKey rec1TyConKey k1TyConKey m1TyConKey sumTyConKey prodTyConKey compTyConKey rTyConKey dTyConKey cTyConKey sTyConKey rec0TyConKey d1TyConKey c1TyConKey s1TyConKey repTyConKey rep1TyConKey uRecTyConKey uAddrTyConKey uCharTyConKeyuDoubleTyConKeyuFloatTyConKey uIntTyConKey uWordTyConKeyerrorMessageTypeErrorFamKeycoercibleTyConKeyproxyPrimTyConKey specTyConKey anyTyConKeysmallArrayPrimTyConKeysmallMutableArrayPrimTyConKeystaticPtrTyConKeystaticPtrInfoTyConKeycallStackTyConKeytypeRepTyConKeysomeTypeRepTyConKeysomeTypeRepDataConKeytypeSymbolAppendFamNameKeyunsafeEqualityTyConKeymultiplicityTyConKeyunrestrictedFunTyConKeymultMulTyConKeyint8X16PrimTyConKeyint16X8PrimTyConKeyint32X4PrimTyConKeyint64X2PrimTyConKeyint8X32PrimTyConKeyint16X16PrimTyConKeyint32X8PrimTyConKeyint64X4PrimTyConKeyint8X64PrimTyConKeyint16X32PrimTyConKeyint32X16PrimTyConKeyint64X8PrimTyConKeyword8X16PrimTyConKeyword16X8PrimTyConKeyword32X4PrimTyConKeyword64X2PrimTyConKeyword8X32PrimTyConKeyword16X16PrimTyConKeyword32X8PrimTyConKeyword64X4PrimTyConKeyword8X64PrimTyConKeyword16X32PrimTyConKeyword32X16PrimTyConKeyword64X8PrimTyConKeyfloatX4PrimTyConKeydoubleX2PrimTyConKeyfloatX8PrimTyConKeydoubleX4PrimTyConKeyfloatX16PrimTyConKeydoubleX8PrimTyConKeytypeSymbolKindConNameKeytypeCharKindConNameKeytypeNatAddTyFamNameKeytypeNatMulTyFamNameKeytypeNatExpTyFamNameKeytypeNatSubTyFamNameKeytypeSymbolCmpTyFamNameKeytypeNatCmpTyFamNameKeytypeCharCmpTyFamNameKeytypeLeqCharTyFamNameKeytypeNatDivTyFamNameKeytypeNatModTyFamNameKeytypeNatLogTyFamNameKeytypeConsSymbolTyFamNameKeytypeUnconsSymbolTyFamNameKeytypeCharToNatTyFamNameKeytypeNatToCharTyFamNameKeyconstPtrTyConKeycharDataConKeyconsDataConKeydoubleDataConKeyfalseDataConKeyfloatDataConKey intDataConKeynothingDataConKeyjustDataConKey eqDataConKey nilDataConKeyratioDataConKeyword8DataConKeystableNameDataConKeytrueDataConKeywordDataConKey ioDataConKey heqDataConKeycrossDataConKey inlDataConKey inrDataConKeygenUnitDataConKeyleftDataConKeyrightDataConKeyordLTDataConKeyordEQDataConKeyordGTDataConKeymkDictDataConKeycoercibleDataConKeystaticPtrDataConKeystaticPtrInfoDataConKeyfingerprintDataConKeysrcLocDataConKeytrTyConDataConKeytrModuleDataConKeytrNameSDataConKeytrNameDDataConKeytrGhcPrimModuleKeytypeErrorTextDataConKeytypeErrorAppendDataConKeytypeErrorVAppendDataConKeytypeErrorShowTypeDataConKeyprefixIDataConKeyinfixIDataConKeyleftAssociativeDataConKeyrightAssociativeDataConKeynotAssociativeDataConKeysourceUnpackDataConKeysourceNoUnpackDataConKeynoSourceUnpackednessDataConKeysourceLazyDataConKeysourceStrictDataConKeynoSourceStrictnessDataConKeydecidedLazyDataConKeydecidedStrictDataConKeydecidedUnpackDataConKeymetaDataDataConKeymetaConsDataConKeymetaSelDataConKeyvecRepDataConKeytupleRepDataConKeysumRepDataConKeyboxedRepDataConKeyboxedRepDataConTyConKeytupleRepDataConTyConKeyruntimeRepSimpleDataConKeysliftedDataConKeyunliftedDataConKeyvecCountDataConKeysvecElemDataConKeyskindRepTyConAppDataConKeykindRepVarDataConKeykindRepAppDataConKeykindRepFunDataConKeykindRepTYPEDataConKeykindRepTypeLitSDataConKeykindRepTypeLitDDataConKeytypeLitSymbolDataConKeytypeLitNatDataConKeytypeLitCharDataConKeyunsafeReflDataConKey oneDataConKeymanyDataConKeyintegerISDataConKeyintegerINDataConKeyintegerIPDataConKeynaturalNSDataConKeynaturalNBDataConKey wildCardKeyabsentErrorIdKeyabsentConstraintErrorIdKey augmentIdKey appendIdKey buildIdKey foldrIdKeyrecSelErrorIdKeyseqIdKeyabsentSumFieldErrorIdKey eqStringIdKeynoMethodBindingErrorIdKeynonExhaustiveGuardsErrorIdKeyimpossibleErrorIdKeyimpossibleConstraintErrorIdKey patErrorIdKeyrealWorldPrimIdKeyrecConErrorIdKeyunpackCStringUtf8IdKeyunpackCStringAppendUtf8IdKeyunpackCStringFoldrUtf8IdKeyunpackCStringIdKeyunpackCStringAppendIdKeyunpackCStringFoldrIdKey voidPrimIdKeytypeErrorIdKey divIntIdKey modIntIdKeycstringLengthIdKey concatIdKey filterIdKeyzipIdKey bindIOIdKey returnIOIdKeynewStablePtrIdKey printIdKey failIOIdKey nullAddrIdKey voidArgIdKeyotherwiseIdKey assertIdKeyleftSectionKeyrightSectionKey rootMainKey runMainKey thenIOIdKey lazyIdKeyassertErrorIdKey oneShotKeyrunRWKeytraceKey nospecIdKey inlineIdKeymapIdKey dollarIdKeycoercionTokenIdKeyconsiderAccessibleIdKey noinlineIdKeynoinlineConstraintIdKeyintegerToFloatIdKeyintegerToDoubleIdKeynaturalToFloatIdKeynaturalToDoubleIdKeyrationalToFloatIdKeyrationalToDoubleIdKey coerceKey unboundKeyfromIntegerClassOpKeyminusClassOpKeyfromRationalClassOpKeyenumFromClassOpKeyenumFromThenClassOpKeyenumFromToClassOpKeyenumFromThenToClassOpKey eqClassOpKey geClassOpKeynegateClassOpKeybindMClassOpKeythenMClassOpKeyfmapClassOpKeyreturnMClassOpKey mfixIdKeyfailMClassOpKeyfromLabelClassOpKey arrAIdKey composeAIdKey firstAIdKey appAIdKey choiceAIdKey loopAIdKeyfromStringClassOpKeytoAnnotationWrapperIdKeyfromIntegralIdKeyrealToFracIdKeytoIntegerClassOpKeytoRationalClassOpKey guardMIdKey liftMIdKey mzipIdKeyghciStepIoMClassOpKeyisListClassKeyfromListClassOpKeyfromListNClassOpKeytoListClassOpKey proxyHashKey mkTyConKey mkTrTypeKey mkTrConKey mkTrAppKeytypeNatTypeRepKeytypeSymbolTypeRepKeytypeCharTypeRepKey typeRepIdKey mkTrFunKey trTYPEKeytrTYPE'PtrRepLiftedKeytrRuntimeRepKeytr'PtrRepLiftedKeytrLiftedRepKeystarKindRepKeystarArrStarKindRepKeystarArrStarArrStarKindRepKeyconstraintKindRepKey toDynIdKeybitIntegerIdKey eqSCSelIdKey heqSCSelIdKeycoercibleSCSelIdKeysappendClassOpKeymemptyClassOpKeymappendClassOpKeymconcatClassOpKeyemptyCallStackKeypushCallStackKeyfromStaticPtrClassOpKey makeStaticKeyunsafeEqualityProofIdKeyunsafeCoercePrimIdKeygetFieldClassOpKeysetFieldClassOpKeyintegerFromNaturalIdKeyintegerToNaturalClampIdKeyintegerToNaturalThrowIdKeyintegerToNaturalIdKeyintegerToWordIdKeyintegerToIntIdKeyintegerToWord64IdKeyintegerToInt64IdKeyintegerAddIdKeyintegerMulIdKeyintegerSubIdKeyintegerNegateIdKeyintegerAbsIdKeyintegerPopCountIdKeyintegerQuotIdKeyintegerRemIdKeyintegerDivIdKeyintegerModIdKeyintegerDivModIdKeyintegerQuotRemIdKeyintegerEncodeFloatIdKeyintegerEncodeDoubleIdKeyintegerGcdIdKeyintegerLcmIdKeyintegerAndIdKeyintegerOrIdKeyintegerXorIdKeyintegerComplementIdKeyintegerBitIdKeyintegerTestBitIdKeyintegerShiftLIdKeyintegerShiftRIdKeyintegerFromWordIdKeyintegerFromWord64IdKeyintegerFromInt64IdKeynaturalToWordIdKeynaturalPopCountIdKeynaturalShiftRIdKeynaturalShiftLIdKeynaturalAddIdKeynaturalSubIdKeynaturalSubThrowIdKeynaturalSubUnsafeIdKeynaturalMulIdKeynaturalQuotRemIdKeynaturalQuotIdKeynaturalRemIdKeynaturalAndIdKeynaturalAndNotIdKeynaturalOrIdKeynaturalXorIdKeynaturalTestBitIdKeynaturalBitIdKeynaturalGcdIdKeynaturalLcmIdKeynaturalLog2IdKeynaturalLogBaseWordIdKeynaturalLogBaseIdKeynaturalPowModIdKeynaturalSizeInBaseIdKeybignatFromWordListIdKey bignatEqIdKeybignatCompareIdKeybignatCompareWordIdKeymkRationalBase2IdKeymkRationalBase10IdKeynumericClassKeysfractionalClassKeysstandardClassKeysderivableClassKeysinteractiveClassNamesinteractiveClassKeyspretendNameIsInScopeAnnEnv CoreAnnTarget AnnTarget NamedTarget ModuleTarget AnnPayload ann_target ann_value emptyAnnEnvmkAnnEnvextendAnnEnvList plusAnnEnvfindAnnsfindAnnsByTypeRepdeserializeAnns$fBinaryAnnTarget$fOutputableAnnTarget$fOutputableAnnotation$fFunctorAnnTargetfingerprintBinMemcomputeFingerprintputNameLiterallyFixItem FixityEnvemptyFixityEnv lookupFixitymkIfaceFixCacheemptyIfaceFixCache$fOutputableFixItemEpAnnImportDeclimportDeclAnnImportimportDeclAnnPragmaimportDeclAnnSafeimportDeclAnnQualifiedimportDeclAnnPackageimportDeclAnnAsXImportDeclPassideclAnnideclSourceText ideclImplicitimportDeclQualifiedStyleisImportDeclQualifiedsimpleImportDeclieNameieNamesieWrappedLName ieWrappedNamelieWrappedNameieLWrappedNamereplaceWrappedNamereplaceLWrappedName pprImpExp$fOutputableIEWrappedName$fOutputableBndrIEWrappedName$fHasOccNameIEWrappedName$fOutputableIE$fOutputableImportDecl$fDataXImportDeclPass$fDataEpAnnImportDecl$fEqIEWrappedName$fEqIEWrappedName0$fEqIEWrappedName1$fDataIEWrappedName$fDataIEWrappedName0$fDataIEWrappedName1RuleOpts roPlatformroNumConstantFoldingroExcessRationalPrecision roBignumRulesDoAlignSanitisation ForeignHintNoHintAddrHint SignedHintLengthWidthW8W16W32W64W128W256W512CmmType cmmEqTypecmmEqType_ignoring_ptrhood typeWidthcmmBitscmmFloatb8b16b32b64b128b256b512f32f64bWord bHalfWordgcWordcInt isFloatType isGcPtrType isBitsType isWordAnyisWord64isWord32 isFloat32 isFloat64 wordWidth halfWordWidth halfWordMask cIntWidth widthInBits widthInByteswidthFromBytes widthInLognarrowUnarrowSvecvec2vec4vec8vec16vec2f64vec2b64vec4f32vec4b32vec8b16vec16b8cmmVec vecLength vecElemType isVecTyperEP_CostCentreStack_mem_allocrEP_CostCentreStack_scc_countrEP_StgEntCounter_allocsrEP_StgEntCounter_allocd$fOutputableWidth$fOutputableCmmCat$fOutputableCmmType$fOutputableForeignHint$fEqForeignHint $fShowCmmType $fEqCmmCat $fShowCmmCat $fEqWidth $fOrdWidth $fShowWidth ForeignStubsNoStubsCHeader getCHeaderCStubgetCStubgetInitializers getFinalizersinitializerCStubfinalizerCStub appendStubC$fSemigroupCStub $fMonoidCStub$fSemigroupCHeader$fMonoidCHeaderWaysWay WayCustom WayThreadedWayDebugWayProfWayDynhasWay hasNotWayaddWay removeWayallowed_combinationwaysTag waysBuildTagwayTag wayRTSOnlyfullWaysrtsWayswayDescwayGeneralFlagswayUnsetGeneralFlagswayOptcwayOptlwayOptPhostIsProfiled hostIsDynamichostIsThreadedhostIsDebugged hostIsTracinghostWays hostFullWays$fEqWay$fOrdWay $fShowWay $fReadWayProfileprofilePlatform profileWaysprofileConstantsprofileIsProfilingprofileWordSizeInBytesprofileBuildTag $fEqProfile $fOrdProfile $fShowProfile $fReadProfile GlobalReg VanillaRegFloatReg DoubleRegLongRegXmmRegYmmRegZmmRegSpSpLimHpHpLimCCCS CurrentTSOCurrentNurseryHpAllocEagerBlackholeInfoGCEnter1GCFunBaseRegMachSpUnwindReturnReg PicBaseRegVGcPtr VNonGcPtrLocalRegCmmRegCmmLocal CmmGlobal cmmRegType cmmRegWidth localRegType pprGlobalRegbaseRegspReghpReghpLimRegspLimRegnodeReg currentTSORegcurrentNurseryReg hpAllocRegcccsRegnode globalRegTypeisArgReg$fUniquableLocalReg $fOrdLocalReg$fOutputableLocalReg $fEqLocalReg$fOutputablePenvGlobalReg$fOutputableGlobalReg$fOrdGlobalReg $fEqGlobalReg$fOutputableCmmReg $fEqCmmReg $fOrdCmmReg $fShowCmmReg$fShowGlobalReg $fEqVGcPtr $fShowVGcPtr$fShowLocalReg AtomicMachOpAMO_AddAMO_SubAMO_AndAMO_NandAMO_OrAMO_XorMemoryOrderingMemOrderRelaxedMemOrderAcquireMemOrderReleaseMemOrderSeqCst CallishMachOp MO_F64_Pwr MO_F64_Sin MO_F64_Cos MO_F64_Tan MO_F64_Sinh MO_F64_Cosh MO_F64_Tanh MO_F64_Asin MO_F64_Acos MO_F64_Atan MO_F64_Asinh MO_F64_Acosh MO_F64_Atanh MO_F64_Log MO_F64_Log1P MO_F64_Exp MO_F64_ExpM1 MO_F64_Fabs MO_F64_Sqrt MO_F32_Pwr MO_F32_Sin MO_F32_Cos MO_F32_Tan MO_F32_Sinh MO_F32_Cosh MO_F32_Tanh MO_F32_Asin MO_F32_Acos MO_F32_Atan MO_F32_Asinh MO_F32_Acosh MO_F32_Atanh MO_F32_Log MO_F32_Log1P MO_F32_Exp MO_F32_ExpM1 MO_F32_Fabs MO_F32_Sqrt MO_I64_ToI MO_I64_FromI MO_W64_ToW MO_W64_FromW MO_x64_Neg MO_x64_Add MO_x64_Sub MO_x64_Mul MO_I64_Quot MO_I64_Rem MO_W64_Quot MO_W64_Rem MO_x64_And MO_x64_Or MO_x64_Xor MO_x64_Not MO_x64_Shl MO_I64_Shr MO_W64_Shr MO_x64_Eq MO_x64_Ne MO_I64_Ge MO_I64_Gt MO_I64_Le MO_I64_Lt MO_W64_Ge MO_W64_Gt MO_W64_Le MO_W64_Lt MO_UF_Conv MO_S_Mul2 MO_S_QuotRem MO_U_QuotRem MO_U_QuotRem2MO_Add2 MO_AddWordC MO_SubWordC MO_AddIntC MO_SubIntC MO_U_Mul2MO_ReadBarrierMO_WriteBarrierMO_TouchMO_Prefetch_Data MO_Memcpy MO_Memset MO_Memmove MO_Memcmp MO_PopCntMO_PdepMO_PextMO_ClzMO_CtzMO_BSwapMO_BRev MO_AtomicRMW MO_AtomicReadMO_AtomicWrite MO_CmpxchgMO_XchgMO_SuspendThreadMO_ResumeThreadMachOpMO_AddMO_SubMO_EqMO_NeMO_MulMO_S_MulMayOflo MO_S_QuotMO_S_RemMO_S_Neg MO_U_QuotMO_U_RemMO_S_GeMO_S_LeMO_S_GtMO_S_LtMO_U_GeMO_U_LeMO_U_GtMO_U_LtMO_F_AddMO_F_SubMO_F_NegMO_F_Mul MO_F_QuotMO_F_EqMO_F_NeMO_F_GeMO_F_LeMO_F_GtMO_F_LtMO_AndMO_OrMO_XorMO_NotMO_ShlMO_U_ShrMO_S_Shr MO_SF_Conv MO_FS_Conv MO_SS_Conv MO_UU_Conv MO_XX_Conv MO_FF_Conv MO_V_Insert MO_V_ExtractMO_V_AddMO_V_SubMO_V_Mul MO_VS_Quot MO_VS_Rem MO_VS_Neg MO_VU_Quot MO_VU_Rem MO_VF_Insert MO_VF_Extract MO_VF_Add MO_VF_Sub MO_VF_Neg MO_VF_Mul MO_VF_QuotMO_AlignmentCheck pprMachOp mo_wordAdd mo_wordSub mo_wordEq mo_wordNe mo_wordMul mo_wordSQuot mo_wordSRem mo_wordSNeg mo_wordUQuot mo_wordURem mo_wordSGe mo_wordSLe mo_wordSGt mo_wordSLt mo_wordUGe mo_wordULe mo_wordUGt mo_wordULt mo_wordAnd mo_wordOr mo_wordXor mo_wordNot mo_wordShl mo_wordSShr mo_wordUShr mo_u_8To32 mo_s_8To32 mo_u_16To32 mo_s_16To32 mo_u_8ToWord mo_s_8ToWord mo_u_16ToWord mo_s_16ToWord mo_s_32ToWord mo_u_32ToWord mo_WordTo8 mo_WordTo16 mo_WordTo32 mo_WordTo64mo_32To8 mo_32To16isCommutableMachOpisAssociativeMachOpisComparisonMachOpmaybeIntComparisonisFloatComparisonmaybeInvertComparisonmachOpResultType machOpArgRepspprCallishMachOpcallishMachOpHintsmachOpMemcpyishAlign$fEqCallishMachOp$fShowCallishMachOp$fEqAtomicMachOp$fShowAtomicMachOp$fEqMemoryOrdering$fOrdMemoryOrdering$fShowMemoryOrdering $fEqMachOp $fShowMachOpGhcNameVersionghcNameVersion_programNameghcNameVersion_projectVersion FileSettingsfileSettings_ghcUsagePathfileSettings_ghciUsagePathfileSettings_toolDirfileSettings_topDir"fileSettings_globalPackageDatabase ToolSettings$toolSettings_ldSupportsCompactUnwindtoolSettings_ldSupportsFilelisttoolSettings_ldIsGnuLdtoolSettings_ccSupportsNoPietoolSettings_useInplaceMinGWtoolSettings_arSupportsDashLtoolSettings_pgm_LtoolSettings_pgm_PtoolSettings_pgm_FtoolSettings_pgm_ctoolSettings_pgm_cxxtoolSettings_pgm_atoolSettings_pgm_ltoolSettings_pgm_lmtoolSettings_pgm_dlltoolSettings_pgm_TtoolSettings_pgm_windrestoolSettings_pgm_artoolSettings_pgm_otool"toolSettings_pgm_install_name_tooltoolSettings_pgm_ranlibtoolSettings_pgm_lotoolSettings_pgm_lctoolSettings_pgm_lcctoolSettings_pgm_itoolSettings_opt_LtoolSettings_opt_PtoolSettings_opt_P_fingerprinttoolSettings_opt_FtoolSettings_opt_ctoolSettings_opt_cxxtoolSettings_opt_atoolSettings_opt_ltoolSettings_opt_lmtoolSettings_opt_windrestoolSettings_opt_lotoolSettings_opt_lctoolSettings_opt_lcctoolSettings_opt_itoolSettings_extraGccViaCFlagsSettingssGhcNameVersion sFileSettingssTargetPlatform sToolSettings sPlatformMisc sRawSettings dynLibSuffix sProgramNamesProjectVersion sGhcUsagePathsGhciUsagePathsToolDirsTopDirsGlobalPackageDatabasePathsLdSupportsCompactUnwindsLdSupportsFilelist sLdIsGnuLdsGccSupportsNoPiesUseInplaceMinGWsArSupportsDashLsPgm_LsPgm_PsPgm_FsPgm_csPgm_cxxsPgm_asPgm_lsPgm_lmsPgm_dllsPgm_T sPgm_windressPgm_ar sPgm_otoolsPgm_install_name_tool sPgm_ranlibsPgm_losPgm_lcsPgm_lccsPgm_isOpt_LsOpt_PsOpt_P_fingerprintsOpt_FsOpt_csOpt_cxxsOpt_asOpt_lsOpt_lm sOpt_windressOpt_losOpt_lcsOpt_lccsOpt_isExtraGccViaCFlagssTargetPlatformStringsGhcWithInterpretersLibFFI PackageName unPackageName PackageIdUnitInfo UnitKeyInfo GenUnitInfo mkUnitKeyInfo mapUnitInfounitPackageIdStringunitPackageNameString pprUnitInfomkUnit mkUnitPprInfocollectIncludeDirscollectExtraCcOptscollectLibraryDirscollectFrameworkscollectFrameworksDirs unitHsLibs$fOutputablePackageId$fUniquablePackageId$fOutputablePackageName$fUniquablePackageName$fEqPackageName $fEqPackageIdUnlitCppHsPpHscCcxxCcCobjcCobjcxxHCcAsLlvmOptLlvmLlc LlvmMangleCmmCppCmm MergeForeignJsStopLn StopPhaseStopPreprocessStopCStopAsNoStopstopPhaseToPhaseisStopLneqPhase happensBefore startPhase phaseInputExtisHaskellishSuffixisBackpackishSuffixisHaskellSigSuffixisHaskellSrcSuffix isCishSuffixisHaskellUserSrcSuffixisObjectSuffixisDynLibSuffixisSourceSuffixisHaskellishTargetisHaskellishFilenameisHaskellSrcFilenameisCishFilenameisHaskellUserSrcFilenameisSourceFilenameisHaskellSigFilenameisObjectFilenameisDynLibFilenamephaseForeignLanguage$fOutputablePhase $fEqPhase $fShowPhase exeFileName LlvmVersion llvmVersionNE LlvmConfig llvmTargets llvmPasses LlvmTarget lDataLayoutlCPU lAttributes LlvmCgConfigllvmCgPlatform llvmCgContextllvmCgFillUndefWithGarbagellvmCgSplitSectionllvmCgBmiVersionllvmCgLlvmVersion llvmCgDoWarnllvmCgLlvmTargetllvmCgLlvmConfiginitLlvmConfigparseLlvmVersionsupportedLlvmVersionLowerBoundsupportedLlvmVersionUpperBoundllvmVersionSupportedllvmVersionStrllvmVersionList$fEqLlvmVersion$fOrdLlvmVersionLlvmConfigCacheinitLlvmConfigCachereadLlvmConfigCacheBuiltInSynFamily sfMatchFam sfInteractTopsfInteractInert CoAxiomRule coaxrNamecoaxrAsmpRoles coaxrRole coaxrProvesTypeEqn CoAxBranchcab_loccab_tvs cab_eta_tvscab_cvs cab_rolescab_lhscab_rhs cab_incompsCoAxiom co_ax_unique co_ax_name co_ax_roleco_ax_tcco_ax_branchesco_ax_implicitBranches MkBranches unMkBranches UnbranchedBranched BranchFlag BranchIndex manyBranches unbranched fromBranches numBranchesmapAccumBranchestoBranchedAxiomtoUnbranchedAxiomcoAxiomNumPatscoAxiomNthBranch coAxiomArity coAxiomName coAxiomRolecoAxiomBranchescoAxiomSingleBranch_maybecoAxiomSingleBranch coAxiomTyConcoAxBranchTyVarscoAxBranchCoVars coAxBranchLHS coAxBranchRHScoAxBranchRolescoAxBranchSpanisImplicitCoAxiomcoAxBranchIncompsplaceHolderIncomps fsFromRoletrivialBuiltInFamily $fBinaryRole$fOutputableRole$fOutputableCoAxBranch$fOutputableCoAxiom $fDataCoAxiom$fNamedThingCoAxiom$fUniquableCoAxiom $fEqCoAxiom$fOutputableCoAxiomRule$fOrdCoAxiomRule$fEqCoAxiomRule$fUniquableCoAxiomRule$fDataCoAxiomRule$fDataCoAxBranchLiftingContexttopNormaliseNewType_maybe coercionType coercionRKind coercionLKind coercionKindseqCo liftCoSubstmkCoercionType coVarRolecoVarKindsTypesRoledecomposePiCos isReflexiveCoisReflCo isGReflCo mkAxiomRuleComkProofIrrelComkSubComkKindCo mkNomReflCo mkGReflComkInstComkLRComkSelCo mkTransComkSymComkUnivCo mkPhantomCo mkAxiomInstCo mkCoVarComkFunCo2 mkNakedFunCo1mkFunCo1 mkForAllComkAppCo mkTyConAppComkReflCoClassMinimalDefATValidityInfoNoATVIATVI ClassATItemATI DefMethInfo ClassOpItemFunDepClass classTyCon classNameclassKey classTyVarsclassMinimalDefmkClassmkAbstractClass classArityclassAllSelIds classSCSelIds classSCSelId classMethods classOpItemsclassATs classATItems classSCTheta classTvsFds classHasFds classBigSigclassExtraBigSigisAbstractClasspprDefMethInfo pprFundeps pprFunDep $fDataClass$fOutputableClass$fNamedThingClass$fUniquableClass $fEqClass DataConBoxer mkDictSelIdmkDataConWorkId TyConFlavour ClassFlavour TupleFlavour SumFlavourDataTypeFlavourNewtypeFlavourAbstractTypeFlavourDataFamilyFlavourOpenTypeFamilyFlavourClosedTypeFamilyFlavourTypeSynonymFlavourBuiltInTypeFlavourPromotedDataConFlavourExpandSynResult NoExpansion ExpandsSyn PrimElemRep Int8ElemRep Int16ElemRep Int32ElemRep Int64ElemRep Word8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep FloatElemRep DoubleElemRepPrimRepVoidRep LiftedRep UnliftedRepInt8RepInt16RepInt32RepInt64RepIntRepWord8Rep Word16Rep Word32Rep Word64RepWordRepAddrRepFloatRep DoubleRepVecRep FamTyConFlavDataFamilyTyConOpenSynFamilyTyConClosedSynFamilyTyConAbstractClosedSynFamilyTyConBuiltInSynFamTyCon Injectivity NotInjective Injective AlgTyConFlavVanillaAlgTyConUnboxedSumTyCon ClassTyConDataFamInstTyConPromDataConInfo NoPromInfo RuntimeRepVecCountVecElem AlgTyConRhs AbstractTyCon DataTyCon TupleTyConSumTyConNewTyCon data_consdata_cons_sizeis_enum is_type_datadata_fixed_levdata_contup_sortnt_rhs nt_etad_rhsnt_co nt_fixed_rep algTcFields tyConUnique tyConBinders tyConResKindtyConHasClosedResKind tyConTyVars tyConKind tyConAritytyConNullaryTy tyConRoles TyConBndrVisNamedTCBAnonTCBTyConPiTyBinder TyConBindermkAnonTyConBindermkAnonTyConBindersmkInvisAnonTyConBindermkNamedTyConBindermkNamedTyConBindersmkRequiredTyConBindertyConBinderForAllTyFlagtyConBndrVisForAllTyFlagisNamedTyConBinderisVisibleTyConBinderisVisibleTcbVisisInvisibleTyConBinder mkTyConKindtyConInvisTVBinderstyConVisibleTyVarsmkLevPolyDataTyConRhsmkDataTyConRhsvisibleDataCons isNoParenttyConRepModOcc isVoidRep isGcPtrRepprimRepCompatibleprimRepsCompatible primRepSizeBprimElemRepSizeBprimElemRepToPrimRepprimRepIsFloat primRepIsWord primRepIsInttyConFieldLabelslookupTyConFieldLabel mkAlgTyCon mkClassTyCon mkTupleTyCon mkSumTyCon mkTcTyConnoTcTyConScopedTyVars mkPrimTyConmkSynonymTyCon mkFamilyTyConmkPromotedDataConisAbstractTyCon isPrimTyCon isAlgTyConisVanillaAlgTyCon isDataTyConisTypeDataTyConisInjectiveTyConisGenerativeTyConisGenInjAlgRhs isNewTyConunwrapNewTyCon_maybeunwrapNewTyConEtad_maybeisTypeSynonymTyCon isTauTyConisFamFreeTyConisForgetfulSynTyContyConMustBeSaturatedisGadtSyntaxTyConisEnumerationTyCon isFamilyTyConisOpenFamilyTyConisTypeFamilyTyConisDataFamilyTyConisOpenTypeFamilyTyCon%isClosedSynFamilyTyConWithAxiom_maybeisBuiltInSynFamTyCon_maybetyConFamilyResVar_maybetyConInjectivityInfo isTyConAssoctyConAssoc_maybetyConFlavourAssoc_maybetyConTuple_maybeisBoxedTupleTyConisUnboxedSumTyConisLiftedAlgTyConisPromotedDataCon_maybeisPromotedTupleTyConisPromotedDataConisDataKindsPromotedDataCon isKindTyConisLiftedTypeKindTyConNameisImplicitTyContyConCType_maybetcHasFixedRuntimeRepisConcreteTyCon isTcTyConsetTcTyConKind isMonoTcTyContcTyConScopedTyVarsexpandSynTyCon_maybeisTyConWithSrcDataCons tyConDataConstyConDataCons_maybetyConSingleDataCon_maybetyConSingleDataContyConSingleAlgDataCon_maybetyConAlgDataCons_maybetyConFamilySize algTyConRhs newTyConRhsnewTyConEtadAritynewTyConEtadRhsnewTyConCo_maybe newTyConConewTyConDataCon_maybetyConStupidThetasynTyConDefn_maybesynTyConRhs_maybefamTyConFlav_maybe isClassTyContyConClass_maybetyConATsisFamInstTyContyConFamInstSig_maybetyConFamInst_maybetyConFamilyCoercion_maybetyConPromDataConInfo mkTyConTagMap tyConFlavourtcFlavourIsOpenpprPromotionQuote tyConSkolem$fBinaryTyConBndrVis$fOutputableTyConBndrVis$fBinaryInjectivity$fOutputableFamTyConFlav$fBinaryPrimElemRep$fOutputablePrimElemRep$fBinaryPrimRep$fOutputablePrimRep $fDataTyCon$fNamedThingTyCon$fOutputableTyConFlavour$fOutputableTyCon$fUniquableTyCon $fEqTyCon$fOutputableAlgTyConFlav$fEqTyConFlavour $fDataPrimRep $fEqPrimRep $fOrdPrimRep $fShowPrimRep$fDataPrimElemRep$fEqPrimElemRep$fOrdPrimElemRep$fShowPrimElemRep$fEnumPrimElemRep$fEqInjectivitytidyToIfaceTcArgstoIfaceCoercionX toIfaceTcArgs toIfaceTyContoIfaceForAllBndrs toIfaceTyLit toIfaceTypeX TyCoFoldertcf_view tcf_tyvar tcf_covartcf_holetcf_tycobinder CoercionHole ch_co_varch_ref PhantomProvProofIrrelProv PluginProv CorePrepProv MCoercionRMReflMCo KindCoercion CoercionP CoercionRFunSelSelMultSelArgSelResSelTyConSelFun SelForAllReflGRefl TyConAppCoAppCoForAllCoFunCoCoVarCo AxiomInstCo AxiomRuleCoUnivCoSymCoTransCoSelCoLRCoInstCoKindCoSubCoHoleCofco_rolefco_aflfco_afrfco_multfco_argfco_resKnotTiedNumTyLitStrTyLit CharTyLitTyVarTyAppTyTyConAppForAllTyFunTyLitTyCastTy CoercionTyft_afft_multft_argft_resFRRType LevityType KindOrTypenonDetCmpTyLitcmpTyLit mkTyVarTy mkTyVarTys mkTyCoVarTy mkTyCoVarTysmkFunTy mkInvisFunTy mkInvisFunTys tcMkVisFunTytcMkInvisFunTy mkVisFunTymkVisFunTyManymkVisFunTysManymkScaledFunTystcMkScaledFunTys mkForAllTysmkInvisForAllTysmkPiTymkPiTys coHoleCoVarsetCoHoleCoVarfoldTyConoViewtypeSize coercionSizeprovSize scaledMult mapScaledType$fOutputableTyLit$fOutputableFunSel $fNFDataCoSel $fBinaryCoSel$fOutputableCoSel$fUniquableCoercionHole$fOutputableCoercionHole$fDataCoercionHole$fOutputableUnivCoProvenance$fOutputableMCoercion$fOutputableCoercion$fOutputableType$fOutputableScaled $fDataScaled $fDataType$fDataCoercion$fDataUnivCoProvenance$fDataMCoercion $fEqCoSel $fDataCoSel $fEqFunSel $fDataFunSel $fEqTyLit $fDataTyLit primTyConsunexposedPrimTyConsexposedPrimTyConscharPrimTyConNameintPrimTyConNameint8PrimTyConNameint16PrimTyConNameint32PrimTyConNameint64PrimTyConNamewordPrimTyConNameword8PrimTyConNameword16PrimTyConNameword32PrimTyConNameword64PrimTyConNameaddrPrimTyConNamefloatPrimTyConNamedoublePrimTyConNamemkTemplateKindVarmkTemplateKindVarsmkTemplateTyVarsFrommkTemplateTyVarsmkTemplateTyConBindersmkTemplateKiTyVarsmkTemplateKiTyVarmkTemplateKindTyConBindersmkTemplateAnonTyConBinders alphaTyVars alphaTyVar betaTyVar gammaTyVar deltaTyVaralphaTyVarSpec betaTyVarSpecgammaTyVarSpecdeltaTyVarSpecalphaConstraintTyVaralphaConstraintTyalphaTysalphaTybetaTygammaTydeltaTyalphaTyVarsUnliftedRepalphaTyVarUnliftedRepalphaTysUnliftedRepalphaTyUnliftedRepruntimeRep1TyVarruntimeRep2TyVarruntimeRep3TyVarruntimeRep1TyVarInfruntimeRep2TyVarInf runtimeRep1Ty runtimeRep2Ty runtimeRep3TyopenAlphaTyVar openBetaTyVaropenGammaTyVaropenAlphaTyVarSpecopenBetaTyVarSpecopenGammaTyVarSpec openAlphaTy openBetaTy openGammaTy levity2TyVar levity1TyVarlevity1TyVarInflevity2TyVarInf levity1Ty levity2TylevPolyAlphaTyVarlevPolyBetaTyVarlevPolyAlphaTyVarSpeclevPolyBetaTyVarSpeclevPolyAlphaTy levPolyBetaTymultiplicityTyVar1multiplicityTyVar2funTyFlagTyCon isArrowTyCon fUNTyConNamectArrowTyConNameccArrowTyConNametcArrowTyConNamefUNTyCon ctArrowTyCon ccArrowTyCon tcArrowTyCon tYPETyCon tYPETyConNametYPEKindcONSTRAINTTyConcONSTRAINTTyConNamecONSTRAINTKind charPrimTy charPrimTyCon intPrimTy intPrimTyCon int8PrimTy int8PrimTyCon int16PrimTyint16PrimTyCon int32PrimTyint32PrimTyCon int64PrimTyint64PrimTyCon wordPrimTy wordPrimTyCon word8PrimTyword8PrimTyCon word16PrimTyword16PrimTyCon word32PrimTyword32PrimTyCon word64PrimTyword64PrimTyCon addrPrimTy addrPrimTyCon floatPrimTyfloatPrimTyCon doublePrimTydoublePrimTyCon mkStatePrimTystatePrimTyConrealWorldTyCon realWorldTyrealWorldStatePrimTy mkProxyPrimTyproxyPrimTyCon eqPrimTyConeqReprPrimTyConeqPhantPrimTyCon equalityTyConarrayPrimTyConmutableArrayPrimTyConmutableByteArrayPrimTyConbyteArrayPrimTyConsmallArrayPrimTyConsmallMutableArrayPrimTyCon mkArrayPrimTybyteArrayPrimTymkSmallArrayPrimTymkMutableArrayPrimTymkMutableByteArrayPrimTymkSmallMutableArrayPrimTymutVarPrimTyConmkMutVarPrimTyioPortPrimTyConmkIOPortPrimTy mVarPrimTyCon mkMVarPrimTy tVarPrimTyCon mkTVarPrimTystablePtrPrimTyConmkStablePtrPrimTystableNamePrimTyConmkStableNamePrimTycompactPrimTyCon compactPrimTystackSnapshotPrimTyConstackSnapshotPrimTy bcoPrimTy bcoPrimTyCon weakPrimTyCon mkWeakPrimTythreadIdPrimTythreadIdPrimTyConpromptTagPrimTyConmkPromptTagPrimTy int8X16PrimTyint8X16PrimTyCon int16X8PrimTyint16X8PrimTyCon int32X4PrimTyint32X4PrimTyCon int64X2PrimTyint64X2PrimTyCon int8X32PrimTyint8X32PrimTyConint16X16PrimTyint16X16PrimTyCon int32X8PrimTyint32X8PrimTyCon int64X4PrimTyint64X4PrimTyCon int8X64PrimTyint8X64PrimTyConint16X32PrimTyint16X32PrimTyConint32X16PrimTyint32X16PrimTyCon int64X8PrimTyint64X8PrimTyConword8X16PrimTyword8X16PrimTyConword16X8PrimTyword16X8PrimTyConword32X4PrimTyword32X4PrimTyConword64X2PrimTyword64X2PrimTyConword8X32PrimTyword8X32PrimTyConword16X16PrimTyword16X16PrimTyConword32X8PrimTyword32X8PrimTyConword64X4PrimTyword64X4PrimTyConword8X64PrimTyword8X64PrimTyConword16X32PrimTyword16X32PrimTyConword32X16PrimTyword32X16PrimTyConword64X8PrimTyword64X8PrimTyCon floatX4PrimTyfloatX4PrimTyCondoubleX2PrimTydoubleX2PrimTyCon floatX8PrimTyfloatX8PrimTyCondoubleX4PrimTydoubleX4PrimTyConfloatX16PrimTyfloatX16PrimTyCondoubleX8PrimTydoubleX8PrimTyCon runTyCoVarstyCoVarsOfTypetyCoVarsOfTypes tyCoVarsOfCo tyCoVarsOfMCo tyCoVarsOfCos deepTcvFoldershallowTyCoVarsOfTypeshallowTyCoVarsOfTypesshallowTyCoVarsOfCoshallowTyCoVarsOfCosshallowTyCoVarsOfTyVarEnvshallowTyCoVarsOfCoVarEnv coVarsOfType coVarsOfTypes coVarsOfCo coVarsOfCoscloseOverKindscloseOverKindsListcloseOverKindsDSettyCoVarsOfTypeDSettyCoVarsOfTypeListtyCoVarsOfTypesDSettyCoVarsOfTypesList tyCoFVsOfType tyCoFVsBndrtyCoFVsVarBndrstyCoFVsVarBndrtyCoFVsOfTypestyCoVarsOfCoDSettyCoVarsOfCoList tyCoFVsOfCo tyCoFVsOfCosalmostDevoidCoVarOfCo visVarsOfTypevisVarsOfTypesinjectiveVarsOfTypeinjectiveVarsOfTypesinvisibleVarsOfTypeinvisibleVarsOfTypesanyFreeVarsOfTypeanyFreeVarsOfTypesanyFreeVarsOfConoFreeVarsOfTypesnoFreeVarsOfCo scopedSorttyCoVarsOfTypeWellScopedtyCoVarsOfTypesWellScoped tyConsOfType tyConsOfTypesoccCheckExpand CvSubstEnv TvSubstEnv IdSubstEnvemptyIdSubstEnvemptyTvSubstEnvemptyCvSubstEnvcomposeTCvSubst emptySubst mkEmptySubst isEmptySubstisEmptyTCvSubstmkSubst mkIdSubst mkTvSubst mkCvSubst getIdSubstEnv getTvSubstEnv getCvSubstEnvgetSubstInScope setInScopegetSubstRangeTyCoFVs isInScope elemSubst notElemSubstzapSubstextendSubstInScopeextendSubstInScopeListextendSubstInScopeSetextendTCvSubstextendTCvSubstWithClone extendTvSubstextendTvSubstBinderAndInScopeextendTvSubstWithClone extendCvSubstextendCvSubstWithCloneextendTvSubstAndInScopeextendTvSubstListextendTCvSubstList unionSubst zipTvSubst zipCvSubst zipTCvSubst mkTvSubstPrszipTyEnvzipCoEnv substTyWithsubstTyWithUncheckedsubstTyWithInScope substCoWithsubstCoWithUncheckedsubstTyWithCoVars substTysWithsubstTysWithCoVarssubstTyAddInScopeisValidTCvSubstcheckValidSubstsubstTysubstTyUnchecked substScaledTysubstScaledTyUncheckedsubstTyssubstScaledTyssubstTysUncheckedsubstScaledTysUnchecked substThetasubstThetaUnchecked substTyVarsubstTyVarToTyVar substTyVars substTyCoVars lookupTyVarsubstCosubstCoUncheckedsubstCossubstForAllCoBndrsubstForAllCoBndrUsing substCoVar substCoVars lookupCoVarsubstTyVarBndrsubstTyVarBndrs substVarBndr substVarBndrssubstCoVarBndrsubstVarBndrUsingcloneTyVarBndrcloneTyVarBndrs substTyCoBndr$fOutputableSubst tidyVarBndrs tidyVarBndravoidNameClashestidyForAllTyBindertidyForAllTyBinderstidyFreeTyCoVarstidyOpenTyCoVarstidyOpenTyCoVartidyTyCoVarOcc tidyTypestidyType tidyOpenTypes tidyOpenType tidyTopTypetidyCotidyCos TyCoMapper tcm_tyvar tcm_covartcm_holetcm_tycobinder tcm_tyconManyTyOneTykindRep kindRep_maybeisUnliftedTypeKindpickyIsLiftedTypeKindkindBoxedRepLevity_maybeisLiftedRuntimeRepisUnliftedRuntimeRepisLiftedLevityisUnliftedLevityisRuntimeRepVar isLevityVarisMultiplicityVarsplitRuntimeRep_maybeisBoxedRuntimeRepruntimeRepLevity_maybelevityType_maybemapTyComapTyCoXgetTyVarrepGetTyVar_maybe isTyVarTygetCastedTyVar_maybemkAppTyssplitAppTy_maybe splitAppTysplitAppTyNoView_maybetcSplitAppTyNoView_maybe splitAppTyssplitAppTysNoView mkNumLitTy isNumLitTy mkStrLitTy isStrLitTy mkCharLitTy isCharLitTyisLitTyuserTypeError_maybepprUserTypeErrorTyfunTyConAppTy_maybetyConAppFunTy_maybetyConAppFunCo_maybemkFunctionTypemkScaledFunctionTys splitFunTysplitFunTy_maybe splitFunTys funResultTyfunArgTy piResultTys applyTysXtyConAppTyConPicky_maybe tyConAppTyContyConAppArgs_maybe tyConAppArgs splitTyConAppsplitTyConAppNoView_maybetcSplitTyConApp_maybetcSplitTyConAppnewTyConInstRhssplitCastTy_maybeisCoercionTy_maybestripCoercionTytyConBindersPiTyBindersmkTyCoInvForAllTy mkInfForAllTymkTyCoInvForAllTysmkInfForAllTysmkSpecForAllTymkSpecForAllTysmkVisForAllTysmkTyConBindersPreferAnonsplitForAllForAllTyBinderssplitForAllTyCoVarssplitForAllTyVarssplitForAllReqTyBinderssplitForAllInvisTyBinders isForAllTy isForAllTy_ty isForAllTy_coisPiTyisFunTysplitForAllTyCoVar dropForAllssplitForAllTyCoVar_maybesplitForAllTyVar_maybesplitForAllCoVar_maybesplitPiTy_maybe splitPiTy splitPiTysgetRuntimeArgTysinvisibleTyBndrCountsplitInvisPiTyssplitInvisPiTysNfilterOutInvisibleTypesfilterOutInferredTypespartitionInvisiblestyConForAllTyFlagsappTyForAllTyFlagsisTauTy isAtomicTymkFamilyTyConApp coAxNthLHS isFamFreeTy isCoVarType buildSynTyConisUnliftedTypemightBeLiftedTypemightBeUnliftedType isBoxedTypeisRuntimeRepKindedTydropRuntimeRepArgs getRuntimeRepisUnboxedTupleTypeisUnboxedSumType isAlgTypeisDataFamilyAppType isStrictTypeisPrimitiveTypeisValidJoinPointTypeseqTypeseqTypessORTKind_maybeisTYPEorCONSTRAINTtyConIsTYPEorCONSTRAINTisConstraintLikeKindisConstraintKindtcIsLiftedTypeKindtcIsBoxedTypeKindisTypeLikeKindreturnsConstraintKindtypeHasFixedRuntimeRepargsHaveFixedRuntimeRepisFixedRuntimeRepKind isConcretetyConAppNeedsKindSig unrestrictedlineartymultirrelevantMultmkScaled scaledSetisManyTyisOneTy isLinearType mkTYPEappmkTYPEapp_maybemkCONSTRAINTappmkCONSTRAINTapp_maybemkBoxedRepApp_maybemkTupleRepApp_maybetypeOrConstraintKind OverLitVal HsIntegral HsFractional HsIsString HsOverLitOverLitol_extol_valHsLitHsChar HsCharPrimHsString HsStringPrimHsInt HsIntPrim HsWordPrim HsInt64Prim HsWord64Prim HsIntegerHsRat HsFloatPrim HsDoublePrimXLitnegateOverLitVal $fEqHsLit$fOrdOverLitVal$fEqOverLitVal$fOrdHsOverLit $fEqHsOverLit$fDataOverLitValtcEqKindtcEqTypetcEqTypeNoKindCheck tcEqTyConApps tcEqTypeVis pickyEqType eqForAllVis cmpForAllViseqTypeeqTypeXeqTypes eqVarBndrs nonDetCmpTypenonDetCmpTypesnonDetCmpTypeXnonDetCmpTypesX nonDetCmpTc$fEqTypeOrdering$fOrdTypeOrdering$fEnumTypeOrdering$fBoundedTypeOrderingShowForAllFlagShowForAllMustShowForAllWhenPrintExplicitKinds UseBndrParensSuppressBndrSigIfaceUnivCoProvIfacePhantomProvIfaceProofIrrelProvIfacePluginProvIfaceCorePrepProv IfaceReflCo IfaceGReflCo IfaceFunCoIfaceTyConAppCo IfaceAppCo IfaceForAllCo IfaceCoVarCoIfaceAxiomInstCoIfaceAxiomRuleCo IfaceUnivCo IfaceSymCo IfaceTransCo IfaceSelCo IfaceLRCo IfaceInstCo IfaceKindCo IfaceSubCoIfaceFreeCoVar IfaceHoleCoIfaceMCoercion IfaceMReflIfaceMCoIfaceTyConInfoifaceTyConIsPromotedifaceTyConSortIfaceTyConSortIfaceNormalTyConIfaceTupleTyCon IfaceSumTyConIfaceEqualityTyConifaceTyConNameifaceTyConInfoIA_NilIA_ArgIfaceForAllSpecBndrIfaceForAllBndrIfaceTyConBinder IfaceNumTyLit IfaceStrTyLitIfaceCharTyLit IfaceContext IfacePredType IfaceMultIfaceFreeTyVar IfaceTyVar IfaceLitTy IfaceAppTy IfaceFunTy IfaceForAllTy IfaceTyConApp IfaceCastTyIfaceCoercionTy IfaceTupleTy IfaceKind IfaceOneShotIfaceNoOneShot IfaceLamBndr IfaceTvBndr IfaceIdBndr IfExtName IfLclName ifaceBndrNamemkIfaceForAllTvBndrmkIfaceTyConKindifaceForAllSpecToBndrsifaceForAllSpecToBndrmkIfaceTyConInfoisIfaceLiftedTypeKindsplitIfaceSigmaTysuppressIfaceInvisiblesstripIfaceInvisVarsifForAllBndrVarifForAllBndrNameifTyConBinderVarifTyConBinderNamemkIfaceTySubstinDomIfaceTySubstsubstIfaceAppArgssubstIfaceTyVarstripInvisArgsappArgsIfaceTypesappArgsIfaceTypesForAllTyFlagspprIfacePrefixAppisIfaceRhoType pprIfaceBndrspprIfaceLamBndrpprIfaceIdBndrpprIfaceTvBndrpprIfaceTyConBinders pprIfaceTypepprParendIfaceTypepprPrecIfaceType pprTypeArrowmany_typprIfaceAppArgspprParendIfaceAppArgspprIfaceForAllPartpprIfaceForAllPartMustpprIfaceForAllpprIfaceSigmaTypepprUserIfaceForAllpprIfaceTypeApp pprTyTcApppprIfaceCoTcApp pprIfaceTyLitpprIfaceCoercionpprParendIfaceCoercionpprIfaceContextArrpprIfaceContext$fNFDataIfaceOneShot$fBinaryIfaceOneShot$fOutputableIfaceOneShot$fNFDataIfaceTyLit$fBinaryIfaceTyLit$fOutputableIfaceTyLit$fNFDataIfaceTyConSort$fBinaryIfaceTyConSort$fOutputableIfaceTyConSort$fNFDataIfaceTyConInfo$fBinaryIfaceTyConInfo$fOutputableIfaceTyConInfo$fNFDataIfaceTyCon$fBinaryIfaceTyCon$fOutputableIfaceTyCon$fNFDataIfaceAppArgs$fNFDataIfaceBndr$fNFDataIfaceMCoercion$fNFDataIfaceUnivCoProv$fNFDataIfaceCoercion$fNFDataIfaceType$fBinaryDefMethSpec$fBinaryIfaceUnivCoProv$fBinaryIfaceCoercion$fBinaryIfaceMCoercion$fBinaryIfaceType$fBinaryIfaceAppArgs$fOutputableIfaceCoercion$fOutputableIfaceAppArgs$fOutputableIfaceType$fBinaryIfaceBndr$fMonoidIfaceAppArgs$fSemigroupIfaceAppArgs$fOutputableIfaceBndr$fEqIfaceTyCon$fEqIfaceTyConInfo$fEqIfaceTyConSort$fEqIfaceTyLitTickishPlacement PlaceRuntime PlaceNonLamPlaceCostCentreTickishScopingNoScope SoftScopeCostCentreScope GenTickishProfNoteHpcTick Breakpoint profNoteCC profNoteCount profNoteScope tickModuletickId breakpointExt breakpointId breakpointFVs sourceSpan sourceName CmmTickish StgTickish CoreTickish XTickishId tickishCounts tickishScopedtickishScopesLiketickishFloatabletickishCanSplit mkNoCount mkNoScope tickishIsCode isProfTick tickishPlacetickishContains$fOutputableTickishPlacement$fEqTickishPlacement$fShowTickishPlacement$fEqTickishScoping$fDataGenTickish$fOrdGenTickish$fEqGenTickish$fDataGenTickish0$fDataGenTickish1$fOrdGenTickish0$fEqGenTickish0 IsSubmultSubmultUnknown isMultMul mkMultAdd mkMultMul scaleScaled mkMultSupsubmultpprArrowWithMultiplicity$fOutputableIsSubmult$fShowIsSubmult $fEqIsSubmultUsageEnvUsageZeroBottomMUsageaddUsage scaleUsageunitUEzeroUEbottomUEaddUEscaleUEsupUEsupUEsdeleteUElookupUE$fOutputableUsage$fOutputableUsageEnv LitNumType LitNumBigNat LitNumInt LitNumInt8 LitNumInt16 LitNumInt32 LitNumInt64 LitNumWord LitNumWord8 LitNumWord16 LitNumWord32 LitNumWord64LiteralLitChar LitNumber LitString LitNullAddr LitRubbishLitFloat LitDoubleLitLabellitNumIsSigned litNumBitSizemkLitNumberWrap litNumWrap litNumCoerce litNumNarrowlitNumCheckRange litNumRange mkLitNumbermkLitInt mkLitIntWrapmkLitIntUnchecked mkLitIntWrapC mkLitWord mkLitWordWrapmkLitWordUncheckedmkLitWordWrapC mkLitInt8 mkLitInt8WrapmkLitInt8Unchecked mkLitWord8mkLitWord8WrapmkLitWord8Unchecked mkLitInt16mkLitInt16WrapmkLitInt16Unchecked mkLitWord16mkLitWord16WrapmkLitWord16Unchecked mkLitInt32mkLitInt32WrapmkLitInt32Unchecked mkLitWord32mkLitWord32WrapmkLitWord32Unchecked mkLitInt64mkLitInt64WrapmkLitInt64Unchecked mkLitWord64mkLitWord64WrapmkLitWord64Unchecked mkLitFloat mkLitDouble mkLitChar mkLitString mkLitBigNat isLitRubbish isMinBound isMaxBound inCharRange isZeroLitisOneLitlitValueisLitValue_maybe mapLitValue narrowInt8LitnarrowInt16LitnarrowInt32LitnarrowInt64LitnarrowWord8LitnarrowWord16LitnarrowWord32LitnarrowWord64LitconvertToWordLitconvertToIntLit charToIntLit intToCharLit floatToIntLit intToFloatLitdoubleToIntLitintToDoubleLitfloatToDoubleLitdoubleToFloatLit nullAddrLit litIsTrivial litIsDupable litFitsInChar litIsLifted literalType pprLiteral$fBinaryLitNumType $fOrdLiteral $fEqLiteral$fOutputableLiteral$fBinaryLiteral $fDataLiteral$fDataLitNumType$fEnumLitNumType$fEqLitNumType$fOrdLitNumTypeGenMap LiteralMapListMapMaybeMapTrieMapKeyemptyTMlookupTMalterTMfilterTMfoldTMXTinsertTMdeleteTM foldMapTM isEmptyTM>.>|>|>> foldMaybe filterMaybelkListxtListlkGxtGmapGfdG$fTrieMapUniqDFM $fTrieMapMap$fTrieMapIntMap$fFoldableMaybeMap$fTrieMapMaybeMap$fFunctorMaybeMap$fOutputableListMap$fFoldableListMap$fTrieMapListMap$fFunctorListMap$fFoldableGenMap$fTrieMapGenMap$fFunctorGenMap$fOutputableGenMapFactBaseLabelMapLabelSetLabel mkHooplLabel lookupFact$fOutputablePenvLabel$fOutputableLabel$fUniquableLabel $fShowLabel$fOutputableLabelSet$fIsSetLabelSet$fTrieMapLabelMap$fOutputablePenvLabelMap$fOutputableLabelMap$fIsMapLabelMap $fEqLabelMap $fOrdLabelMap$fShowLabelMap$fFunctorLabelMap$fFoldableLabelMap$fTraversableLabelMap $fEqLabelSet $fOrdLabelSet$fShowLabelSet$fMonoidLabelSet$fSemigroupLabelSet $fEqLabel $fOrdLabelBlockId mkBlockIdGraph'GNilGUnitGManyNonLocal entryLabel successorsBody emptyBodybodyListbodyToBlockListaddBlockmapGraphmapGraphBlocks labelsDefinedrevPostorderFrom$fNonLocalBlock DTyConEnvTyConEnvnonDetTyConEnvElts emptyTyConEnvisEmptyTyConEnv unitTyConEnvextendTyConEnvextendTyConEnvListlookupTyConEnv alterTyConEnv mkTyConEnvmkTyConEnvWith elemTyConEnv plusTyConEnvplusTyConEnv_CplusTyConEnv_CDplusTyConEnv_CD2extendTyConEnv_C mapTyConEnvextendTyConEnv_AccextendTyConEnvList_CdelFromTyConEnvdelListFromTyConEnvfilterTyConEnv anyTyConEnvdisjointTyConEnvlookupTyConEnv_NFemptyDTyConEnvisEmptyDTyConEnvlookupDTyConEnvdelFromDTyConEnvfilterDTyConEnv mapDTyConEnvmapMaybeDTyConEnvadjustDTyConEnvalterDTyConEnvextendDTyConEnv foldDTyConEnv RecTcChecker initRecTcdefaultRecTcMaxBoundsetRecTcMaxBound checkRecTc$fOutputableRecTcCheckerRoughMapRoughMatchLookupTc RML_KnownTc RML_NoKnownTc RML_WildCard RoughMatchTc RM_KnownTc RM_WildCardinstanceCantMatchroughMatchTcToLookupisRoughWildcard roughMatchTcsroughMatchTcsLookuptypeToRoughMatchLookupTctypeToRoughMatchTcemptyRMlookupRM lookupRM'unionRMinsertRMfilterRMfilterMatchingRMelemsRMfoldRMsizeRM$fOutputableRoughMatchTc$fOutputableRoughMatchLookupTc$fOutputableRoughMap$fFunctorRoughMap$fDataRoughMatchLookupTc$fDataRoughMatchTc pprParendType pprTidiedType pprPrecType pprPrecTypeX pprParendKind pprParendCo pprClassPredpprThetapprParendThetapprThetaArrowTy pprSigmaType pprForAll pprUserForAll pprTCvBndrs pprTCvBndr pprTyVars pprDataCons pprTypeApppprWithExplicitKindsWhen pprWithTYPEpprSourceTyCon LiftCoEnvLCNormaliseStepResultNS_DoneNS_AbortNS_StepNormaliseStepper coVarNamesetCoVarUnique setCoVarNameetaExpandCoAxBranch pprCoAxiompprCoAxBranchUserpprCoAxBranchLHS pprCoAxBranchtidyCoAxBndrsForUsercoToMCocheckReflexiveMCo isGReflMCo mkTransMCo mkTransMCoL mkTransMCoRmkSymMCo mkCastTyMComkHomoForAllMComkPiMCos mkFunResMComkGReflLeftMComkGReflRightMComkCoherenceRightMCo isReflMCo decomposeCodecomposeFunCogetCoVar_maybemultToCosplitAppCo_maybesplitFunCo_maybesplitForAllCo_maybesplitForAllCo_ty_maybesplitForAllCo_co_maybe coVarLType coVarRType coVarTypes coVarKindmkRuntimeRepCoisReflCoVar_maybeisGReflCo_maybeisReflCo_maybeisReflexiveCo_maybe mkRepReflCo mkFunCoNoFTF mkNakedFunCo2mkAppCos mkForAllCosmkHomoForAllCos mkCoVarCos mkAxInstComkUnbranchedAxInstCo mkAxInstRHSmkUnbranchedAxInstRHS mkAxInstLHSmkUnbranchedAxInstLHSmkHoleCo getNthFunmkGReflRightCo mkGReflLeftComkCoherenceLeftComkCoherenceRightCo downgradeRolesetNominalRole_maybe tyConRolesXtyConRoleListXtyConRolesRepresentationaltyConRoleListRepresentational tyConRolefunRoleltRolepromoteCoercioncastCoercionKind2castCoercionKind1castCoercionKindmkPiCosmkPiCo mkFunResComkCoCastinstNewTyCon_maybecomposeSteppersunwrapNewTypeSteppertopNormaliseTypeX eqCoercion eqCoercionXliftCoSubstWithExliftCoSubstWithemptyLiftingContextmkSubstLiftingContextextendLiftingContextextendLiftingContextAndInScopezapLiftingContextsubstForAllCoBndrUsingLCliftCoSubstTyVarliftCoSubstVarBndrUsing isMappedByLC substLeftCo substRightCo swapLiftCoEnv lcSubstLeft lcSubstRightliftEnvSubstLeftliftEnvSubstRightlcSubst lcInScopeSet coercionKindscoercionKindRolegetNthFromType coercionRole mkPrimEqPredmkPrimEqPredRolemkHeteroPrimEqPredmkHeteroReprPrimEqPredmkReprPrimEqPred buildCoercionhasCoercionHoleTyhasCoercionHoleCohasThisCoercionHoleTy setCoHoleType$fOutputableNormaliseStepResult$fOutputableLiftingContext$fFunctorNormaliseStepResult StarIsType StarIsNotTypeUntickedPromotedThingUntickedConstructorUntickedExplicitList SimilarNameSimilarRdrName HowInScopeLocallyBoundAtImportSuggestionCouldImportFromCouldUnhideFromInstantiationSuggestionGhcHint UnknownHintSuggestExtensionSuggestCorrectPragmaNameSuggestMissingDoSuggestLetInDoSuggestAddSignatureCabalFileSuggestSignatureInstantiationsSuggestUseSpacesSuggestUseWhitespaceAfterSuggestUseWhitespaceAroundSuggestParenthesesSuggestIncreaseMaxPmCheckModelsSuggestAddTypeSignaturesSuggestBindToWildcard SuggestAddInlineOrNoInlinePragmaSuggestAddPhaseToCompetingRuleSuggestAddToHSigExportList#SuggestIncreaseSimplifierIterationsSuggestUseTypeFromDataKindSuggestQualifiedAfterModuleNameSuggestThQuotationSyntax SuggestRolesSuggestQualifyStarOperatorSuggestTypeSignatureFormSuggestFixOrphanInstanceSuggestAddStandaloneDerivationSuggestFillInWildcardConstraintSuggestRenameForallSuggestAppropriateTHTickSuggestDumpSlicesSuggestAddTickSuggestMoveToDeclarationSiteSuggestSimilarNamesRemindFieldSelectorSuppressedSuggestImportingDataConSuggestPlacePragmaInHeaderSuggestPatternMatchingSyntax SuggestSpecialiseVisibilityHintsLoopySuperclassSolveHintsuppressed_selectorsuppressed_parentsLanguageExtensionHintSuggestSingleExtensionSuggestAnyExtensionSuggestExtensionsSuggestExtensionInOrderToAvailableBindings NamedBindingsUnnamedBindingsuggestExtensionsuggestExtensionWithInfosuggestExtensionssuggestExtensionsWithInfosuggestAnyExtensionsuggestAnyExtensionWithInfouseExtensionInOrderTopprUntickedConstructor isBareSymbolnoStarIsTypeHintsDiagnosticCodediagnosticCodeNameSpacediagnosticCodeNumberSeverity SevIgnore SevWarningSevError MessageClassMCOutputMCFatal MCInteractiveMCDumpMCInfo MCDiagnostic MsgEnvelope errMsgSpan errMsgContexterrMsgDiagnosticerrMsgSeverityDiagnosticReasonWarningWithoutFlagWarningWithFlagErrorWithoutFlagDiagnosticMessage diagMessage diagReason diagHintsDiagnosticHintNoDiagnosticOptsUnknownDiagnostic DiagnosticDiagnosticOptsdefaultDiagnosticOptsdiagnosticMessagediagnosticReasondiagnosticHintsdiagnosticCode DecoratedSDoc unDecoratedMessages getMessages emptyMessages mkMessagesisEmptyMessages singleMessage addMessage unionMessagesunionManyMessages mkDecoratedmkSimpleDecoratedunionDecoratedSDocmapDecoratedSDocnoHintsmkPlainDiagnostic mkPlainErrormkDecoratedDiagnosticmkDecoratedError pprMessageBag mkLocMessagemkLocMessageWarningGroupsgetCaretDiagnosticisIntrinsicErrorMessageisWarningMessage errorsFoundisExtrinsicErrorMessageerrorsOrFatalWarningsFoundgetWarningMessagesgetErrorMessagespartitionMessages$fOutputableDiagnosticHint$fOutputableDiagnosticReason$fToJsonSeverity$fOutputableSeverity$fShowMsgEnvelope$fOutputableDiagnosticCode$fToJsonMessageClass$fDiagnosticDiagnosticMessage$fOutputableMessages$fDiagnosticUnknownDiagnostic$fSemigroupMessages$fMonoidMessages$fFunctorMessages$fFoldableMessages$fTraversableMessages$fFunctorMsgEnvelope$fFoldableMsgEnvelope$fTraversableMsgEnvelope $fEqSeverity$fShowSeverity$fEqDiagnosticReason$fShowDiagnosticReasonContainsLogger extractLogger HasLogger getLoggerLoggerlogFlags DumpFormat FormatHaskell FormatCore FormatSTGFormatByteCode FormatCMM FormatASMFormatC FormatLLVMFormatJS FormatText TraceAction DumpAction LogActionLogFlagslog_default_user_contextlog_default_dump_contextlog_dump_flagslog_show_caretlog_show_warn_groupslog_enable_timestampslog_dump_to_file log_dump_dirlog_dump_prefixlog_dump_prefix_override log_with_wayslog_enable_debug log_verbositylog_waysdefaultLogFlagslog_dopt log_set_doptlogHasDumpFlaglogVerbAtLeastupdateLogFlags setLogFlagsloggerTraceFlushUpdateloggerTraceFlush initLogger putLogMsg putDumpFile putTraceMsg pushLogHook popLogHook pushDumpHook popDumpHook pushTraceHook popTraceHookmakeThreadSafe jsonLogActiondefaultLogActiondefaultLogActionHPrintDocdefaultLogActionHPutStrDocdefaultDumpActionwithDumpFileHandledefaultTraceActionlogMsg logDumpFile logTraceMsg logDumpMsgputDumpFileMaybeputDumpFileMaybe' touchDumpFile$fShowDumpFormat$fEqDumpFormatValidity Validity'IsValidNotValidDiagOptsdiag_warning_flagsdiag_fatal_warning_flagsdiag_warn_is_errordiag_reverse_errorsdiag_max_errors diag_ppr_ctx diag_woptdiag_fatal_woptdiagReasonSeveritymkMCDiagnosticerrorDiagnostic mkMsgEnvelopemkErrorMsgEnvelopemkPlainMsgEnvelopemkPlainErrorMsgEnvelopeandValidallValid getInvalidsformatBulleted pprMessagespprMsgEnvelopeBagWithLocpprMsgEnvelopeBagWithLocDefaultpprLocMsgEnvelopeDefaultpprLocMsgEnvelope sortMsgBagghcExiterrorMsg fatalErrorMsgcompilationProgressMsgshowPass withTimingwithTimingSilent debugTraceMsgputMsgprintInfoForUserprintOutputForUserlogInfo logOutputprettyPrintGhcErrorstraceCmdtraceSystoolCommand$fEqPrintTimings$fShowPrintTimings$fFunctorValidity'TempDirTempFileLifetimeTFL_CurrentModuleTFL_GhcSession PathsToClean ptcGhcSessionptcCurrentModuleTmpFsemptyPathsToClean initTmpFs forkTmpFsFrommergeTmpFsInto cleanTempDirscleanTempFileskeepCurrentModuleTempFilescleanCurrentModuleTempFilesaddFilesToCleanchangeTempFilesLifetime newTempName newTempSubDirnewTempLibNamewithSystemTempDirectorywithTempDirectory$fShowTempFileLifetimePipelineOutput Temporary Persistent SpecificFile NoOutputFilePipeEnv stop_phase src_filename src_basename src_suffix start_phase output_specMonadUseuseTPipelineClass$fShowPipelineOutputDefunctionalizedCDefsNoCDefs LlvmCDefsDefunctionalizedPostHscPipelineNcgPostHscPipelineViaCPostHscPipelineLlvmPostHscPipelineJSPostHscPipelineNoPostHscPipelineDefunctionalizedCodeOutput NcgCodeOutputViaCCodeOutputLlvmCodeOutput JSCodeOutput#DefunctionalizedAssemblerInfoGetterStandardAssemblerInfoGetterJSAssemblerInfoGetterDarwinClangAssemblerInfoGetterDefunctionalizedAssemblerProgStandardAssemblerProgJSAssemblerProgDarwinClangAssemblerProgPrimitiveImplementationLlvmPrimitives NcgPrimitives JSPrimitivesGenericPrimitivesBackendplatformDefaultBackendplatformNcgSupported ncgBackend llvmBackend jsBackend viaCBackendinterpreterBackend noBackendbackendDescriptionbackendWritesFilesbackendPipelineOutputbackendCanReuseLoadedCodebackendGeneratesCodebackendGeneratesCodeForHsBootbackendSupportsInterfaceWritingbackendRespectsSpecialisebackendWantsGlobalBindingsbackendHasNativeSwitchbackendPrimitiveImplementationbackendSimdValiditybackendSupportsEmbeddedBlobsbackendNeedsPlatformNcgSupport backendSupportsUnsplitProcPointsbackendSwappableWithViaCbackendUnregisterisedAbiOnlybackendGeneratesHcbackendSptIsDynamicbackendWantsBreakpointTicksbackendForcesOptimization0backendNeedsFullWaysbackendSpecialModuleSourcebackendSupportsHpcbackendSupportsCImportbackendSupportsCExportbackendAssemblerProgbackendAssemblerInfoGetter backendCDefsbackendCodeOutputbackendUseJSLinkerbackendPostHscPipelinebackendNormalSuccessorPhase backendName allBackendsbackendValidityOfCImportbackendValidityOfCExport $fShowBackend$fShowPrimitiveImplementation SwitchPlanUnconditionallyIfEqualIfLT JumpTable SwitchTargetsmkSwitchTargetsmapSwitchTargetsswitchTargetsCasesswitchTargetsDefaultswitchTargetsRangeswitchTargetsSignedswitchTargetsToTableswitchTargetsToListswitchTargetsFallThrougheqSwitchTargetWithcreateSwitchPlan$fShowSwitchPlan$fShowSwitchTargets$fEqSwitchTargetsStgToCmmConfigstgToCmmProfilestgToCmmThisModulestgToCmmTmpDirstgToCmmContextstgToCmmEmitDebugInfostgToCmmBinBlobThreshstgToCmmMaxInlAllocSizestgToCmmDoTickystgToCmmTickyAllocdstgToCmmTickyLNEstgToCmmTickyDynThunkstgToCmmTickyTagstgToCmmLoopificationstgToCmmAlignCheckstgToCmmOptHpcstgToCmmFastPAPCallsstgToCmmSCCProfilingstgToCmmEagerBlackHolestgToCmmInfoTableMap stgToCmmInfoTableMapWithFallbackstgToCmmInfoTableMapWithStackstgToCmmOmitYieldsstgToCmmOmitIfPragmas stgToCmmPIC stgToCmmPIEstgToCmmExtDynRefsstgToCmmDoBoundsCheckstgToCmmDoTagCheckstgToCmmAllowBigArithstgToCmmAllowQuotRemInstrstgToCmmAllowQuotRem2!stgToCmmAllowExtendedAddSubInstrsstgToCmmAllowIntMul2InstrstgToCmmTickyAPstgToCmmVecInstrsErr stgToCmmAvx stgToCmmAvx2stgToCmmAvx512fstgToCmmPlatformEwMWarn warnReasonwarnMsgErrerrMsg WarnReasonNoReasonReasonDeprecatedFlagReasonUnrecognisedFlagOptKindNoArgHasArgSepArg OptPrefix OptIntSuffix IntSuffix WordSuffix FloatSuffixPassFlag AnySuffix GhcFlagModeOnlyGhcOnlyGhciAllModes HiddenFlagFlagflagName flagOptKind flagGhcModedefFlag defGhcFlag defGhciFlag defHiddenFlag hoistFlagrunEwMaddErraddWarn addFlagWarngetArg getCurLocliftEwM processArgsparseResponseFileerrorsToGhcException$fToJsonWarnReason$fOutputableWarnReason $fMonadIOEwM $fMonadEwM$fApplicativeEwM $fFunctorEwM$fEqWarnReason$fShowWarnReasonTickPreInlineUnconditionallyPostInlineUnconditionally UnfoldingDone RuleFiredLetFloatFromLet EtaExpansion EtaReduction BetaReduction CaseOfCase KnownBranch CaseMergeAltMergeCaseElim CaseIdentityFillInCaseDefaultSimplifierDone SimplCount simplCountNzeroSimplCountisZeroSimplCounthasDetailedCountsdoFreeSimplTick doSimplTickplusSimplCount pprSimplCount $fOrdTick$fEqTick$fOutputableTickVarMapBndrMapDeBruijnDCmEnv LooseTypeMapTypeMapTypeMapG CoercionMapGeqDeBruijnType eqDeBruijnVar foldTypeMap emptyTypeMap lookupTypeMap extendTypeMaplookupTypeMapWithScopeextendTypeMapWithScopemkDeBruijnContextemptyCME extendCME extendCMEs lookupCME deBruijnizelkBndrxtBndrlkVarxtVar lkDFreeVar xtDFreeVarlkDNamedxtDNamed$fTrieMapTyLitMap$fFunctorTyLitMap $fEqDeBruijn $fEqDeBruijn0 $fEqDeBruijn1 $fEqDeBruijn2 $fEqDeBruijn3$fTrieMapVarMap$fFunctorVarMap$fTrieMapBndrMap$fFunctorBndrMap$fTrieMapTypeMapX$fFunctorTypeMapX$fTrieMapLooseTypeMap$fFunctorLooseTypeMap$fTrieMapTypeMap$fFunctorTypeMap$fTrieMapCoercionMapX$fFunctorCoercionMapX$fTrieMapCoercionMap$fFunctorCoercionMapBindFlagBindMeApartMaybeApartReason MARTypeFamily MARInfiniteMARTypeVsConstraint UnifyResultM Unifiable MaybeApart SurelyApart UnifyResultBindFun tcMatchTy tcMatchTyX_BM tcMatchTyKi tcMatchTyX tcMatchTys tcMatchTyKis tcMatchTysX tcMatchTyKisXruleMatchTyKiX matchBindFun alwaysBindFuntypesCantMatch typesAreApart tcUnifyTy tcUnifyTyKitcUnifyTyWithTFs tcUnifyTys tcUnifyTyKis tcUnifyTysFG liftCoMatch flattenTys flattenTysX$fSemigroupMaybeApartReason$fOutputableMaybeApartReason$fOutputableUnifyResultM$fMonadUnifyResultM$fApplicativeUnifyResultM $fMonadFailUM $fMonadUM$fApplicativeUM $fFunctorUM $fEqBindFlag$fFunctorUnifyResultMEqRelNomEqReprEqPred ClassPredEqPred IrredPred ForAllPredclassifyPredType mkClassPredisDictTytypeDeterminesValuegetClassPredTysgetClassPredTys_maybe classMethodTyclassMethodInstTy eqRelRole getEqPredTysgetEqPredTys_maybe getEqPredRole predTypeEqRel isEvVarType isEqPredClass isClassPredisEqPred isEqPrimPred isCTupleClass isIPTyCon isIPClass isIPLikePredhasIPSuperClassesisCallStackPredTyisCallStackPred isCallStackTyisIPPred_maybeisEvVarisDictId$fOutputableEqRel $fEqEqRel $fOrdEqRelStrictnessMark MarkedStrictNotMarkedStrict HsImplBangHsLazyHsStrictHsUnpack HsSrcBang DataConEnv NoDataConRepDCR dcr_wrap_id dcr_boxer dcr_arg_tys dcr_stricts dcr_bangsmkEqSpec eqSpecTyVar eqSpecType eqSpecPair eqSpecPredseqHsBangisBanged isSrcStrict isSrcUnpackedisMarkedStrictcbvFromStrictMark mkDataCon dataConTag dataConTagZdataConOrigTyCondataConRepTypedataConIsInfixdataConUnivTyVarsdataConUnivAndExTyCoVars dataConThetadataConWrapId_maybedataConImplicitTyThingsdataConFieldTypedataConFieldType_maybedataConSrcBangsdataConRepArityisNullarySrcDataConisNullaryRepDataCondataConRepStrictnessdataConImplBangs dataConBoxerdataConInstSigdataConOrigResTydataConWrapperTypedataConNonlinearTypedataConDisplayTypedataConInstArgTysdataConInstUnivsdataConOrigArgTysdataConOtherThetadataConRepArgTysdataConIdentityisTupleDataConisBoxedTupleDataConisUnboxedTupleDataConisVanillaDataCon isNewDataConisCovertGadtDataConspecialPromotedDc classDataCondataConCannotMatchdataConResRepTyArgscheckDataConTyVarsdataConUserTyVarsNeedWrappersplitDataProductType_maybe$fBinarySrcUnpackedness$fBinarySrcStrictness$fOutputableSrcUnpackedness$fOutputableSrcStrictness$fOutputableHsSrcBang$fOutputableHsImplBang$fBinaryStrictnessMark$fOutputableStrictnessMark$fOutputableEqSpec $fDataDataCon$fOutputableBndrDataCon$fOutputableDataCon$fNamedThingDataCon$fUniquableDataCon $fEqDataCon$fEqStrictnessMark$fDataHsImplBang$fDataHsSrcBangAmbiguousFieldOcc Unambiguous AmbiguousXAmbiguousFieldOccLAmbiguousFieldOccFieldOcc XFieldOccfoExtfoLabel LFieldOcc LHsTypeArgHsArgHsValArg HsTypeArgHsArgPar HsConDetails PrefixConRecConInfixCon ConDeclField cd_fld_ext cd_fld_names cd_fld_type cd_fld_doc LConDeclField HsTupleSortHsUnboxedTupleHsBoxedOrConstraintTupleHsScaledHsLinearArrowTokensHsPct1HsLollyHsArrowHsUnrestrictedArrow HsLinearArrowHsExplicitMultHsTyLitHsNumTyHsStrTyHsCharTyHsType HsForAllTyHsQualTyHsTyVarHsAppTy HsAppKindTyHsFunTyHsListTy HsTupleTyHsSumTyHsOpTyHsParTy HsIParamTyHsStarTy HsKindSig HsSpliceTyHsDocTyHsBangTyHsRecTyHsExplicitListTyHsExplicitTupleTy HsWildCardTyXHsType hst_xforallhst_telehst_body hst_xqualhst_ctxt HsTyVarBndr UserTyVar KindedTyVar XTyVarBndrHsIPName HsSigTypeHsSig XHsSigTypesig_ext sig_bndrssig_body LHsSigWcType LHsWcType LHsSigType HsPatSigTypeHsPS XHsPatSigTypehsps_ext hsps_bodyHsWildCardBndrsHsWCXHsWildCardBndrshswc_ext hswc_bodyHsOuterFamEqnTyVarBndrsHsOuterSigTyVarBndrsHsOuterTyVarBndrsHsOuterImplicitHsOuterExplicitXHsOuterTyVarBndrs hso_ximplicit hso_xexplicit hso_bndrs LHsQTyVarsHsQTvs XLHsQTyVarshsq_ext hsq_explicit LHsTyVarBndrHsForAllTelescope HsForAllVis HsForAllInvisXHsForAllTelescopehsf_xvis hsf_vis_bndrs hsf_xinvishsf_invis_bndrsLHsKindHsKindLHsType HsContext LHsContextBangType LBangType hsQTvExplicit hsPatSigTypemapHsOuterImplicit hsIPNameFSisHsKindedTyVarhsMult hsScaledThing noTypeArgs$fDataHsConDetails$fDataHsTupleSort $fEqHsIPName$fDataHsIPName$fEqPromotionFlag$fDataPromotionFlag $fEqFieldOcc HsFieldBindhfbAnnhfbLHShfbRHShfbPun HsRecUpdField HsRecFieldLHsRecUpdField LHsRecField LHsFieldBindRecFieldsDotDotunRecFieldsDotDot HsRecFieldsrec_flds rec_dotdotHsConPatDetails HsConPatTyArgConLikePWildPatVarPatLazyPatAsPatParPatBangPatListPatTuplePatSumPatConPatViewPat SplicePatLitPatNPat NPlusKPatSigPatXPat pat_con_extpat_conpat_args hsConPatArgs hsRecFieldshsRecFieldsArgs hsRecFieldSel$fFunctorHsFieldBind$fFoldableHsFieldBind$fTraversableHsFieldBind$fDataRecFieldsDotDot$fEqRecFieldsDotDot$fOrdRecFieldsDotDotpprLPat HsPatSynDirUnidirectionalImplicitBidirectionalExplicitBidirectionalRecordPatSynFieldrecordPatSynFieldrecordPatSynPatVarHsPatSynDetails FixitySig LFixitySigSigTypeSig PatSynSig ClassOpSigFixSig InlineSigSpecSig SpecInstSig MinimalSig SCCFunSigCompleteMatchSigXSigLSigIPBindXIPBindLIPBind HsIPBindsIPBinds PatSynBindPSBpsb_extpsb_idpsb_argspsb_defpsb_dirHsBindLRFunBindPatBindVarBind XHsBindsLRfun_extfun_id fun_matchespat_extpat_lhspat_rhsvar_extvar_idvar_rhs LHsBindLR LHsBindsLRHsBindLHsBindsLHsBind HsValBindsLRValBinds XValBindsLR HsValBindsLHsLocalBindsLRHsLocalBindsLREmptyLocalBindsXHsLocalBindsLR LHsLocalBinds HsLocalBinds isFixityLSig isTypeLSig isSpecLSigisSpecInstLSig isPragLSig isInlineLSig isMinimalLSig isSCCFunSigisCompleteMatchSig RoleAnnotDeclXRoleAnnotDeclLRoleAnnotDecl AnnProvenanceValueAnnProvenanceTypeAnnProvenanceModuleAnnProvenance HsAnnotationXAnnDeclLAnnDeclWarnDeclWarning XWarnDecl LWarnDecl WarnDecls XWarnDeclswd_ext wd_warnings LWarnDeclsDocDeclDocCommentNextDocCommentPrevDocCommentNamedDocGroupLDocDeclRuleBndr RuleBndrSig XRuleBndr LRuleBndrRuleDeclHsRule XRuleDeclrd_extrd_namerd_actrd_tyvsrd_tmvsrd_lhsrd_rhs LRuleDecl RuleDeclsHsRules XRuleDeclsrds_ext rds_rules LRuleDecls ForeignExportCExport CImportSpec CFunctionCWrapper ForeignImportCImport ForeignDecl XForeignDeclfd_i_extfd_name fd_sig_tyfd_fifd_e_extfd_fe LForeignDecl DefaultDecl XDefaultDecl LDefaultDecl DerivStrategy StockStrategyAnyclassStrategyNewtypeStrategy ViaStrategyLDerivStrategy DerivDecl XDerivDecl deriv_ext deriv_typederiv_strategyderiv_overlap_mode LDerivDeclInstDeclClsInstD DataFamInstD TyFamInstD XInstDecl cid_d_extcid_instdfid_ext dfid_insttfid_ext tfid_inst LInstDecl ClsInstDecl XClsInstDeclcid_ext cid_poly_ty cid_bindscid_sigscid_tyfam_instscid_datafam_instscid_overlap_mode LClsInstDeclFamEqnXFamEqnfeqn_ext feqn_tycon feqn_bndrs feqn_pats feqn_fixityfeqn_rhsDataFamInstDecldfid_eqnLDataFamInstDecl TyFamInstDeclXTyFamInstDecltfid_xtntfid_eqnLTyFamInstDeclLTyFamDefltDeclTyFamDefltDecl TyFamInstEqnHsTyPats LTyFamInstEqnHsConDeclGADTDetails PrefixConGADT RecConGADTHsConDeclH98DetailsConDecl ConDeclGADT ConDeclH98XConDecl con_g_ext con_names con_dcolon con_bndrs con_mb_cxt con_g_args con_res_tycon_doccon_extcon_name con_forall con_ex_tvscon_argsLConDecl DataDefnCons NewTypeCon DataTypeCons NewOrDataNewTypeDataTypeStandaloneKindSigLStandaloneKindSigDerivClauseTys DctSingleDctMultiXDerivClauseTysLDerivClauseTysHsDerivingClauseXHsDerivingClausederiv_clause_extderiv_clause_strategyderiv_clause_tysLHsDerivingClause HsDeriving HsDataDefn XHsDataDefndd_extdd_ctxtdd_cType dd_kindSigdd_cons dd_derivs FamilyInfo DataFamilyOpenTypeFamilyClosedTypeFamilyInjectivityAnnXInjectivityAnnLInjectivityAnn FamilyDecl XFamilyDeclfdExtfdInfo fdTopLevelfdLNamefdTyVarsfdFixity fdResultSigfdInjectivityAnn LFamilyDeclFamilyResultSigNoSigKindSigTyVarSigXFamilyResultSigLFamilyResultSig TyClGroup XTyClGroup group_ext group_tyclds group_roles group_kisigs group_instds LHsFunDepXFunDepTyClDeclFamDeclSynDeclDataDecl ClassDecl XTyClDecltcdFExttcdFamtcdSExttcdLName tcdTyVars tcdFixitytcdRhstcdDExt tcdDataDefntcdCExt tcdLayouttcdCtxttcdFDstcdSigstcdMethstcdATs tcdATDefstcdDocs LTyClDeclSpliceDecoration DollarSplice BareSplice SpliceDecl LSpliceDeclHsGroupXHsGrouphs_exths_valds hs_splcds hs_tyclds hs_derivdshs_fixdshs_defdshs_fords hs_warndshs_annds hs_ruledshs_docsHsDeclTyClDInstDDerivDValDSigDKindSigDDefDForDWarningDAnnDRuleDSpliceDDocD RoleAnnotDXHsDeclLHsDeclhsGroupInstDecls isDataDecl isSynDecl isClassDecl isFamilyDeclisTypeFamilyDeclisOpenTypeFamilyInfoisClosedTypeFamilyInfoisDataFamilyDecltyClDeclTyVarstyClGroupTyClDeclstyClGroupInstDeclstyClGroupRoleDeclstyClGroupKindSigsdataDefnConsNewOrDataisTypeDataDefnConscollectRuleBndrSigTys docDeclDocannProvenanceName_maybe$fDataCImportSpec$fEqDataDefnCons$fDataDataDefnCons$fFoldableDataDefnCons$fFunctorDataDefnCons$fTraversableDataDefnCons $fEqNewOrData$fDataNewOrData$fDataSpliceDecoration$fEqSpliceDecoration$fShowSpliceDecoration $fDataDocDecl HsDoFlavourDoExprMDoExpr GhciStmtCtxtListComp MonadCompHsArrowMatchContextProcExpr ArrowCaseAltArrowLamCaseAlt KappaExpr HsStmtContextHsDoStmtPatGuard ParStmtCtxt TransStmtCtxt ArrowExprHsMatchContextFunRhs LambdaExprCaseAlt LamCaseAltIfAltArrowMatchCtxt PatBindRhs PatBindGuardsRecUpdStmtCtxt ThPatSplice ThPatQuotePatSynmc_fun mc_fixity mc_strictness ArithSeqInfoFromFromThenFromTo FromThenToHsQuoteExpBrPatBrDecBrLDecBrGTypBrVarBrXQuoteHsUntypedSpliceExpr HsQuasiQuoteApplicativeArgApplicativeArgOneApplicativeArgManyXApplicativeArgxarg_app_arg_oneapp_arg_patternarg_expr is_body_stmtxarg_app_arg_many app_stmts final_expr bv_pattern stmt_context FailOperator ParStmtBlock TransFormThenForm GroupFormStmtLRLastStmtBindStmtApplicativeStmtBodyStmtLetStmtParStmt TransStmtRecStmtXStmtLRtrS_exttrS_form trS_stmts trS_bndrs trS_usingtrS_bytrS_rettrS_bindtrS_fmaprecS_ext recS_stmtsrecS_later_ids recS_rec_ids recS_bind_fn recS_ret_fn recS_mfix_fnGhciStmt GhciLStmt GuardStmt GuardLStmtExprStmt ExprLStmtCmdStmtCmdLStmtStmtLStmtLRLStmtGRHSXGRHSLGRHSXGRHSsgrhssExt grhssGRHSsgrhssLocalBindsMatchXMatchm_extm_ctxtm_patsm_grhssLMatchMG XMatchGroupmg_extmg_alts HsRecordBindsHsCmdTop LHsCmdTop HsArrAppTypeHsHigherOrderAppHsFirstOrderAppHsCmd HsCmdArrApp HsCmdArrFormHsCmdAppHsCmdLamHsCmdPar HsCmdCase HsCmdLamCaseHsCmdIfHsCmdLetHsCmdDoXCmdLHsCmdLamCaseVariantLamCaseLamCasesHsTupArgPresentMissingXTupArg LHsTupArgHsPragE HsPragSCCXHsPragE DotFieldOcc XDotFieldOccdfoExtdfoLabelHsVar HsUnboundVarHsRecSel HsOverLabelHsIPVarHsLam HsLamCaseHsApp HsAppTypeOpAppNegAppHsParSectionLSectionR ExplicitTuple ExplicitSumHsCaseHsIf HsMultiIfHsLetHsDo ExplicitList RecordCon RecordUpd HsGetField HsProjection ExprWithTySigArithSeqHsTypedBracketHsUntypedBracket HsTypedSpliceHsProcHsStaticXExprrcon_extrcon_con rcon_fldsrupd_ext rupd_expr rupd_fldsgf_extgf_exprgf_fieldproj_ext proj_flds LHsRecUpdProj RecUpdProj LHsRecProjRecProjFieldLabelStringsLFieldLabelStrings isInfixMatch isPatSynCtxtqualifiedDoModuleName_maybeisComprehensionContextisDoComprehensionContextisMonadStmtContextisMonadDoStmtContextisMonadCompContextisMonadDoCompContext$fDataTransForm$fDataHsArrAppType$fDataLamCaseVariant$fEqLamCaseVariantHsUntypedSpliceResultHsUntypedSpliceTopHsUntypedSpliceNestedutsplice_result_finalizersutsplice_resultThModFinalizersSplicePointName pprFunBind pprPatBindpprUntypedSplicepprTypedSplicepprExprpprLExprHsModuleXModulehsmodExt hsmodName hsmodExports hsmodImports hsmodDecls TypeShapeTsFunTsProdTsUnkDmdTransformerDmdSigDmdTypedt_envdt_argsDmdEnvDEde_fvsde_div DivergenceDivergesExnOrDivDunno SubDemandPolyProdDemandBotDmdAbsDmd CardNonOnce CardNonAbsCard:*C_0NC_1NC_01C_11C_10C_00isStrictisAbs isUsedOnce oneifyCardlubCardplusCardmultCard topSubDmdmkProdviewProdtopDmdabsDmdbotDmdseqDmdunboxDeeplyDmdmultDmd multSubDmdlubDmd lubSubDmdplusDmd plusSubDmdisTopDmdisAbsDmd isStrictDmd isStrUsedDmd isUsedOnceDmd isWeakDmdevalDmdstrictOnceApply1DmdstrictManyApply1Dmd lazyApply1Dmd lazyApply2Dmd oneifyDmd strictifyDmdstrictifyDictDmd lazifyDmdmkCalledOnceDmdmkCalledOnceDmds peelCallDmd peelManyCallssubDemandIfEvaluatedmkWorkerDemand argsOneShots argOneShotssaturatedByOneShots lubDivergencetopDivexnDivbotDiv isDeadEndDiv mkTermDmdEnv nopDmdEnv addVarDmdEnv plusDmdEnv plusDmdEnvsreuseEnv lubDmdTypediscardArgDmds plusDmdType botDmdType nopDmdType dmdTypeDepth splitDmdTy multDmdTypepeelFV addDemand findIdDemanddeferAfterPreciseExceptionmkDmdSigForAritymkClosedDmdSigmkVanillaDmdSig splitDmdSig dmdSigDmdEnvhasDemandEnvSigbotSignopSigisNopSig isDeadEndSigisBottomingSigonlyBoxedArgumentsisDeadEndAppSigtrimBoxityDmdSigtransferArgBoxityDmdSigprependArgsDmdSigetaConvertDmdSigdmdTransformSigdmdTransformDataConSigdmdTransformDictSelSig zapDmdEnvSigzapUsageDemandzapUsedOnceDemandzapUsedOnceSig trimToType trimBoxity seqDemand seqDemandList seqDmdType seqDmdSig $fBinaryCard$fOutputableCard $fShowCard$fBinarySubDemand$fBinaryDemand$fOutputableSubDemand$fOutputableDemand $fEqSubDemand$fBinaryDivergence$fOutputableDivergence$fBinaryDmdEnv$fOutputableDmdEnv $fEqDmdEnv$fBinaryDmdType$fOutputableDmdType $fEqDmdType$fBinaryDmdSig$fOutputableDmdSig$fOutputableTypeShape $fEqDmdSig$fEqDivergence $fEqDemand$fEqCardSlotTy PtrLiftedSlotPtrUnliftedSlotWordSlot Word64Slot FloatSlot DoubleSlotVecSlot UnaryType NvUnaryType isNvUnaryTypetypePrimRepArgs unwrapTypecountFunRepArgscountConRepArgsdataConRuntimeRepStrictness isZeroBitTy ubxSumRepType layoutUbxSum typeSlotTy primRepSlot slotPrimRep typePrimReptypePrimRep_maybe typePrimRep1 tyConPrimRep tyConPrimRep1kindPrimRep_mayberuntimeRepPrimRepruntimeRepPrimRep_maybeprimRepToRuntimeRep primRepToType mightBeFunTy$fOutputableSlotTy $fEqSlotTy $fOrdSlotTyCprSig getCprSigUnpackConFieldsResult AllFieldsSame ForeachFieldCprTypect_artyct_cprCprConCprtopCprbotCpr flatConCprasConCpr topCprType botCprTypeflatConCprType lubCprType applyCprTy abstractCprTy trimCprTyunpackConFieldsCprmkCprSigForArity topCprSig isTopCprSigmkCprSig seqCprSigprependArgsCprSig $fBinaryCpr$fOutputableCpr$fBinaryCprType$fOutputableCprType $fEqCprType$fOutputableCprSig $fEqCprSig$fBinaryCprSig$fEqCprAnnBind AnnNonRecAnnAltAnnExpr'AnnVarAnnLitAnnAppAnnCastAnnTick AnnCoercionAnnExpr TaggedAlt TaggedArg TaggedExpr TaggedBind TaggedBndrTBCoreAltCoreBindCoreArg CoreProgramUnfoldingGuidanceUnfWhen UnfIfGoodArgsUnfNeverug_arity ug_unsat_ok ug_boring_okug_argsug_sizeug_resUnfoldingCache uf_is_value uf_is_conlikeuf_is_work_free uf_expandable Unfolding NoUnfolding BootUnfoldingOtherCon DFunUnfolding CoreUnfoldingdf_bndrsdf_condf_argsuf_tmpluf_src uf_is_topuf_cache uf_guidanceIdUnfoldingFun InScopeEnvISERuleFunCoreRuleRule BuiltinRuleru_nameru_actru_fnru_roughru_bndrsru_argsru_rhsru_auto ru_origin ru_orphanru_localru_nargsru_tryIsOrphan NotOrphan MOutCoercionOutArgOutAltOutExprOutBind OutCoercionOutKindOutTypeOutBndr InCoercionInArgInAltInExprInBindInKindInTypeInBndrBindNonRecRecAltConDataAltLitAltDEFAULTAltArgLitAppLamLetCaseCastisOrphan notOrphanchooseOrphanAnchor isBuiltinRule isAutoRule ruleArityruleName ruleModuleruleActivation ruleIdName isLocalRule setRuleIdName needSaturated unSaturatedOk boringCxtOkboringCxtNotOk noUnfoldingevaldUnfolding bootUnfolding mkOtherConunfoldingTemplatemaybeUnfoldingTemplate otherConsisValueUnfoldingisEvaldUnfoldingisConLikeUnfoldingisCheapUnfoldingisExpandableUnfoldingexpandUnfolding_maybeisCompulsoryUnfoldingisStableUnfoldingisStableUserUnfoldingisStableSystemUnfoldingisInlineUnfoldinghasSomeUnfoldingisBootUnfoldingneverUnfoldGuidancehasCoreUnfolding canUnfoldcmpAltltAlt cmpAltCon deTagExprmkAppsmkCoApps mkVarAppsmkConAppmkTyApps mkConApp2mkTyArgmkIntLit mkIntLitWrap mkWordLit mkWordLitWrap mkWord8LitmkWord64LitWord64mkInt64LitInt64 mkCharLit mkStringLit mkFloatLitmkFloatLitFloat mkDoubleLitmkDoubleLitDoublemkLamsmkLetsmkLet mkLetNonRecmkLetRecmkTyBindmkCoBind varToCoreExprvarsToCoreExprs exprToType bindersOfbindersOfBindsfoldBindersOfBindStrictfoldBindersOfBindsStrict rhssOfBind rhssOfAlts flattenBindscollectBinderscollectTyBinderscollectTyAndValBinderscollectNBinderscollectNValBinders_maybe collectArgscollectFunSimple wrapLamBody stripNArgscollectArgsTicks isRuntimeVar isRuntimeArgisValArg isTyCoArgisCoArg isTypeArg valBndrCount valArgCountcollectAnnArgscollectAnnArgsTicks deAnnotate deAnnotate'deAnnAlt deAnnBindcollectAnnBndrscollectNAnnBndrs$fOutputableAltCon $fOrdAltCon$fBinaryIsOrphan$fOutputableTaggedBndr$fEqUnfoldingGuidance$fEqUnfoldingCache$fDataIsOrphan $fDataBind $fDataExpr $fDataAlt $fEqAltCon $fDataAltCon SimpleOpts simpleOptExpr so_uf_optseqDeBruijnExpr eqCoreExpr lookupCoreMap extendCoreMap foldCoreMap emptyCoreMap$fTrieMapAltMap$fFunctorAltMap$fTrieMapCoreMapX$fFunctorCoreMapX$fOutputableCoreMap$fTrieMapCoreMap$fFunctorCoreMapArgsReductions Reductions ReductionR ReductionN HetReduction ReductionreductionCoercionreductionReducedTypemkHetReductionhomogeniseHetRedn mkReductionreductionOriginalType coercionRedn downgradeRedn mkSubRedn mkTransRedn mkReflRednmkGReflRightRednmkGReflRightMRednmkGReflLeftRednmkGReflLeftMRednmkCoherenceRightRednmkCoherenceRightMRedn mkCastRedn1 mkCastRedn2 mkAppRedn mkFunRedn mkForAllRednmkHomoForAllRednmkProofIrrelRedn mkReflCoRedn mkReductions mkAppRednsmkTyConAppRednmkClassPredRedn unzipRednssimplifyArgsWorker$fOutputableReduction PatSynBuilder PatSynMatchermkPatSyn patSynName patSynIsInfix patSynArityisVanillaPatSyn patSynArgspatSynFieldLabelspatSynFieldTypepatSynUnivTyVarBinderspatSynExTyVarspatSynExTyVarBinders patSynSigBndr patSynSig patSynMatcher patSynBuilderpatSynResultTypepatSynInstArgTyspatSynInstResTy pprPatSynType $fDataPatSyn$fOutputableBndrPatSyn$fOutputablePatSyn$fNamedThingPatSyn$fUniquablePatSyn $fEqPatSyn RealDataCon PatSynConisVanillaConLike conLikeArityconLikeFieldLabelsconLikeInstOrigArgTysconLikeUserTyVarBindersconLikeExTyCoVars conLikeNameconLikeStupidThetaconLikeHasBuilderconLikeImplBangs conLikeResTyconLikeFullSigconLikeFieldTypeconLikesWithFieldsconLikeIsInfix $fDataConLike$fOutputableBndrConLike$fOutputableConLike$fNamedThingConLike$fUniquableConLike $fEqConLikeCompleteMatches CompleteMatch cmConLikes cmResultTyConvanillaCompleteMatchcompleteMatchAppliesAtType$fOutputableCompleteMatchArgDescrArgSpecArgGen ArgUnknownLivenessConstrDescriptionClosureTypeInfoConstrFunThunk ThunkSelector BlackHole IndStaticIsStaticSMRepHeapRep ArrayPtrsRepSmallArrayPtrsRep ArrayWordsRepStackRepRTSRep StgHalfWordStgWordWordOffByteOffroundUpToWords roundUpTo wordsToBytesbytesToWordsRoundUp fromStgWord toStgWordfromStgHalfWord toStgHalfWord halfWordSizehalfWordSizeInBits mkHeapRepmkRTSRep mkStackRep blackHoleRep indStaticRep arrPtrsRepsmallArrPtrsRep arrWordsRep isStaticRep isStackRepisConRep isThunkRepisFunRepisStaticNoCafCon fixedHdrSize fixedHdrSizeW profHdrSizearrWordsHdrSizearrWordsHdrSizeWarrPtrsHdrSizearrPtrsHdrSizeWsmallArrPtrsHdrSizesmallArrPtrsHdrSizeW thunkHdrSizehdrSizehdrSizeW nonHdrSize nonHdrSizeWheapClosureSizeWcard cardRoundUpcardTableSizeBcardTableSizeWrtsClosureType rET_SMALLrET_BIGaRG_GEN aRG_GEN_BIG$fOutputableStgWord$fOutputableStgHalfWord$fOutputableArgDescr$fOutputableClosureTypeInfo$fOutputableSMRep $fEqSMRep $fOrdSMRep$fEqClosureTypeInfo$fOrdClosureTypeInfo $fEqArgDescr $fOrdArgDescr$fEqStgHalfWord $fEqStgWord $fBitsStgWord DoExtDynRefsDoSCCProfilingStandardFormInfoNonStandardThunk SelectorThunkApThunkLambdaFormInfo LFReEntrantLFThunkLFCon LFUnknown LFUnlifted LFLetNoEscape ModuleLFInfos CmmCgInfos cgNonCafs cgLFInfos cgIPEStub$fOutputableStandardFormInfo$fOutputableLambdaFormInfo$fEqStandardFormInfo TickBoxOpTickBox TickBoxIdCafInfoMayHaveCafRefs NoCafRefsRuleInfoInlinePragInfo ArityInforuleInforealUnfoldingInfoinlinePragInfooccInfo dmdSigInfo cprSigInfo demandInfolfInfotagSig RecSelParent RecSelData RecSelPatSyn VanillaIdRecSelId DataConWorkId DataConWrapId ClassOpIdPrimOpIdFCallId TickBoxOpIdCoVarId WorkerLikeId sel_tycon sel_naughtyisJoinIdDetails_maybe oneShotInfo arityInfocafInfo callArityInfo tagSigInfo setRuleInfosetInlinePragInfo setOccInfo unfoldingInfosetUnfoldingInfohasInlineUnfolding setArityInfosetCallArityInfo setCafInfo setLFInfo setTagSigsetOneShotInfo setDemandInfo setDmdSigInfo setCprSigInfo noCafIdInfo unknownArity ppArityInfo pprStrictness emptyRuleInfoisEmptyRuleInforuleInfoFreeVars ruleInfoRulessetRuleInfoHeadmayHaveCafRefs ppCafInfo zapLamInfo zapDemandInfo zapUsageInfozapUsageEnvInfozapUsedOnceInfozapFragileInfo trimUnfoldingzapTailCallInfozapCallArityInfo$fOutputableRecSelParent$fOutputableCafInfo$fOutputableTickBoxOp$fOutputableIdDetails $fEqCafInfo $fOrdCafInfo$fEqRecSelParentidUniqueidTypeidMult idScaledType scaleIdBy scaleVarBy setIdName setIdUnique setIdType localiseId setIdInfo modifyIdInfomaybeModifyIdInfo mkGlobalIdmkVanillaGlobalmkVanillaGlobalWithInfo mkLocalId mkLocalCoVarmkLocalIdOrCoVarmkLocalIdWithInfomkExportedLocalIdmkExportedVanillaId mkSysLocalmkSysLocalOrCoVar mkSysLocalMmkSysLocalOrCoVarM mkUserLocalmkUserLocalOrCoVar mkWorkerIdmkTemplateLocalmkScaledTemplateLocalmkTemplateLocalsmkTemplateLocalsNumrecordSelectorTyConrecordSelectorTyCon_maybeisRecordSelectorisDataConRecordSelectorisPatSynRecordSelectorisNaughtyRecordSelector isClassOpIdisClassOpId_maybe isPrimOpIdisDFunIdisPrimOpId_maybe isFCallIdisFCallId_maybeisDataConWorkIdisDataConWorkId_maybeisDataConWrapIdisDataConWrapId_maybeisDataConId_maybeisWorkerLikeIdisJoinIdisJoinId_maybe idDataCon hasNoBinding isImplicitIdidIsFrom isDeadBinder idJoinArityasJoinId zapJoinIdasJoinId_maybeidArity setIdArity idCallAritysetIdCallArity idFunRepArity isDeadEndIdidDmdSig setIdDmdSigidCprSig setIdCprSig zapIdDmdSig isStrictIdidTagSig_maybe idUnfoldingnoUnfoldingFunalwaysActiveUnfoldingFunwhenActiveUnfoldingFunrealIdUnfoldingsetIdUnfolding idDemandInfosetIdDemandInfo setIdTagSig setIdCbvMarksidCbvMarks_maybeidCbvMarkArityasNonWorkerLikeIdasWorkerLikeIdsetCaseBndrEvaldzapIdUnfoldingidSpecialisation idCoreRules idHasRulessetIdSpecialisation idCafInfo setIdCafInfoidLFInfo_maybe setIdLFInfo idOccInfo setIdOccInfo zapIdOccInfoidInlinePragmasetInlinePragmamodifyInlinePragmaidInlineActivationsetInlineActivationidRuleMatchInfo isConLikeId idOneShotInfosetOneShotLambdaclearOneShotLambdasetIdOneShotInfoupdOneShotInfo zapLamIdInfozapFragileIdInfozapIdDemandInfozapIdUsageInfozapIdUsageEnvInfozapIdUsedOnceInfozapIdTailCallInfozapStableUnfoldingtransferPolyIdInfo MonadThings lookupThinglookupId lookupDataCon lookupTyConAnIdAConLikeATyConACoAxiompprShortTyThingpprTyThingCategorytyThingCategoryimplicitTyThingsimplicitConLikeThingsimplicitClassThingsimplicitTyConThingsimplicitCoTyConisImplicitTyThingtyThingParent_maybetyThingsTyCoVarstyThingAvailInfo tyThingTyContyThingCoAxiomtyThingDataContyThingConLike tyThingId$fNamedThingTyThing$fOutputableTyThing$fMonadThingsReaderT BoxingInfoBI_NoBoxNeededBI_NoBoxAvailableBI_Box bi_data_con bi_inst_con bi_boxed_type wiredInTyConsmkWiredInTyConNamemkWiredInIdName eqTyConName eqTyCon_RDR heqTyConNamecoercibleTyConName charTyConName intTyConName boolTyConName listTyConNamenilDataConNameconsDataConNamemaybeTyConNamenothingDataConNamejustDataConName wordTyConNamefloatTyConNamedoubleTyConNameanyTyConanyTymakeRecoveryTyCon boolTyCon_RDR false_RDRtrue_RDR intTyCon_RDR charTyCon_RDRstringTyCon_RDRintDataCon_RDR listTyCon_RDRconsDataCon_RDRtypeSymbolKindConisBuiltInOcc_maybeisPunOcc_maybe mkTupleStr cTupleTyConcTupleTyConNamesisCTupleTyConNamecTupleTyConNameArity_maybecTupleDataConNames cTupleSelIdmkPromotedPairTyisPromotedPairType unitTyCon unitTyConKey unitDataCon unitDataConId soloTyCon pairTyCon unboxedUnitTyunboxedUnitTyConunboxedUnitDataConunboxedSumKindeqTyConeqClass eqDataConheqClass heqDataConcoercibleClasscoercibleDataConmultiplicityTyConNameoneDataConNamemanyDataConName oneDataCon manyDataConunrestrictedFunTyConNameconstraintKindTyContypeToTypeKindunliftedTypeKindTyConNameunliftedDataConTyConsumRepDataConTyConliftedRepTyConNameunliftedRepTyConName charTyCon charDataConstringTyintTyintTyCon intDataConwordTy wordTyCon wordDataConword8Ty word8TyCon word8DataConfloatTy floatTyCon floatDataCondoubleTy doubleTyCon doubleDataCon boxingDataConboolTy boolTyCon falseDataCon trueDataConfalseDataConId trueDataConId orderingTyCon ordLTDataCon ordEQDataCon ordGTDataConordLTDataConIdordEQDataConIdordGTDataConIdmkListTy nilDataCon consDataCon maybeTyConnothingDataCon justDataConmkPromotedMaybeTy mkMaybeTyisPromotedMaybeTy mkTupleTy mkTupleTy1mkConstraintTupleTymkSumTypromotedTrueDataConpromotedFalseDataConpromotedNothingDataConpromotedJustDataConpromotedLTDataConpromotedEQDataConpromotedGTDataConpromotedConsDataConpromotedNilDataConmkPromotedListTyintegerTyConNameintegerISDataConNameintegerIPDataConNameintegerINDataConName integerTyConintegerISDataConintegerIPDataConintegerINDataConnaturalTyConNamenaturalNSDataConNamenaturalNBDataConName naturalTyConnaturalNSDataConnaturalNBDataCon filterCTuple OrigNameCache NameCache nsUniqCharnsNamestakeUniqFromNameCachelookupOrigNameCacheextendOrigNameCache'extendOrigNameCache initNameCacheupdateNameCache'updateNameCache CoreStatsCScs_tmcs_tycs_cocs_vbcs_jbcoreBindsStats exprStats coreBindsSizeexprSize$fOutputableCoreStatsHistoryhistoryApStackhistoryBreakInfohistoryEnclosingDeclsResumeBindingsResume resumeStmt resumeContextresumeBindingsresumeFinalIds resumeApStackresumeBreakInfo resumeSpan resumeDecl resumeCCS resumeHistoryresumeHistoryIxIcGlobalRdrEnvigre_envigre_prompt_env ExecResult ExecComplete ExecBreak execResultexecAllocation breakNames breakInfo SingleStepRunToCompletionRunAndLogSteps ExecOptionsexecSingleStepexecSourceFileexecLineNumberexecWrapisSteppprCoreBindingspprCoreBindingpprCoreBindingsWithSizepprCoreBindingWithSize pprParendExpr pprCoreExprpprOptCo pprCoreAltpprOccpprOccWithTick pprCoreBinderpprCoreBinderspprIdpprIdspprRulespprRule$fOutputableGenTickish$fOutputableCoreRule$fOutputableUnfoldingCache$fOutputableUnfolding$fOutputableUnfoldingGuidance$fOutputableIdInfo$fOutputableBndrTaggedBndr$fOutputableBndrVar$fOutputableAlt$fOutputableExpr$fOutputableBindCoreAltWithFVsCoreExprWithFVs'CoreExprWithFVsCoreBindWithFVsFVAnn exprFreeVarsexprFVsexprFreeVarsDSetexprFreeVarsList exprFreeIds exprsFreeIdsexprFreeIdsDSetexprFreeIdsListexprsFreeIdsDSetexprsFreeIdsList exprsFreeVarsexprsFreeVarsList bindFreeVarsexprSomeFreeVarsexprSomeFreeVarsListexprsSomeFreeVarsexprsSomeFreeVarsListexprsOrphNamesorphNamesOfTypeorphNamesOfTypes orphNamesOfCoorphNamesOfCoConorphNamesOfAxiomLHSruleRhsFreeVarsrulesRhsFreeIdsruleLhsFreeIdsruleLhsFreeIdsList ruleFreeVarsrulesFreeVarsDSet rulesFreeVars mkRuleInfo freeVarsOf freeVarsOfAnnvarTypeTyCoVarsvarTypeTyCoFVs idFreeVars dIdFreeVarsidFVsbndrRuleAndUnfoldingVarsDSetbndrRuleAndUnfoldingIds idRuleVarsidUnfoldingVarsstableUnfoldingVars freeVarsBindfreeVars FamInstMatch fim_instancefim_tysfim_cosInjectivityCheckResultInjectivityAcceptedInjectivityUnified FamInstEnv FamInstEnvs FamFlavor SynFamilyInstDataFamilyInstFamInstfi_axiom fi_flavorfi_famfi_tcsfi_tvsfi_cvsfi_tysfi_rhs famInstAxiom famInstRHS famInstTyConfamInstsRepTyConsfamInstRepTyCon_maybedataFamInstRepTyConorphNamesOfFamInst pprFamInst pprFamInstsmkImportedFamInstfamInstEnvSizeemptyFamInstEnvsemptyFamInstEnvfamInstEnvEltsfamilyInstancesfamilyNameInstancesunionFamInstEnvextendFamInstEnvListextendFamInstEnvcompatibleBranchesinjectiveBranches mkCoAxBranchmkBranchedCoAxiommkUnbranchedCoAxiommkSingleCoAxiommkNewTypeCoAxiomlookupFamInstEnvByTyConlookupFamInstEnvlookupFamInstEnvConflicts$lookupFamInstEnvInjectivityConflicts isDominatedByreduceTyFamApp_maybeapartnessChecktopNormaliseTypetopNormaliseType_maybetopReduceTyFamApp_maybe normaliseTypenormaliseTcApp$fOutputableFamInst$fNamedThingFamInst$fOutputableFamInstEnv$fOutputableFamInstMatch$fApplicativeNormM $fMonadNormM$fFunctorNormMTypeEnv emptyTypeEnv typeEnvElts typeEnvTyConstypeEnvCoAxioms typeEnvIdstypeEnvPatSynstypeEnvDataConstypeEnvClasses mkTypeEnvmkTypeEnvWithImplicitstypeEnvFromEntities lookupTypeEnv extendTypeEnvextendTypeEnvListextendTypeEnvWithIds plusTypeEnvPrimCallPrimOpResultInfo ReturnsPrim ReturnsAlg PrimOpVecCatIntVecWordVecFloatVecCharGtOpCharGeOpCharEqOpCharNeOpCharLtOpCharLeOpOrdOp Int8ToIntOp IntToInt8Op Int8NegOp Int8AddOp Int8SubOp Int8MulOp Int8QuotOp Int8RemOp Int8QuotRemOp Int8SllOp Int8SraOp Int8SrlOp Int8ToWord8OpInt8EqOpInt8GeOpInt8GtOpInt8LeOpInt8LtOpInt8NeOp Word8ToWordOp WordToWord8Op Word8AddOp Word8SubOp Word8MulOp Word8QuotOp Word8RemOpWord8QuotRemOp Word8AndOp Word8OrOp Word8XorOp Word8NotOp Word8SllOp Word8SrlOp Word8ToInt8Op Word8EqOp Word8GeOp Word8GtOp Word8LeOp Word8LtOp Word8NeOp Int16ToIntOp IntToInt16Op Int16NegOp Int16AddOp Int16SubOp Int16MulOp Int16QuotOp Int16RemOpInt16QuotRemOp Int16SllOp Int16SraOp Int16SrlOpInt16ToWord16Op Int16EqOp Int16GeOp Int16GtOp Int16LeOp Int16LtOp Int16NeOpWord16ToWordOpWordToWord16Op Word16AddOp Word16SubOp Word16MulOp Word16QuotOp Word16RemOpWord16QuotRemOp Word16AndOp Word16OrOp Word16XorOp Word16NotOp Word16SllOp Word16SrlOpWord16ToInt16Op Word16EqOp Word16GeOp Word16GtOp Word16LeOp Word16LtOp Word16NeOp Int32ToIntOp IntToInt32Op Int32NegOp Int32AddOp Int32SubOp Int32MulOp Int32QuotOp Int32RemOpInt32QuotRemOp Int32SllOp Int32SraOp Int32SrlOpInt32ToWord32Op Int32EqOp Int32GeOp Int32GtOp Int32LeOp Int32LtOp Int32NeOpWord32ToWordOpWordToWord32Op Word32AddOp Word32SubOp Word32MulOp Word32QuotOp Word32RemOpWord32QuotRemOp Word32AndOp Word32OrOp Word32XorOp Word32NotOp Word32SllOp Word32SrlOpWord32ToInt32Op Word32EqOp Word32GeOp Word32GtOp Word32LeOp Word32LtOp Word32NeOp Int64ToIntOp IntToInt64Op Int64NegOp Int64AddOp Int64SubOp Int64MulOp Int64QuotOp Int64RemOp Int64SllOp Int64SraOp Int64SrlOpInt64ToWord64Op Int64EqOp Int64GeOp Int64GtOp Int64LeOp Int64LtOp Int64NeOpWord64ToWordOpWordToWord64Op Word64AddOp Word64SubOp Word64MulOp Word64QuotOp Word64RemOp Word64AndOp Word64OrOp Word64XorOp Word64NotOp Word64SllOp Word64SrlOpWord64ToInt64Op Word64EqOp Word64GeOp Word64GtOp Word64LeOp Word64LtOp Word64NeOpIntAddOpIntSubOpIntMulOp IntMul2OpIntMulMayOfloOp IntQuotOpIntRemOp IntQuotRemOpIntAndOpIntOrOpIntXorOpIntNotOpIntNegOp IntAddCOp IntSubCOpIntGtOpIntGeOpIntEqOpIntNeOpIntLtOpIntLeOpChrOp IntToWordOp IntToFloatOp IntToDoubleOp WordToFloatOpWordToDoubleOpIntSllOpIntSraOpIntSrlOp WordAddOp WordAddCOp WordSubCOp WordAdd2Op WordSubOp WordMulOp WordMul2Op WordQuotOp WordRemOp WordQuotRemOpWordQuotRem2Op WordAndOpWordOrOp WordXorOp WordNotOp WordSllOp WordSrlOp WordToIntOpWordGtOpWordGeOpWordEqOpWordNeOpWordLtOpWordLeOp PopCnt8Op PopCnt16Op PopCnt32Op PopCnt64OpPopCntOpPdep8OpPdep16OpPdep32OpPdep64OpPdepOpPext8OpPext16OpPext32OpPext64OpPextOpClz8OpClz16OpClz32OpClz64OpClzOpCtz8OpCtz16OpCtz32OpCtz64OpCtzOp BSwap16Op BSwap32Op BSwap64OpBSwapOpBRev8OpBRev16OpBRev32OpBRev64OpBRevOp Narrow8IntOp Narrow16IntOp Narrow32IntOp Narrow8WordOpNarrow16WordOpNarrow32WordOp DoubleGtOp DoubleGeOp DoubleEqOp DoubleNeOp DoubleLtOp DoubleLeOp DoubleAddOp DoubleSubOp DoubleMulOp DoubleDivOp DoubleNegOp DoubleFabsOp DoubleToIntOpDoubleToFloatOp DoubleExpOp DoubleExpM1Op DoubleLogOp DoubleLog1POp DoubleSqrtOp DoubleSinOp DoubleCosOp DoubleTanOp DoubleAsinOp DoubleAcosOp DoubleAtanOp DoubleSinhOp DoubleCoshOp DoubleTanhOp DoubleAsinhOp DoubleAcoshOp DoubleAtanhOp DoublePowerOpDoubleDecode_2IntOpDoubleDecode_Int64Op FloatGtOp FloatGeOp FloatEqOp FloatNeOp FloatLtOp FloatLeOp FloatAddOp FloatSubOp FloatMulOp FloatDivOp FloatNegOp FloatFabsOp FloatToIntOp FloatExpOp FloatExpM1Op FloatLogOp FloatLog1POp FloatSqrtOp FloatSinOp FloatCosOp FloatTanOp FloatAsinOp FloatAcosOp FloatAtanOp FloatSinhOp FloatCoshOp FloatTanhOp FloatAsinhOp FloatAcoshOp FloatAtanhOp FloatPowerOpFloatToDoubleOpFloatDecode_IntOp NewArrayOp ReadArrayOp WriteArrayOp SizeofArrayOpSizeofMutableArrayOp IndexArrayOpUnsafeFreezeArrayOpUnsafeThawArrayOp CopyArrayOpCopyMutableArrayOp CloneArrayOpCloneMutableArrayOp FreezeArrayOp ThawArrayOp CasArrayOpNewSmallArrayOpShrinkSmallMutableArrayOp_CharReadSmallArrayOpWriteSmallArrayOpSizeofSmallArrayOpSizeofSmallMutableArrayOpGetSizeofSmallMutableArrayOpIndexSmallArrayOpUnsafeFreezeSmallArrayOpUnsafeThawSmallArrayOpCopySmallArrayOpCopySmallMutableArrayOpCloneSmallArrayOpCloneSmallMutableArrayOpFreezeSmallArrayOpThawSmallArrayOpCasSmallArrayOpNewByteArrayOp_CharNewPinnedByteArrayOp_Char NewAlignedPinnedByteArrayOp_CharMutableByteArrayIsPinnedOpByteArrayIsPinnedOpByteArrayContents_CharMutableByteArrayContents_CharShrinkMutableByteArrayOp_CharResizeMutableByteArrayOp_CharUnsafeFreezeByteArrayOpSizeofByteArrayOpSizeofMutableByteArrayOpGetSizeofMutableByteArrayOpIndexByteArrayOp_CharIndexByteArrayOp_WideCharIndexByteArrayOp_IntIndexByteArrayOp_WordIndexByteArrayOp_AddrIndexByteArrayOp_FloatIndexByteArrayOp_DoubleIndexByteArrayOp_StablePtrIndexByteArrayOp_Int8IndexByteArrayOp_Int16IndexByteArrayOp_Int32IndexByteArrayOp_Int64IndexByteArrayOp_Word8IndexByteArrayOp_Word16IndexByteArrayOp_Word32IndexByteArrayOp_Word64IndexByteArrayOp_Word8AsChar IndexByteArrayOp_Word8AsWideCharIndexByteArrayOp_Word8AsIntIndexByteArrayOp_Word8AsWordIndexByteArrayOp_Word8AsAddrIndexByteArrayOp_Word8AsFloatIndexByteArrayOp_Word8AsDouble!IndexByteArrayOp_Word8AsStablePtrIndexByteArrayOp_Word8AsInt16IndexByteArrayOp_Word8AsInt32IndexByteArrayOp_Word8AsInt64IndexByteArrayOp_Word8AsWord16IndexByteArrayOp_Word8AsWord32IndexByteArrayOp_Word8AsWord64ReadByteArrayOp_CharReadByteArrayOp_WideCharReadByteArrayOp_IntReadByteArrayOp_WordReadByteArrayOp_AddrReadByteArrayOp_FloatReadByteArrayOp_DoubleReadByteArrayOp_StablePtrReadByteArrayOp_Int8ReadByteArrayOp_Int16ReadByteArrayOp_Int32ReadByteArrayOp_Int64ReadByteArrayOp_Word8ReadByteArrayOp_Word16ReadByteArrayOp_Word32ReadByteArrayOp_Word64ReadByteArrayOp_Word8AsCharReadByteArrayOp_Word8AsWideCharReadByteArrayOp_Word8AsIntReadByteArrayOp_Word8AsWordReadByteArrayOp_Word8AsAddrReadByteArrayOp_Word8AsFloatReadByteArrayOp_Word8AsDouble ReadByteArrayOp_Word8AsStablePtrReadByteArrayOp_Word8AsInt16ReadByteArrayOp_Word8AsInt32ReadByteArrayOp_Word8AsInt64ReadByteArrayOp_Word8AsWord16ReadByteArrayOp_Word8AsWord32ReadByteArrayOp_Word8AsWord64WriteByteArrayOp_CharWriteByteArrayOp_WideCharWriteByteArrayOp_IntWriteByteArrayOp_WordWriteByteArrayOp_AddrWriteByteArrayOp_FloatWriteByteArrayOp_DoubleWriteByteArrayOp_StablePtrWriteByteArrayOp_Int8WriteByteArrayOp_Int16WriteByteArrayOp_Int32WriteByteArrayOp_Int64WriteByteArrayOp_Word8WriteByteArrayOp_Word16WriteByteArrayOp_Word32WriteByteArrayOp_Word64WriteByteArrayOp_Word8AsChar WriteByteArrayOp_Word8AsWideCharWriteByteArrayOp_Word8AsIntWriteByteArrayOp_Word8AsWordWriteByteArrayOp_Word8AsAddrWriteByteArrayOp_Word8AsFloatWriteByteArrayOp_Word8AsDouble!WriteByteArrayOp_Word8AsStablePtrWriteByteArrayOp_Word8AsInt16WriteByteArrayOp_Word8AsInt32WriteByteArrayOp_Word8AsInt64WriteByteArrayOp_Word8AsWord16WriteByteArrayOp_Word8AsWord32WriteByteArrayOp_Word8AsWord64CompareByteArraysOpCopyByteArrayOpCopyMutableByteArrayOpCopyByteArrayToAddrOpCopyMutableByteArrayToAddrOpCopyAddrToByteArrayOpSetByteArrayOpAtomicReadByteArrayOp_IntAtomicWriteByteArrayOp_IntCasByteArrayOp_IntCasByteArrayOp_Int8CasByteArrayOp_Int16CasByteArrayOp_Int32CasByteArrayOp_Int64FetchAddByteArrayOp_IntFetchSubByteArrayOp_IntFetchAndByteArrayOp_IntFetchNandByteArrayOp_IntFetchOrByteArrayOp_IntFetchXorByteArrayOp_Int AddrAddOp AddrSubOp AddrRemOp AddrToIntOp IntToAddrOpAddrGtOpAddrGeOpAddrEqOpAddrNeOpAddrLtOpAddrLeOpIndexOffAddrOp_CharIndexOffAddrOp_WideCharIndexOffAddrOp_IntIndexOffAddrOp_WordIndexOffAddrOp_AddrIndexOffAddrOp_FloatIndexOffAddrOp_DoubleIndexOffAddrOp_StablePtrIndexOffAddrOp_Int8IndexOffAddrOp_Int16IndexOffAddrOp_Int32IndexOffAddrOp_Int64IndexOffAddrOp_Word8IndexOffAddrOp_Word16IndexOffAddrOp_Word32IndexOffAddrOp_Word64ReadOffAddrOp_CharReadOffAddrOp_WideCharReadOffAddrOp_IntReadOffAddrOp_WordReadOffAddrOp_AddrReadOffAddrOp_FloatReadOffAddrOp_DoubleReadOffAddrOp_StablePtrReadOffAddrOp_Int8ReadOffAddrOp_Int16ReadOffAddrOp_Int32ReadOffAddrOp_Int64ReadOffAddrOp_Word8ReadOffAddrOp_Word16ReadOffAddrOp_Word32ReadOffAddrOp_Word64WriteOffAddrOp_CharWriteOffAddrOp_WideCharWriteOffAddrOp_IntWriteOffAddrOp_WordWriteOffAddrOp_AddrWriteOffAddrOp_FloatWriteOffAddrOp_DoubleWriteOffAddrOp_StablePtrWriteOffAddrOp_Int8WriteOffAddrOp_Int16WriteOffAddrOp_Int32WriteOffAddrOp_Int64WriteOffAddrOp_Word8WriteOffAddrOp_Word16WriteOffAddrOp_Word32WriteOffAddrOp_Word64InterlockedExchange_AddrInterlockedExchange_WordCasAddrOp_AddrCasAddrOp_WordCasAddrOp_Word8CasAddrOp_Word16CasAddrOp_Word32CasAddrOp_Word64FetchAddAddrOp_WordFetchSubAddrOp_WordFetchAndAddrOp_WordFetchNandAddrOp_WordFetchOrAddrOp_WordFetchXorAddrOp_WordAtomicReadAddrOp_WordAtomicWriteAddrOp_Word NewMutVarOp ReadMutVarOp WriteMutVarOpAtomicModifyMutVar2OpAtomicModifyMutVar_Op CasMutVarOpCatchOpRaiseOpRaiseUnderflowOpRaiseOverflowOpRaiseDivZeroOp RaiseIOOpMaskAsyncExceptionsOpMaskUninterruptibleOpUnmaskAsyncExceptionsOp MaskStatusNewPromptTagOpPromptOp Control0Op AtomicallyOpRetryOp CatchRetryOp CatchSTMOp NewTVarOp ReadTVarOp ReadTVarIOOp WriteTVarOp NewMVarOp TakeMVarOp TryTakeMVarOp PutMVarOp TryPutMVarOp ReadMVarOp TryReadMVarOp IsEmptyMVarOp NewIOPortOp ReadIOPortOp WriteIOPortOpDelayOp WaitReadOp WaitWriteOpForkOpForkOnOp KillThreadOpYieldOp MyThreadIdOp LabelThreadOpIsCurrentThreadBoundOp NoDuplicateOpGetThreadLabelOpThreadStatusOp ListThreadsOpMkWeakOpMkWeakNoFinalizerOpAddCFinalizerToWeakOp DeRefWeakOpFinalizeWeakOpTouchOpMakeStablePtrOpDeRefStablePtrOp EqStablePtrOpMakeStableNameOpStableNameToIntOp CompactNewOpCompactResizeOpCompactContainsOpCompactContainsAnyOpCompactGetFirstBlockOpCompactGetNextBlockOpCompactAllocateBlockOpCompactFixupPointersOp CompactAddCompactAddWithSharing CompactSizeReallyUnsafePtrEqualityOpParOpSparkOpSeqOp GetSparkOp NumSparks KeepAliveOp DataToTagOp TagToEnumOp AddrToAnyOp AnyToAddrOp MkApUpd0_OpNewBCOOpUnpackClosureOp ClosureSizeOpGetApStackValOp GetCCSOfOpGetCurrentCCSOp ClearCCSOp WhereFromOp TraceEventOpTraceEventBinaryOp TraceMarkerOpSetThreadAllocationCounterVecBroadcastOp VecPackOp VecUnpackOp VecInsertOpVecAddOpVecSubOpVecMulOpVecDivOp VecQuotOpVecRemOpVecNegOpVecIndexByteArrayOpVecReadByteArrayOpVecWriteByteArrayOpVecIndexOffAddrOpVecReadOffAddrOpVecWriteOffAddrOpVecIndexScalarByteArrayOpVecReadScalarByteArrayOpVecWriteScalarByteArrayOpVecIndexScalarOffAddrOpVecReadScalarOffAddrOpVecWriteScalarOffAddrOpPrefetchByteArrayOp3PrefetchMutableByteArrayOp3PrefetchAddrOp3PrefetchValueOp3PrefetchByteArrayOp2PrefetchMutableByteArrayOp2PrefetchAddrOp2PrefetchValueOp2PrefetchByteArrayOp1PrefetchMutableByteArrayOp1PrefetchAddrOp1PrefetchValueOp1PrefetchByteArrayOp0PrefetchMutableByteArrayOp0PrefetchAddrOp0PrefetchValueOp0 maxPrimOpTag primOpTag allThePrimOps tagToEnumKey primOpFixity primOpDocsprimOpOutOfLineprimOpOkForSpeculationprimOpOkForSideEffects primOpIsCheap primOpIsDivprimOpCodeSize primOpTypeprimOpResultType primOpOccprimOpWrapperIdisComparisonPrimOp primOpSiggetPrimOpResultInfo pprPrimOpprimOpIsReallyInline$fOutputablePrimOp $fOrdPrimOp $fEqPrimOp$fOutputablePrimCall primOpRules CheapAppFunexprType coreAltType coreAltsType mkLamType mkLamTypesapplyTypeToArgs mkCastMComkPiMComkCastmkTickmkTicksisSaturatedConApp mkTickNoHNF tickHNFArgs stripTicksTopstripTicksTopEstripTicksTopT stripTicksE stripTicksT bindNonRecneedsCaseBinding mkAltExpr mkDefaultCasemkSingleAltCase findDefault addDefault isDefaultAltfindAlt mergeAlts trimConArgs filterAltsrefineDefaultAltcombineIdenticalAlts scaleAltsBy exprIsTrivialgetIdFromTrivialExprgetIdFromTrivialExpr_maybe exprIsDupableexprIsWorkFree exprIsCheap exprIsCheapXexprIsExpandable isCheapAppisExpandableAppexprOkForSpeculationexprOkForSideEffectsexprOkForSpecEvalaltsAreExhaustiveetaExpansionTick exprIsHNF exprIsConLikeexprIsTopLevelBindableexprIsTickedStringexprIsTickedString_maybedataConRepInstPatdataConRepFSInstPat cheapEqExpr cheapEqExpr' diffBinds isEmptyTynormSplitTyConApp_maybeextendInScopeSetBindextendInScopeSetBndrsmkInScopeSetBndrscollectMakeStaticArgs isJoinBinddumpIdInfoOfProgrammkStrictFieldSeqsshouldStrictifyIdForCbvshouldUseCbvForIdisUnsafeEqualityProof StgPprOpts stgSccEnabledOutputablePassStgOp StgPrimOp StgPrimCallOp StgFCallOp UpdateFlag ReEntrant Updatable SingleEntry XLetNoEscape XRhsClosureBinderPStgPassVanillaLiftLamsInferTaggedBinders InferTaggedCodeGenConstructorNumberNoNumberNumbered OutStgAlt OutStgRhs OutStgExpr OutStgArg OutStgBindingOutStgTopBindingInStgAltInStgRhs InStgExprInStgArg InStgBindingInStgTopBindingTgStgAltTgStgRhs TgStgExpr TgStgBindingTgStgTopBindingCgStgAltCgStgRhs CgStgExpr CgStgBindingCgStgTopBindingLlStgAltLlStgRhs LlStgExpr LlStgBindingLlStgTopBindingStgAltStgRhsStgExpr StgBinding StgTopBindingAltTypePolyAlt MultiValAltAlgAltPrimAlt GenStgAltalt_con alt_bndrsalt_rhsNoExtFieldSilent GenStgRhs StgRhsClosure StgRhsCon GenStgExprStgAppStgLit StgConAppStgOpAppStgCaseStgLetStgLetNoEscapeStgTickStgArg StgVarArg StgLitArg GenStgBinding StgNonRecStgRecGenStgTopBinding StgTopLiftedStgTopStringLit isDllConApp stgArgTypestgCaseBndrInScopenoExtFieldSilent stgRhsArity freeVarsOfRhs isUpdatablepanicStgPprOptsshortStgPprOptspprGenStgTopBindingpprGenStgTopBindings pprStgBindingpprStgTopBindingpprStgTopBindings pprStgArg pprStgExpr pprStgAlt pprStgRhs$fOutputableStgArg$fOutputableNoExtFieldSilent$fOutputableAltType$fOutputableConstructorNumber$fOutputableUpdateFlag$fOutputableStgOp$fOutputableGenStgRhs$fOutputableGenStgExpr$fOutputableGenStgBinding$fDataNoExtFieldSilent$fEqNoExtFieldSilent$fOrdNoExtFieldSilentCallCtxt BoringCtxtRhsCtxt DiscArgCtxt RuleArgCtxt ValAppCtxtCaseCtxt ArgSummaryTrivArg NonTrivArgValueArgunfoldingCreationThresholdunfoldingUseThresholdunfoldingFunAppDiscountunfoldingDictDiscountunfoldingVeryAggressiveunfoldingCaseThresholdunfoldingCaseScalingunfoldingReportPrefixupdateReportPrefixinlineBoringOkcalcUnfoldingGuidancecouldBeSmallEnoughToInlinesmallEnoughToInlinecallSiteInline$fOutputableExprSize$fOutputableArgSummary$fOutputableCallCtxt megaSeqIdInfo seqRuleInfoseqRulesseqExprseqExprsseqBinds seqUnfolding extendIdSubstextendIdSubstWithCloneextendIdSubstList extendSubstextendSubstWithVarextendSubstList lookupIdSubstlookupIdSubst_maybedelBndrdelBndrs mkOpenSubst substExprSC substExpr substBindSC substBind deShadowBinds substBndr substBndrs substRecBndrs cloneIdBndr cloneIdBndrs cloneBndrs cloneBndrcloneRecIdBndrs substIdType substIdInfosubstUnfoldingSCsubstUnfolding substIdOcc substRuleInfosubstRulesForImportedIds substDVarSet substTickish ArityOpts ao_ped_botao_dicts_cheap ArityType manifestArity joinRhsArityexprBotStrictness_maybearityTypeBotSigs_maybe typeArity typeOneShots typeOneShot isOneShotBndrisStateHackType zapLamBndrsmkBotArityTypearityTypeArityexprEtaExpandArity findRhsArity idArityTypecheapArityType exprArity exprIsDeadEnd etaExpand etaExpandAT tryEtaReduce pushCoArgs pushCoArg pushCoTyArg pushCoValArgpushCoercionIntoLambda pushCoDataConcollectBindersPushingCoetaExpandToJoinPointetaExpandToJoinPointRule$fOutputableArityType$fOutputableArityEnv$fOutputableEtaInfo $fEqArityType$fEqCostoccurAnalyseExproccurAnalysePgmzapLambdaBndrsscrutBinderSwap_maybe$fOutputableOccEncl$fOutputableUsageDetails$fOutputableDetailsmkFinalUnfoldingmkFinalUnfolding'mkCompulsoryUnfolding'mkCompulsoryUnfoldingmkSimpleUnfoldingmkDFunUnfoldingmkDataConUnfoldingmkWrapperUnfoldingmkWorkerUnfoldingmkInlineUnfoldingNoAritymkInlineUnfoldingWithAritymkInlinableUnfolding specUnfolding mkUnfoldingmkCoreUnfoldingcertainlyWillInline FloatBindFloatLet FloatCase MkStringIdsunpackCStringIdunpackCStringUtf8Id sortQuantVars mkCoreAppmkWildEvBindermkWildValBinder mkWildCase mkIfThenElsecastBottomExpr mkLitRubbishmkUncheckedIntExpr mkIntExprInt mkIntegerExpr mkNaturalExprmkStringExprFSgetMkStringIdsmkStringExprFSWithmkCoreUnboxedTuplemkCoreTupBoxitymkCoreVarTupTy mkCoreTupmkCoreUnboxedSummkBigCoreVarTupSolomkBigCoreVarTup mkBigCoreTupmkBigCoreVarTupTymkBigCoreTupTyunitExpr mkChunkifiedchunkifymkBigTupleSelectormkBigTupleSelectorSolomkBigTupleCase wrapFloat wrapFloats floatBindings mkNilExpr mkConsExpr mkListExpr mkFoldrExpr mkBuildExpr mkNothingExpr mkJustExprmkRuntimeErrorApperrorIdsrEC_SEL_ERROR_IDrEC_CON_ERROR_ID pAT_ERROR_IDnO_METHOD_BINDING_ERROR_IDnON_EXHAUSTIVE_GUARDS_ERROR_ID tYPE_ERROR_IDaBSENT_SUM_FIELD_ERROR_IDmkImpossibleExprmkAbsentErrorApp$fOutputableFloatBind LabelStyleCStyleAsmStyle InfoProvEnt infoTablePtrinfoProvEntClosureType infoTableTypeinfoProvModule infoTableProvDynamicLinkerLabelInfoCodeStub SymbolPtr GotSymbolPtrGotSymbolOffsetConInfoTableLocation UsageSiteDefinitionSiteForeignLabelSourceForeignLabelInPackageForeignLabelInExternalPackageForeignLabelInThisPackageNeedExternDecl isIdLabel isTickyLabelpprDebugCLabelgetConInfoTableLocation mkSRTLabelmkRednCountsLabel mkTagHitLabelmkClosureLabelmkInfoTableLabel mkEntryLabelmkClosureTableLabelmkConInfoTableLabel mkBytesLabelmkBlockInfoTableLabelmkDirty_MUT_VAR_Label#mkNonmovingWriteBarrierEnabledLabelmkUpdInfoLabelmkBHUpdInfoLabelmkIndStaticInfoLabelmkMainCapabilityLabelmkMAP_FROZEN_CLEAN_infoLabelmkMAP_FROZEN_DIRTY_infoLabelmkMAP_DIRTY_infoLabelmkTopTickyCtrLabelmkCAFBlackHoleInfoTableLabelmkArrWords_infoLabelmkSMAP_FROZEN_CLEAN_infoLabelmkSMAP_FROZEN_DIRTY_infoLabelmkSMAP_DIRTY_infoLabelmkBadAlignmentLabelmkOutOfBoundsAccessLabelmkMemcpyRangeOverlapLabelmkMUT_VAR_CLEAN_infoLabelmkSRTInfoLabelmkCmmInfoLabelmkCmmEntryLabelmkCmmRetInfoLabel mkCmmRetLabelmkCmmCodeLabelmkCmmClosureLabelmkCmmDataLabelmkRtsCmmDataLabelmkLocalBlockLabelmkRtsPrimOpLabelmkSelectorInfoLabelmkSelectorEntryLabelmkApInfoTableLabelmkApEntryLabelmkPrimCallLabelmkForeignLabel addLabelSize isBytesLabelisForeignLabelisStaticClosureLabelisSomeRODataLabelisInfoTableLabelisCmmInfoTableLabelisConInfoTableLabelforeignLabelStdcallInfo mkBitmapLabel mkCCLabel mkCCSLabel mkIPELabelmkRtsApFastLabelmkRtsSlowFastTickyCtrLabelmkRtsUnpackCStringLabelmkRtsUnpackCStringUtf8LabelmkHpcTicksLabelmkDynamicLinkerLabeldynamicLinkerLabelInfomkPicBaseLabelmkDeadStripPreventermkStringLitLabelmkInitializerStubLabelmkInitializerArrayLabelmkFinalizerStubLabelmkFinalizerArrayLabelmkAsmTempLabelmkAsmTempDerivedLabelmkAsmTempEndLabelmkAsmTempProcEndLabelmkAsmTempDieLabel toClosureLbltoSlowEntryLbl toEntryLbl toInfoLblhasHaskellNamehasIdLabelInfohasCAF needsCDeclmaybeLocalBlockLabel isMathFunexternallyVisibleCLabelisCFunctionLabel isGcPtrLabel isLocalCLabel labelDynamic pprAsmLabelppInternalProcLabel mayRedirectTo$fOutputableForeignLabelSource$fOrdTickyIdInfo$fOutputableTickyIdInfo $fOutputableConInfoTableLocation$fOutputableIdLabelInfo$fOutputablePPlatformCLabel $fOutputablePPlatformInfoProvEnt $fOrdCLabel $fShowCLabel$fEqInfoProvEnt$fOrdInfoProvEnt $fEqCLabel$fEqDynamicLinkerLabelInfo$fOrdDynamicLinkerLabelInfo$fEqCmmLabelInfo$fOrdCmmLabelInfo$fEqRtsLabelInfo$fOrdRtsLabelInfo$fEqIdLabelInfo$fOrdIdLabelInfo$fEqConInfoTableLocation$fOrdConInfoTableLocation$fEqTickyIdInfo$fShowTickyIdInfo$fEqForeignLabelSource$fOrdForeignLabelSource$fOrdNeedExternDecl$fEqNeedExternDecl$fEqModuleLabelKind$fOrdModuleLabelKindInfoTableProvMapprovDC provClosureprovInfoTablesDCMap ClosureMapIpeSourceLocationemptyInfoTableProvMap newBlockIdblockLbl infoTblLbl ShowHowMuch ShowHeaderShowSome ShowIfaceAltPprShowSub ss_how_much ss_forall IfaceJoinInfoIfaceNotJoinPointIfaceJoinPoint IfaceMaybeRhsIfUseUnfoldingRhsIfRhsIfaceTopBndrInfo IfLclTopBndr IfGblTopBndr IfaceLetBndr IfLetBndr IfaceBindingX IfaceNonRecIfaceRec IfaceBinding IfaceConAlt IfaceDefault IfaceDataAlt IfaceLitAltIfaceAlt IfaceTickish IfaceHpcTickIfaceSCC IfaceSource IfaceExprIfaceLclIfaceExtIfaceCo IfaceTupleIfaceLamIfaceApp IfaceCase IfaceECaseIfaceLet IfaceCastIfaceLitIfaceLitRubbish IfaceFCall IfaceTick IfaceLFInfo IfLFReEntrant IfLFThunkIfLFCon IfLFUnknown IfLFUnliftedIfaceIdDetails IfVanillaIdIfWorkerLikeId IfRecSelIdIfDFunId IfGuidance IfNoGuidanceIfWhenIfaceUnfolding IfCoreUnfold IfDFunUnfold IfaceInfoItemHsArityHsDmdSigHsCprSigHsInlineHsUnfold HsNoCafRefsHsLFInfoHsTagSig IfaceIdInfoIfaceCompleteMatchIfaceAnnTargetIfaceAnnotationifAnnotatedTargetifAnnotatedValue IfaceRule ifRuleName ifActivation ifRuleBndrs ifRuleHead ifRuleArgs ifRuleRhs ifRuleAuto ifRuleOrph IfaceFamInst ifFamInstFam ifFamInstTysifFamInstAxiom ifFamInstOrph IfaceClsInst ifInstCls ifInstTysifDFunifOFlag ifInstOrph IfaceSrcBang IfSrcBang IfaceBangIfNoBangIfStrictIfUnpack IfUnpackCo IfaceEqSpec IfaceConDeclIfCon ifConName ifConWrapper ifConInfix ifConExTCvsifConUserTvBinders ifConEqSpec ifConCtxt ifConArgTys ifConFields ifConStrictsifConSrcStricts IfaceConDeclsIfAbstractTyCon IfDataTyCon IfNewTyCon IfaceAxBranch ifaxbTyVarsifaxbEtaTyVars ifaxbCoVarsifaxbLHS ifaxbRolesifaxbRHS ifaxbIncompsIfaceAT IfaceClassOpIfaceFamTyConFlavIfaceDataFamilyTyConIfaceOpenSynFamilyTyConIfaceClosedSynFamilyTyCon!IfaceAbstractClosedSynFamilyTyConIfaceBuiltInSynFamTyConIfaceTyConParent IfNoParentIfDataInstanceIfaceClassBodyIfAbstractClassIfConcreteClass ifClassCtxtifATsifSigsifMinDef IfaceDeclIfaceId IfaceData IfaceSynonym IfaceFamily IfaceClass IfaceAxiom IfacePatSynifNameifType ifIdDetailsifIdInfo ifBinders ifResKindifCTypeifRolesifCtxtifCons ifGadtSyntaxifParentifSynRhsifResVar ifFamFlavifFamInjifFDsifBodyifTyConifRole ifAxBranches ifPatIsInfix ifPatMatcher ifPatBuilderifPatUnivBndrs ifPatExBndrs ifPatProvCtxt ifPatReqCtxt ifPatArgsifPatTy ifFieldLabels IfaceTopBndrvisibleIfConDeclsifaceDeclImplicitBndrsifaceDeclFingerprints showToHeader showToIface pprIfaceDecl pprIfaceExprfreeNamesIfDeclfreeNamesIfRulefreeNamesIfFamInst$fNFDataIfaceTyConParent$fBinaryIfaceTyConParent$fOutputableIfaceTyConParent$fNFDataIfaceClassOp$fBinaryIfaceClassOp$fOutputableIfaceClassOp$fHasOccNameIfaceClassOp$fNamedThingIfaceClassOp$fNFDataIfaceAxBranch$fBinaryIfaceAxBranch$fNFDataIfaceFamTyConFlav$fBinaryIfaceFamTyConFlav$fNFDataIfaceBang$fBinaryIfaceBang$fNFDataIfaceSrcBang$fBinaryIfaceSrcBang$fNFDataIfaceConDecl$fBinaryIfaceConDecl$fHasOccNameIfaceConDecl$fNamedThingIfaceConDecl$fNFDataIfaceConDecls$fBinaryIfaceConDecls$fNFDataIfaceClsInst$fBinaryIfaceClsInst$fOutputableIfaceClsInst$fNFDataIfaceFamInst$fBinaryIfaceFamInst$fOutputableIfaceFamInst$fNFDataIfaceAnnotation$fBinaryIfaceAnnotation$fOutputableIfaceAnnotation$fNFDataIfaceCompleteMatch$fBinaryIfaceCompleteMatch$fOutputableIfaceCompleteMatch$fNFDataIfGuidance$fBinaryIfGuidance$fOutputableIfGuidance$fBinaryIfaceLFInfo$fOutputableIfaceLFInfo$fNFDataIfaceTickish$fBinaryIfaceTickish$fNFDataIfaceConAlt$fBinaryIfaceConAlt$fOutputableIfaceConAlt$fNFDataIfaceBindingX$fBinaryIfaceBindingX$fOutputableIfaceBindingX$fNFDataIfaceJoinInfo$fBinaryIfaceJoinInfo$fOutputableIfaceJoinInfo$fNFDataIfaceLetBndr$fNFDataIfaceAlt$fNFDataIfaceExpr$fNFDataIfaceUnfolding$fNFDataIfaceInfoItem$fBinaryIfaceLetBndr$fBinaryIfaceExpr$fBinaryIfaceAlt$fBinaryIfaceUnfolding$fBinaryIfaceInfoItem$fOutputableIfaceUnfolding$fOutputableIfaceInfoItem$fOutputableIfaceExpr$fNFDataIfaceMaybeRhs$fBinaryIfaceMaybeRhs$fOutputableIfaceMaybeRhs$fNFDataIfaceIdDetails$fNFDataIfaceAT$fNFDataIfaceClassBody$fNFDataIfaceDecl$fBinaryIfaceIdDetails$fBinaryIfaceAT$fBinaryIfaceDecl$fOutputableIfaceIdDetails$fOutputableIfaceAT$fOutputableIfaceDecl$fHasOccNameIfaceDecl$fNamedThingIfaceDecl$fNFDataIfaceTopBndrInfo$fBinaryIfaceTopBndrInfo$fOutputableIfaceTopBndrInfo$fNFDataIfaceRule$fBinaryIfaceRule$fOutputableIfaceRule$fOutputableShowHowMuch$fFunctorIfaceBindingX$fFoldableIfaceBindingX$fTraversableIfaceBindingX$fOrdIfaceBindingX$fEqIfaceBindingXWholeCoreBindings wcb_bindings wcb_modulewcb_mod_location DefinerOfRegs foldRegsDefd UserOfRegs foldRegsUsed GlobalRegSet LocalRegSetRegSetCmmLitCmmIntCmmFloatCmmVecCmmLabel CmmLabelOffCmmLabelDiffOffCmmBlockCmmHighStackMarkAreaOldYoung AlignmentSpecNaturallyAligned UnalignedCmmExprCmmLoad CmmMachOp CmmStackSlot CmmRegOff cmmExprType cmmLitType cmmExprWidthcmmExprAlignmentmaybeInvertCmmExprisTrivialCmmExprhasNoGlobalRegsisLitisComparisonExpr emptyRegSet nullRegSet elemRegSet extendRegSetdeleteFromRegSetmkRegSet minusRegSet plusRegSet timesRegSet sizeRegSet regSetToListfoldLocalRegsUsedfoldLocalRegsDefd$fOutputableArea$fOutputableCmmLit$fOutputablePPlatformCmmLit$fOutputablePPlatformCmmExpr $fEqCmmExpr$fUserOfRegsrList$fUserOfRegsrCmmExpr$fUserOfRegsrr$fUserOfRegsGlobalRegCmmReg$fUserOfRegsLocalRegCmmReg$fDefinerOfRegsrList$fDefinerOfRegsrr$fDefinerOfRegsGlobalRegCmmReg$fDefinerOfRegsLocalRegCmmReg $fShowCmmExpr $fEqCmmLit $fShowCmmLit$fEqArea $fOrdArea $fShowArea$fEqAlignmentSpec$fOrdAlignmentSpec$fShowAlignmentSpecmodBreaks_flagsmodBreaks_locsmodBreaks_varsmodBreaks_decls modBreaks_ccsmodBreaks_breakInfo CCostCentre BreakIndex CgBreakInfo cgb_tyvarscgb_vars cgb_restyBCONPtr BCONPtrWord BCONPtrLbl BCONPtrItbl BCONPtrAddr BCONPtrStrBCOPtr BCOPtrName BCOPtrPrimOp BCOPtrBCOBCOPtrBreakArray UnlinkedBCOunlinkedBCONameunlinkedBCOArityunlinkedBCOInstrsunlinkedBCOBitmapunlinkedBCOLitsunlinkedBCOPtrsAddrPtrItblPtrAddrEnvItblEnvNativeCallInfonativeCallTypenativeCallSizenativeCallRegsnativeCallStackSpillSizeNativeCallTypeNativePrimCallNativeTupleReturn RegBitmap unRegBitmapFFIInfoCompiledByteCodebc_bcosbc_itblsbc_ffisbc_strs bc_breaksseqCompiledByteCodevoidTupleReturnInfovoidPrimCallInfoemptyModBreaks$fOutputableNativeCallInfo$fNFDataBCONPtr$fOutputableUnlinkedBCO$fNFDataBCOPtr$fNFDataUnlinkedBCO$fOutputableCgBreakInfo$fOutputableCompiledByteCode$fNFDataAddrPtr $fShowItblPtr$fNFDataItblPtr$fEqNativeCallType$fEnumRegBitmap $fEqRegBitmap$fShowRegBitmap$fIntegralRegBitmap$fNumRegBitmap$fOrdRegBitmap$fRealRegBitmap$fBitsRegBitmap$fFiniteBitsRegBitmap$fOutputableRegBitmap $fEnumWordOff $fEqWordOff $fShowWordOff$fIntegralWordOff $fNumWordOff $fOrdWordOff $fRealWordOff$fOutputableWordOff $fEnumByteOff $fEqByteOff $fShowByteOff$fIntegralByteOff $fNumByteOff $fOrdByteOff $fRealByteOff$fOutputableByteOff $fShowFFIInfo$fNFDataFFIInfo callerSaves activeStgRegs haveRegBaseglobalRegMaybefreeReg freeRegBaseOutputableBndrFlagHsCoreTyHsPSRn hsps_nwcs hsps_imp_tvs EpAnnForallTy getBangTypegetBangStrictnessfromMaybeContextmkHsForAllVisTelemkHsForAllInvisTelemkHsQTvs emptyLHsQTvs hsSigWcType dropWildCardshsOuterTyVarNameshsOuterExplicitBndrsmkHsOuterImplicitmkHsOuterExplicitmkHsImplicitSigTypemkHsExplicitSigTypemkHsWildCardBndrsmkHsPatSigTypemkEmptyWildCardBndrshsTyVarBndrFlagsetHsTyVarBndrFlaghsTvbAllKindedhsLinearhsUnrestrictedisUnrestricted arrowToHsType pprHsArrow hsWcScopedTvs hsScopedTvs hsTyVarName hsLTyVarName hsLTyVarNameshsExplicitLTyVarNameshsAllLTyVarNameshsLTyVarLocNamehsLTyVarLocNames hsTyKindSig ignoreParensmkAnonWildCardTymkHsOpTy mkHsAppTy mkHsAppTys mkHsAppKindTysplitHsFunTypehsTyGetAppHead_maybelhsTypeArgSrcSpannumVisibleArgs pprHsArgsAppsplitLHsPatSynTysplitLHsSigmaTyInvissplitLHsGadtTysplitLHsForAllTyInvissplitLHsForAllTyInvis_KPsplitLHsQualTysplitLHsInstDeclTygetLHsInstDeclHeadgetLHsInstDeclClass_maybe mkFieldOccmkAmbiguousFieldOccrdrNameAmbiguousFieldOccselectorAmbiguousFieldOccunambiguousFieldOccambiguousFieldOccpprAnonWildCardpprHsOuterFamEqnTyVarBndrspprHsOuterSigTyVarBndrs pprHsForAll pprLHsContextpprConDeclFields pprHsTypehsTypeNeedsParensparenthesizeHsTypeparenthesizeHsContext$fOutputableBndrFieldOcc$fOutputableFieldOcc$fOutputableHsConDetails$fOutputableBndrHsIPName$fOutputableHsIPName$fOutputableHsTyLit$fOutputableHsPatSigType$fOutputableHsWildCardBndrs$fOutputableHsForAllTelescope$fOutputableLHsQTyVars$fOutputableHsType$fOutputableHsSigType$fOutputableBndrGenLocated0!$fOutputableBndrAmbiguousFieldOcc$fOutputableAmbiguousFieldOcc$fOutputableHsArg$fOutputableConDeclField$fOutputableHsArrow$fNamedThingHsTyVarBndr$fOutputableHsTyVarBndr$fOutputableHsOuterTyVarBndrs $fOutputableBndrFlagSpecificityp$fOutputableBndrFlag()p $fDataHsPSRn CompilerInfoGCCClang AppleClang AppleClang51 Emscripten UnknownCC LinkerInfoGnuLDGnuGoldLlvmLLDDarwinLD SolarisLDAixLD UnknownLDPkgDbRef GlobalPkgDb UserPkgDb PkgDbPathFlagSpec flagSpecName flagSpecFlagflagSpecActionflagSpecGhcMode TurnOnFlagCmdLinePOnOffOnOffFlushOut FatalMessagerDynamicTooStateDT_DontDT_OKDT_DynRtsOptsEnabled RtsOptsNone RtsOptsIgnoreRtsOptsIgnoreAllRtsOptsSafeOnly RtsOptsAll DynLibLoader DeployableSystemDependent PackageDBFlag PackageDBNoUserPackageDBNoGlobalPackageDBClearPackageDBs PackageFlag ExposePackage HidePackage TrustFlag TrustPackageDistrustPackageIgnorePackageFlag IgnorePackage ModRenamingmodRenamingWithImplicit modRenamings PackageArg UnitIdArgGhcLinkNoLink LinkBinary LinkInMemory LinkDynLib LinkStaticLib LinkMergedObjGhcMode CompManagerOneShotMkDependContainsDynFlagsextractDynFlags HasDynFlags getDynFlagsghcModeghcLinkghcNameVersion fileSettingstargetPlatform toolSettings platformMisc rawSettingstmpDir llvmOptLevel verbosity debugLevel simplPhasesmaxSimplIterations ruleCheckstrictnessBefore parMakeCountenableTimeStats ghcHeapSizemaxRelevantBindsmaxValidHoleFitsmaxRefHoleFitsrefLevelHoleFitsmaxUncoveredPatternsmaxPmCheckModelssimplTickFactor dmdUnboxWidthspecConstrThresholdspecConstrCountspecConstrRecursivebinBlobThresholdliberateCaseThreshold floatLamArgsliftLamsRecArgsliftLamsNonRecArgs liftLamsKnowncmmProcAlignment historySize importPathsmainModuleNameIs mainFunIsreductionDepthsolverIterations homeUnitId_homeUnitInstanceOf_homeUnitInstantiations_workingDirectorythisPackageName hiddenModulesreexportedModules targetWays_ splitInfo objectDirdylibInstallNamehiDirhieDirstubDirdumpDir objectSuf_hcSufhiSuf_hieSuf dynObjectSuf_ dynHiSuf_ outputFile_dynOutputFile_outputHi dynOutputHi dynLibLoader dynamicNow dumpPrefixdumpPrefixForceldInputs includePaths libraryPathsframeworkPathscmdlineFrameworksrtsOptsrtsOptsEnabledrtsOptsSuggestionshpcDirpluginModNamespluginModNameOptsfrontendPluginOptsexternalPluginSpecs depMakefiledepIncludePkgDepsdepIncludeCppDepsdepExcludeMods depSuffixespackageDBFlagsignorePackageFlags packageFlagspluginPackageFlags trustFlags packageEnv dumpFlags generalFlags warningFlagsfatalWarningFlagslanguage safeHaskell safeInfer safeInferredthOnLoc newDerivOnLocderiveViaOnLocoverlapInstLocincoherentOnLoc pkgTrustOnLoc warnSafeOnLocwarnUnsafeOnLoctrustworthyOnLoc extensionsextensionFlags unfoldingOpts maxWorkerArgs ghciHistSizeflushOutghcVersionFilehaddockOptions ghciScripts pprUserLengthpprCols useUnicodeuseColor canUseColor colSchemeprofAutocallerCcFiltersinteractivePrint sseVersion bmiVersionavxavx2avx512cdavx512eravx512favx512pfrtldInfortccInfo rtasmInfomaxInlineAllocSizemaxInlineMemcpyInsnsmaxInlineMemsetInsns reverseErrors maxErrors initialUniqueuniqueIncrement cfgWeights IncludeSpecsincludePathsQuoteincludePathsGlobalincludePathsQuoteImplicitaddGlobalIncludeaddQuoteIncludeaddImplicitQuoteIncludeflattenIncludessettings programNameprojectVersion ghcUsagePath ghciUsagePathtopDirextraGccViaCFlagsglobalPackageDatabasePathpgm_Lpgm_Ppgm_Fpgm_cpgm_cxxpgm_apgm_lpgm_lmpgm_dllpgm_T pgm_windrespgm_lccpgm_ar pgm_ranlibpgm_lopgm_lcpgm_iopt_Lopt_Popt_P_signatureopt_Fopt_copt_cxxopt_aopt_lopt_lm opt_windresopt_lccopt_loopt_lcopt_iversionedAppDirversionedFilePath isOneShotisNoLinkpackageFlagsChangedpositionIndependentdynamicTooState setDynamicNow initDynFlagsdefaultDynFlagsdefaultFatalMessagerdefaultFlushOutlanguageExtensions hasPprDebughasNoDebugOutputhasNoStateHackhasNoOptCoerciondoptdopt_set dopt_unsetgoptgopt_set gopt_unsetwoptwopt_set wopt_unset wopt_fatalwopt_set_fatalwopt_unset_fatalxoptxopt_set xopt_unsetxopt_set_unlessExplSpecxopt_DuplicateRecordFieldsxopt_FieldSelectorslang_setpackageTrustOn safeHaskellOnsafeHaskellModeEnabledsafeLanguageOn safeInferOn safeImportsOnsafeDirectImpsReqsafeImplicitImpsReq unsafeFlagsunsafeFlagsForInfergetOpts getVerbFlags setOutputFilesetDynOutputFile setOutputHisetDynOutputHiaddPluginModuleName updOptLevelparseDynamicFlagsCmdLineparseDynamicFilePragmagetCmdLineStateputCmdLineState runCmdLinePprocessCmdLinePparseDynamicFlagsFullallNonDeprecatedFlagsflagsAll flagsDynamic flagsPackageflagsForCompletionturnOnturnOff flagSpecOf wWarningFlagsfFlags fLangFlagssupportedLanguagesAndExtensionsxFlags impliedGFlagsimpliedOffGFlags impliedXFlagsglasgowExtsFlagssetGeneralFlag'unSetGeneralFlag' setUnitIdaugmentByWorkingDirectorysetFlagsFromEnvFile setTmpDir picCCOpts pieCCLDOptspicPOpts compilerInfo targetProfilemakeDynFlagsConsistentsetUnsafeGlobalDynFlagsisSse4_2Enabled isAvxEnabled isAvx2EnabledisAvx512cdEnabledisAvx512erEnabledisAvx512fEnabledisAvx512pfEnabled isBmiEnabled isBmi2EnabledsccProfilingEnabledneedSourceNotesuseXLinkerRPathinitSDocContextinitDefaultSDocContextinitPromotionTickContext outputFile objectSufwayspprDynFlagsDiffupdatePlatformConstants$fOutputableGhcMode$fOutputablePackageArg$fOutputableModRenaming$fOutputablePackageFlag$fOutputableOnOff$fApplicativeCmdLineP$fMonadCmdLineP$fHasDynFlagsExceptT$fHasDynFlagsMaybeT$fHasDynFlagsReaderT$fHasDynFlagsWriterT$fEqCompilerInfo$fEqLinkerInfo$fEqPackageDBFlag $fEqPkgDbRef$fEqDeprecation$fOrdDeprecation$fFunctorCmdLineP $fEqOnOff $fShowOnOff$fEqDynamicTooState$fShowDynamicTooState$fOrdDynamicTooState$fShowRtsOptsEnabled$fEqDynLibLoader$fEqPackageFlag $fEqTrustFlag$fEqIgnorePackageFlag$fEqModRenaming$fEqPackageArg$fShowPackageArg $fEqGhcLink $fShowGhcLink $fEqGhcMode$fShowIncludeSpecsTypeSize PatersonSizePS_TyFam PS_Vanillaps_tvsps_sizePatersonSizeFailure PSF_TyFamPSF_Size PSF_TyVarTypeCannotBeMarshaledReason NotADataTypeNewtypeDataConNotInScopeUnliftedFFITypesNeededNotABoxedMarshalableTyConForeignLabelNotAPtrNotSimpleUnliftedTypeNotBoxedKindAnyIllegalForeignTypeReasonTypeCannotBeMarshaledForeignDynNotPtrSafeHaskellMustBeInIOIOResultExpectedUnexpectedNestedForallLinearTypesNotAllowedOneArgExpectedAtLeastOneArgExpectedTcLevelConcreteTvOrigin ConcreteFRRMetaInfoTauTvTyVarTv RuntimeUnkTvCycleBreakerTv ConcreteTvFlexiIndirectSkolemTv RuntimeUnkMetaTvmtv_infomtv_ref mtv_tclvl SyntaxOpTypeSynAnySynRhoSynListSynFunSynType ExpRhoTypeExpSigmaTypeFRR ExpTypeFRR ExpSigmaType InferResultIRir_uniqir_lvlir_frrir_refExpTypeCheckInfer TcDTyCoVarSet TcDTyVarSet TcTyCoVarSet TcTyVarSetTcKind TcTauType TcRhoTypeTcSigmaTypeFRR TcSigmaType TcThetaType TcPredType TcTyConBinder PolyTcTyCon MonoTcTyConTcTyCon TcReqTVBinderTcInvisTVBinder TcTyVarBinder TcTypeFRR TcTyCoVarTcTypeTcCoVarmkCheckExpType synKnownType mkSynFunTys maxTcLevel topTcLevel isTopTcLevel pushTcLevelstrictlyDeeperThandeeperThanOrSame sameDepthAs tcTyVarLevel tcTypeLevel tcTyFamInststcTyFamInstsAndVistcTyConAppTyFamInstsAndVis isTyFamFreeanyRewritableTyVaranyRewritableTyFamAppexactTyCoVarsOfTypeexactTyCoVarsOfTypes tcIsTcTyVarisPromotableMetaTyVarisTouchableMetaTyVarisImmutableTyVar isSkolemTyVarskolemSkolInfoisOverlappableTyVarisAmbiguousTyVarisCycleBreakerTyVarisConcreteTyVar_maybeisConcreteTyVarTyisConcreteTyVarTy_maybe isMetaTyVarTy metaTyVarInfometaTyVarTcLevelmetaTyVarTcLevel_maybe metaTyVarRefsetMetaTyVarTcLevel isTyVarTyVarisFlexi isIndirectisRuntimeUnkSkolmkTyVarNamePairsfindDupTyVarTvs ambigTkvsOfTy mkInfSigmaTy mkSpecSigmaTy mkSigmaTytcMkDFunSigmaTymkPhiTy tcMkPhiTy tcMkDFunPhiTy getDFunTyKey tcSplitPiTystcSplitPiTy_maybetcSplitForAllTyVarBinder_maybetcSplitForAllTyVarstcSplitForAllInvisTyVarstcSplitSomeForAllTyVarstcSplitForAllReqTVBinderstcSplitForAllInvisTVBinderstcSplitForAllTyVarBinderstcSplitPredFunTy_maybe tcSplitPhiTytcSplitSigmaTytcSplitNestedSigmaTystcTyConAppTyContcTyConAppTyCon_maybetcTyConAppArgs tcSplitFunTystcSplitFunTy_maybetcSplitFunTysN tcFunArgTy tcFunResultTytcFunResultTyNtcSplitAppTy_maybe tcSplitAppTy tcSplitAppTys tcIsTyVarTytcSplitQuantPredTy tcSplitDFunTytcSplitDFunHeadtcSplitMethodTyisTyVarClassPredcheckValidClsArgs hasTyVarHead evVarPred boxEqPredpickCapturedPredsmkMinimalBySCstransSuperClassesimmSuperClassesisImprovementPred isSigmaTyisRhoTy isRhoExpTyisOverloadedTy isFloatTy isDoubleTy isIntegerTy isNaturalTyisIntTyisWordTyisBoolTyisUnitTyisCharTyisFloatingPrimTy isStringTy isRigidTy deNoteTypetcSplitIOType_maybeisFFIArgumentTyisFFIExternalTyisFFIImportResultTyisFFIExportResultTy isFFIDynTy isFFILabelTyisFFIPrimArgumentTyisFFIPrimResultTy isFunPtrTytcTyConVisibilitiesisNextTyConArgVisibleisNextArgVisible pSizeZeropSizeOneltPatersonSize noMoreTyVars pSizeType pSizeTypes pSizeTypeX pSizeTyConApppSizeClassPredpSizeClassPredXisStuckTypeFamilyisTerminatingClassallDistinctTyVarssizeType sizeTypes$fOutputableMetaDetails$fOutputableMetaInfo$fOutputableTcLevel$fOutputableTcTyVarDetails$fOutputableInferResult$fOutputableExpType$fOutputablePatersonSize!$fGenericIllegalForeignTypeReason$$fGenericTypeCannotBeMarshaledReason $fEqTcLevel $fOrdTcLevel TcTyThing TcIdSigInfo SelfBootInfoTcLclEnvlclEnvInGeneratedCode getLclEnvLoc setLclEnvLocgetLclEnvTcLevelsetLclEnvTcLevelHoleFit RawHoleFithfIdhfCandhfTypehfRefLvlhfWrap hfMatcheshfDoc HoleFitPluginHoleFitCandidateIdHFCand NameHFCand GreHFCand QuoteWrapper HoleExprRefHER EvCallStack EvCsEmpty EvCsPushCall EvTypeableEvTypeableTyConEvTypeableTyAppEvTypeableTrFunEvTypeableTyLitEvExprEvTermEvFunet_tvset_givenet_bindset_bodyEvBindeb_lhseb_rhs eb_is_given EvBindMapev_bind_varenv EvBindsVar CoEvBindsVarebv_uniq ebv_bindsebv_tcvs TcEvBindsEvBinds HsWrapperWpHole WpComposeWpFunWpCastWpEvLamWpEvAppWpTyLamWpTyAppWpLetWpMultCoercion TcMCoercionR TcMCoercionN TcMCoercion TcCoercionP TcCoercionR TcCoercionN TcCoercion maybeSymCo<.>mkWpFunmkWpEta mkWpCastR mkWpCastN mkWpTyApps mkWpEvApps mkWpEvVarApps mkWpTyLams mkWpEvLamsmkWpLet idHsWrapper isIdHsWrapperhsWrapDictBinderscollectHsWrapBindersisCoEvBindsVaremptyEvBindMap extendEvBindsisEmptyEvBindMap lookupEvBindevBindMapBinds foldEvBindMapnonDetStrictFoldEvBindMapfilterEvBindMapevBindMapToVarSetvarSetMinusEvBindMap evBindVarmkWantedEvBind mkGivenEvBindevId evCoercionevCast evDFunApp evDataConApp evSelector evTypeablemkEvCastmkEvScSelectorsemptyTcEvBindsisEmptyTcEvBindsevTermCoercion_maybeevTermCoercionfindNeededEvVars evVarsOfTerm pprHsWrapperunwrapIPwrapIPquoteWrapperTyVarTyapplyQuoteWrapper$fOutputableEvTypeable$fOutputableEvTerm$fOutputableEvBind$fUniquableEvBindsVar$fOutputableEvBindsVar$fOutputableTcEvBinds$fOutputableEvBindMap$fDataTcEvBinds$fOutputableHsWrapper$fMonoidHsWrapper$fSemigroupHsWrapper$fOutputableEvCallStack$fDataHoleExprRef$fOutputableHoleExprRef$fDataQuoteWrapper$fDataEvCallStack$fDataHsWrapper$fDataEvTypeable $fDataEvTermOptCoercionOptsoptCoercionEnabled optCoercion checkAxInstCo so_co_opts so_eta_reddefaultSimpleOptssimpleOptExprWith simpleOptPgmjoinPointBinding_maybejoinPointBindings_maybeexprIsConApp_maybeexprIsLiteral_maybeexprIsLambda_maybe$fOutputableSimpleOptEnvBangOptsbang_opt_strict_databang_opt_unbox_disablebang_opt_unbox_strictbang_opt_unbox_smallDataConBangOpts FixedBangOpts SrcBangOptsDCB wiredInIds ghcPrimIds mkDictSelRhsvanillaDataConBoxer mkDataConRepunwrapNewTypeBodywrapFamInstBody mkFCallId mkDictFunId coerceNameleftSectionNamerightSectionName nospecIdName proxyHashId nullAddrIdseqIdlazyIdnoinlineIdNamenoinlineConstraintIdName noinlineIdnoinlineConstraintIdnospecIdcoerceIdrealWorldPrimId voidPrimIdunboxedUnitExpr voidArgIdcoercionTokenId toIfaceTvBndrtoIfaceTvBndrs toIfaceIdBndr toIfaceBndrtoIfaceForAllBndr toIfaceKind toIfaceType toIfaceTyVartoIfaceTyCon_nametoIfaceCoerciontidyToIfaceTypetidyToIfaceContextpatSynToIfaceDecl toIfaceBangtoIfaceSrcBangtoIfaceLetBndrtoIfaceTopBndrtoIfaceIdDetails toIfaceIdInfo toIfUnfolding toIfaceExprtoIfaceTickish toIfaceBindtoIfaceTopBind toIfaceAlt toIfaceCon toIfaceApp toIfaceVar toIfaceLFInfodehydrateCgBreakInfoPotentialUnifiers NoUnifiersOneOrMoreUnifiersClsInstLookupResult InstMatch DFunInstTypeVisibleOrphanModulesInstEnvs ie_globalie_local ie_visibleInstEnvClsInst is_cls_nmis_tcs is_dfun_nameis_tvsis_clsis_tysis_dfunis_flag is_orphanfuzzyClsInstCmpisOverlappable isOverlapping isIncoherentinstanceDFunIdupdateClsInstDFunupdateClsInstDFuns pprInstancepprInstanceHdr pprInstances instanceHeadorphNamesOfClsInst instanceSigmkLocalInstancemkImportedInstance emptyInstEnv mkInstEnv instEnvEltsinstEnvClasses instIsVisibleclassInstancesclassNameInstances memberInstEnv unionInstEnvextendInstEnvList extendInstEnv filterInstEnv anyInstEnv mapInstEnvdeleteFromInstEnvdeleteDFunFromInstEnvidenticalClsInstHeadlookupUniqueInstEnvgetPotentialUnifiers nullUnifiers lookupInstEnvinstanceBindFun$fOutputableClsInst$fNamedThingClsInst$fOutputableInstEnv$fMonoidPotentialUnifiers$fSemigroupPotentialUnifiers$fOutputablePotentialUnifiers$fOutputableInstMatches $fDataClsInst ModDetails md_exportsmd_typesmd_insts md_fam_instsmd_rulesmd_annsmd_complete_matchesemptyModDetails ShHoleSubstUnitErr CloseUnitErrPackageFlagErr TrustFlagErrModuleSuggestionSuggestVisible SuggestHidden LookupResult LookupFoundLookupMultiple LookupHiddenLookupUnusableLookupNotFoundUnusableUnitReasonIgnoredWithFlagBrokenDependenciesCyclicDependenciesIgnoredDependenciesShadowedDependencies UnitInfoMap UnitDatabaseunitDatabasePathunitDatabaseUnits UnitState unitInfoMappreloadClosurepackageNameMapwireMap unwireMap preloadUnits explicitUnitshomeUnitDependsmoduleNameProvidersMappluginModuleNameProvidersMaprequirementContextallowVirtualUnitsPreloadUnitClosure ModuleOrigin ModHidden ModUnusable ModOrigin fromOrigUnitfromExposedReexportfromHiddenReexportfromPackageFlagemptyUnitState lookupUnit lookupUnit' lookupUnitId lookupUnitId'unsafeLookupUnitunsafeLookupUnitIdlookupPackageNamesearchPackageIdresolvePackageImport listUnitInfo initUnitsreadUnitDatabases getUnitDbRefsresolveUnitDatabasereadUnitDatabasepprFlag pprReason unwireUnitlookupModuleInAllUnitslookupModuleWithSuggestionslookupModulePackage!lookupPluginModuleWithSuggestionslistVisibleModuleNames closeUnitDepscloseUnitDeps'mayThrowUnitErrrequirementMergespprUnitIdForUserpprUnitInfoForUserpprUnitspprUnitsSimple pprModuleMap improveUnitinstUnitToUnitrenameHoleModulerenameHoleUnitrenameHoleModule'renameHoleUnit'instModuleToModuleimplicitPackageDeps$fMonoidUnitVisibility$fSemigroupUnitVisibility$fOutputableUnitVisibility$fOutputableUnitDatabase$fOutputableUnusableUnitReason$fMonoidModuleOrigin$fSemigroupModuleOrigin$fOutputableModuleOrigin$fOutputableUnitErr ImportAvailsimp_modsimp_direct_dep_modsimp_dep_direct_pkgsimp_trust_own_pkgimp_trust_pkgs imp_boot_mods imp_sig_mods imp_orphs imp_finstsUsagePackageModuleUsageHomeModule UsageFileUsageHomeModuleInterfaceUsageMergedRequirementusg_mod usg_mod_hashusg_safe usg_mod_name usg_unit_id usg_entities usg_exports usg_file_path usg_file_hashusg_file_labelusg_iface_hash Dependenciesdep_direct_modsdep_direct_pkgsdep_plugin_pkgs dep_sig_modsdep_trusted_pkgs dep_boot_mods dep_orphs dep_finstsmkDependenciesdep_orphs_updatedep_finsts_updatenoDependenciespprDeps$fBinaryDependencies $fBinaryUsage $fEqUsage$fEqDependencies LibrarySpecObjectsArchiveDLLDLLPath FrameworkSptEntryUnlinkedDotODotADotDLL CoreBindings LoadedBCOsBCOsObjFile LinkableSetLinkableLM linkableTimelinkableModulelinkableUnlinked LoadedPkgInfoloaded_pkg_uidloaded_pkg_hs_objsloaded_pkg_non_hs_objsloaded_pkg_trans_deps PkgsLoaded ClosureEnv LinkerEnv closure_envitbl_envaddr_env LoaderState linker_env bcos_loaded objs_loaded pkgs_loadedtemp_sosLoader loader_stateuninitializedLoadermodifyClosureEnvfilterLinkerEnvemptyClosureEnvextendClosureEnv mkLinkableSetunionLinkableSetisObjectLinkable linkableObjsisObjectisInterpretablenameOfObject_maybe nameOfObjectbyteCodeOfObject$fOutputableSptEntry$fOutputableUnlinked$fOutputableLinkable$fOutputableLibrarySpec$fOutputableLoadedPkgInfo IServInstance iservPipe iservProcessiservLookupSymbolCacheiservPendingFrees IServConfigiservConfProgram iservConfOptsiservConfProfilediservConfDynamic iservConfHookiservConfTrace IServState IServPending IServRunningIServInterpInstanceExternalInterpInternalInterpInterpinterpInstance interpLoaderInputFileBufferTargetId TargetModule TargetFileTargettargetIdtargetAllowObjCode targetUnitIdtargetContents pprTarget pprTargetId$fOutputableTargetId$fOutputableTarget $fEqTargetId FinderOptsfinder_importPathsfinder_lookupHomeInterfacesfinder_bypassHiFileCheck finder_waysfinder_enableSuggestionsfinder_workingDirectoryfinder_thisPackageNamefinder_hiddenModulesfinder_reexportedModules finder_hieDir finder_hieSuf finder_hiDir finder_hiSuffinder_dynHiSuffinder_objectDirfinder_objectSuffinder_dynObjectSuffinder_stubDir FindResultFound NoPackage FoundMultipleNotFoundfr_pathsfr_pkgfr_mods_hiddenfr_pkgs_hidden fr_unusablesfr_suggestionsInstalledFindResultInstalledFoundInstalledNoPackageInstalledNotFound FinderCache fcModuleCache fcFileCacheFinderCacheState$fShowFinderOptsshowSDocshowPprshowSDocForUser printForUser initLogFlags IOEnvFailureIOEnvfailM failWithMrunIOEnvfixMtryMtryAllMtryMostMunsafeInterleaveMuninterruptibleMaskM_ newMutVar writeMutVar readMutVar updMutVar updMutVarMatomicUpdMutVaratomicUpdMutVar'getEnvsetEnvupdEnv$fMonadPlusIOEnv$fAlternativeIOEnv$fHasModuleIOEnv$fHasLoggerIOEnv$fHasHooksIOEnv$fHasDynFlagsIOEnv$fApplicativeIOEnv$fMonadFailIOEnv $fMonadIOEnv$fMonadIOIOEnv$fFunctorIOEnv$fExceptionIOEnvFailure$fShowIOEnvFailure$fMonadThrowIOEnv$fMonadCatchIOEnv$fMonadMaskIOEnv$fMonadFixIOEnvtidyCbvInfoToptidyExpr tidyRules tidyBndrsprimOpIdallThePrimOpIds builtinRules caseRules$fMonadPlusRuleM$fAlternativeRuleM$fMonadFailRuleM $fMonadRuleM$fApplicativeRuleM$fFunctorRuleM OverLitTc$sel:ol_rebindable:OverLitTc$sel:ol_witness:OverLitTc$sel:ol_type:OverLitTc OverLitRn$sel:ol_rebindable:OverLitRn$sel:ol_from_fun:OverLitRn pprXOverLit overLitTypehsOverLitNeedsParenshsLitNeedsParens convertLit pmPprHsLit$fOutputableOverLitVal$fOutputableHsOverLit$fOutputableHsLit TcSpecPragSpecPrag LTcSpecPrag TcSpecPragsIsDefaultMethod SpecPragsAnnSigasDcolonasRestIdSigunIdSigABExportABEabe_polyabe_monoabe_wrap abe_pragsAbsBindsabs_tvs abs_ev_vars abs_exports abs_ev_binds abs_bindsabs_sig NHsValBindsLR NValBinds pprLHsBindspprLHsBindsForUser pprDeclListemptyLocalBindseqEmptyLocalBindsisEmptyValBindsemptyValBindsInemptyValBindsOut emptyLHsBindsisEmptyLHsBindsplusHsValBinds ppr_monobindpprTicksisEmptyIPBindsPRisEmptyIPBindsTc noSpecPrags hasSpecPragsisDefaultMethodppr_sighsSigDocextractSpecPragName pragBracketspragSrcBrackets pprVarSigpprSpecpprTcSpecPrags pprMinimalSig$fOutputableFixitySig$fOutputableSig$fOutputableIPBind$fOutputableHsIPBinds$fOutputableRecordPatSynField$fOutputablePatSynBind$fOutputableHsBindLR$fOutputableHsLocalBindsLR$fOutputableHsValBindsLR$fOutputableTcSpecPrag$fOutputableABExport$fDataTcSpecPrags$fDataTcSpecPrag $fDataAnnSig $fDataIdSigConPatTc cpt_arg_tyscpt_tvs cpt_dicts cpt_bindscpt_wrapHsPatExpansion HsPatExpanded XXPatGhcTcCoPat ExpansionPat co_cpt_wrap co_pat_inner co_pat_ty EpAnnSumPat sumPatParenssumPatVbarsBeforesumPatVbarsAfter hsRecFieldIdhsRecUpdFieldRdrhsRecUpdFieldIdhsRecUpdFieldOcc pprParendLPat pprConArgsmkPrefixConPatmkNilPat mkCharLitPat isBangedLPatlooksLazyPatBindisIrrefutableHsPat isSimplePatpatNeedsParensgParPatparenthesizePatcollectEvVarsPatscollectEvVarsPat$fOutputablePat$fOutputableHsFieldBind$fOutputableHsRecFields$fOutputableHsConPatTyArg$fOutputableHsPatExpansion$fDataHsPatExpansion$fDataEpAnnSumPatDataConBuilderPrefixDataConBuilderInfixDataConBuilder PatBuilder PatBuilderPat PatBuilderPar PatBuilderAppPatBuilderAppTypePatBuilderOpApp PatBuilderVarPatBuilderOverLit SumOrTupleSumTuple pprSumOrTuple$fOutputablePatBuilder$fOutputableDataConBuilder HsRuleAnn ra_tyanns ra_tmannsra_restHsRuleRnXViaStrategyPs DataDeclRn tcdDataCusktcdFVspartitionBindsAndSigs emptyRdrGroup emptyRnGrouphsGroupTopLevelFixitySigs appendGroupstyFamInstDeclNametyFamInstDeclLName tyClDeclLNamecountTyClDeclstcdName hsDeclHasCuskpp_vanilla_decl_headpprTyClDeclFlavourfamilyDeclLNamefamilyDeclNamefamResultKindSignatureresultVariableNamederivStrategyNamestandaloneKindSigName getConNamesgetRecConArgs_maybehsConDeclThetappDataDefnHeaderpprTyFamInstDeclpprDataFamInstFlavourpprHsFamInstLHSinstDeclDataFamInstsnewOrDataToFlavour anyLConIsGadtfoldDerivStrategymapDerivStrategyflattenRuleDeclspprFullRuleNameroleAnnotDeclName$fOutputableRoleAnnotDecl$fOutputableAnnDecl$fOutputableWarnDecl$fOutputableWarnDecls$fOutputableRuleBndr$fOutputableRuleDecl$fOutputableRuleDecls$fOutputableForeignExport$fOutputableForeignImport$fOutputableForeignDecl$fOutputableDefaultDecl$fOutputableDerivStrategy$fOutputableDerivDecl$fOutputableNewOrData$fOutputableInstDecl$fOutputableClsInstDecl$fOutputableDataFamInstDecl$fOutputableTyFamInstDecl$fOutputableConDecl$fOutputableStandaloneKindSig$fOutputableHsDataDefn$fOutputableDerivClauseTys$fOutputableHsDerivingClause$fOutputableFamilyDecl$fOutputableFunDep$fOutputableTyClGroup$fOutputableTyClDecl$fOutputableFamilyInfo$fOutputableSpliceDecoration$fOutputableSpliceDecl$fOutputableHsGroup$fOutputableHsDecl$fOutputableDocDecl$fOutputableXViaStrategyPs$fDataHsRuleAnn $fEqHsRuleAnn$fDataHsRuleRn$fDataDataDeclRnPendingTcSplicePendingRnSpliceUntypedSpliceFlavourUntypedExpSpliceUntypedPatSpliceUntypedTypeSpliceUntypedDeclSplice DelayedSplice XBindStmtTc xbstc_bindOpxbstc_boundResultTypexbstc_boundResultMult xbstc_failOp XBindStmtRn xbsrn_bindOp xbsrn_failOp RecStmtTc recS_bind_tyrecS_later_rets recS_rec_rets recS_ret_tyGrhsAnnga_vbarga_sep MatchGroupTc mg_arg_tys mg_res_ty mg_originCmdTopTcCmdSyntaxTable HsExpansion HsExpanded XXExprGhcTcWrapExpr ExpansionExpr ConLikeTcHsTick HsBinTickAnnsIfaiIfaiThenaiElse aiThenSemi aiElseSemi AnnProjectionapOpenapClose AnnFieldLabelafDotAnnExplicitSumaesOpen aesBarsBefore aesBarsAfteraesCloseEpAnnUnboundVarhsUnboundBackquotes hsUnboundHole EpAnnHsCase hsCaseAnnCase hsCaseAnnOfhsCaseAnnsRest HsBracketTc hsb_quotehsb_tyhsb_wrap hsb_splicesHsWrap SyntaxExprTcNoSyntaxExprTcsyn_expr syn_arg_wraps syn_res_wrap SyntaxExprRnNoSyntaxExprRn SyntaxExprGhc PostTcTable PostTcExprnoExpr noSyntaxExpr mkSyntaxExprmkRnSyntaxExpr tupArgPresent isQuietHsExprpprBinds ppr_lexprppr_exprppr_infix_exprppr_infix_expr_rnppr_infix_expr_tcppr_appspprDebugParendExprpprParendLExprhsExprNeedsParensgHsParparenthesizeHsExprstripParensLHsExprstripParensHsExprisAtomicHsExprpprLCmdpprCmd isQuietHsCmdppr_lcmdppr_cmd pprCmdArgisEmptyMatchGroupisSingletonMatchGroupmatchGroupArity hsLMatchPats pprMatchespprMatchpprGRHSspprGRHSpp_rhspprStmt pprBindStmtpprArgpprTransformStmt pprTransStmtpprBypprDo pprArrowExprppr_module_name_prefix ppr_do_stmtspprComppprQualspprPendingSplice ppr_quasi ppr_splice thBrackets thTyBracketsppr_with_pending_tc_splices pp_dotdotlamCaseKeywordpprExternalSrcLoc pprHsArrTypematchContextErrStringmatchArrowContextErrStringmatchDoContextErrStringpprMatchInCtxt pprStmtInCtxtmatchSeparatorpprMatchContextpprMatchContextNounpprMatchContextNounspprArrowMatchContextNounpprArrowMatchContextNounspprAStmtContextpprStmtContext pprStmtCatpprAHsDoFlavourpprHsDoFlavourprependQualifiedpprFieldLabelStringspprPrefixFastString$fWrapXRecGhcPassa$fOutputableDotFieldOcc!$fOutputableBndrFieldLabelStrings$fOutputableFieldLabelStrings$fOutputableHsStmtContext$fOutputableHsArrowMatchContext$fOutputableLamCaseVariant$fOutputableHsMatchContext$fOutputableArithSeqInfo$fOutputableHsQuote$fOutputableApplicativeArg$fOutputableStmtLR$fOutputableParStmtBlock$fOutputableMatch$fOutputableHsCmdTop$fOutputableHsCmd$fOutputableHsPragE$fOutputableHsExpr$fOutputableSyntaxExprRn$fOutputableSyntaxExprTc$fOutputableHsExpansion$fOutputableXXExprGhcTc$fOutputableGrhsAnn$fDataThModFinalizers$fDataDelayedSplice$fOutputablePendingRnSplice$fOutputablePendingTcSplice$fDataUntypedSpliceFlavour $fDataGrhsAnn$fDataMatchGroupTc$fDataHsExpansion $fDataAnnsIf$fDataAnnProjection$fDataAnnFieldLabel$fDataAnnExplicitSum$fDataEpAnnUnboundVar$fDataEpAnnHsCase $fDataHsWrap CollectPass collectXXPatcollectXXHsBindsLRcollectXSplicePat CollectFlagCollNoDictBindersCollWithDictBindersmkHsPar mkSimpleMatchunguardedGRHSs unguardedRHS mkMatchGroupmkLamCaseMatchGroup mkLocatedListmkHsApp mkHsAppWithmkHsApps mkHsAppsWith mkHsAppType mkHsAppTypesmkHsLammkHsLams mkHsCaseAlt nlHsTyApp nlHsTyAppsmkLHsParmkParPatnlParPat mkRecStmt mkHsIntegralmkHsFractional mkHsIsStringmkHsDo mkHsDoAnnsmkHsComp mkHsCompAnnsmkHsIf mkHsCmdIfmkNPat mkNPlusKPatemptyTransStmtmkTransformStmtmkTransformByStmtmkGroupUsingStmtmkGroupByUsingStmt mkLastStmt mkBodyStmt mkPsBindStmt mkRnBindStmt mkTcBindStmt unitRecStmtTc emptyRecStmtemptyRecStmtNameemptyRecStmtId mkLetStmt mkHsOpApp mkHsString mkHsStringFSmkHsStringPrimLitmkHsCharPrimLit mkConLikeTcnlHsVarnl_HsVar nlHsDataConnlHsLit nlHsIntLitnlVarPatnlLitPatnlHsAppnlHsSyntaxAppsnlHsApps nlHsVarApps nlConVarPatnlConVarPatName nlInfixConPatnlConPat nlConPatNamenlNullaryConPat nlWildConPat nlWildPat nlWildPatNamenlHsDo nlHsOpAppnlHsLamnlHsParnlHsIfnlHsCasenlList nlHsAppTy nlHsTyVar nlHsFunTy nlHsParTy nlHsTyConApp nlHsAppKindTymkLHsTupleExpr mkLHsVarTuple nlTuplePat missingTupArgmkBigLHsVarTup mkBigLHsTupmkBigLHsVarPatTupmkBigLHsPatTuphsTypeToHsSigTypehsTypeToHsSigWcType mkHsSigEnv mkClassOpSigs mkLHsWrapmkHsWrap mkHsWrapCo mkHsWrapCoR mkLHsWrapCo mkHsCmdWrap mkLHsCmdWrap mkHsWrapPat mkHsWrapPatCo mkHsDictLet mkFunBind mkTopFunBind mkHsVarBind mkVarBind mkPatSynBindisInfixFunBindspanHsLocaLBindsmkSimpleGeneratedFunBindmkPrefixFunRhsmkMatchisUnliftedHsBindisBangedHsBindcollectLocalBinderscollectHsIdBinderscollectHsValBinderscollectHsBindBinderscollectHsBindsBinderscollectHsBindListBinderscollectMethodBinderscollectLStmtsBinderscollectStmtsBinderscollectLStmtBinderscollectStmtBinderscollectPatBinderscollectPatsBindershsGroupBindershsTyClForeignBindershsLTyClDeclBindershsForeignDeclsBindershsPatSynSelectorsgetPatSynBindshsDataFamInstBinderslStmtsImplicitshsValBindsImplicits lPatImplicits$fCollectPassGhcPass perhapsAsPat$fOutputableGhcHint$fDataXViaStrategyPs$fDataXXPatGhcTc$fDataXXExprGhcTc$fEqIE$fEqIE0$fEqIE1$fDataIE $fDataIE0 $fDataIE1$fDataImportDecl$fDataImportDecl0$fDataImportDecl1$fDataAmbiguousFieldOcc$fDataAmbiguousFieldOcc0$fDataAmbiguousFieldOcc1$fDataFieldOcc$fDataFieldOcc0$fDataFieldOcc1$fDataConDeclField$fDataConDeclField0$fDataConDeclField1 $fDataHsArg$fDataHsScaled$fDataHsScaled0$fDataHsScaled1 $fDataHsArrow$fDataHsArrow0$fDataHsArrow1$fDataHsLinearArrowTokens$fDataHsLinearArrowTokens0$fDataHsLinearArrowTokens1 $fDataHsTyLit$fDataHsTyLit0$fDataHsTyLit1 $fDataHsType $fDataHsType0 $fDataHsType1$fDataHsTyVarBndr$fDataHsTyVarBndr0$fDataHsTyVarBndr1$fDataHsForAllTelescope$fDataHsForAllTelescope0$fDataHsForAllTelescope1$fDataHsPatSigType$fDataHsPatSigType0$fDataHsPatSigType1$fDataHsWildCardBndrs$fDataHsWildCardBndrs0$fDataHsWildCardBndrs1$fDataHsSigType$fDataHsSigType0$fDataHsSigType1$fDataHsOuterTyVarBndrs$fDataHsOuterTyVarBndrs0$fDataHsOuterTyVarBndrs1$fDataLHsQTyVars$fDataLHsQTyVars0$fDataLHsQTyVars1$fDataHsRecFields$fDataHsRecFields0$fDataHsRecFields1$fDataHsFieldBind$fDataHsConPatTyArg$fDataHsConPatTyArg0$fDataHsConPatTyArg1$fDataConPatTc $fDataPat $fDataPat0 $fDataPat1$fDataOverLitTc$fDataOverLitRn$fDataHsOverLit$fDataHsOverLit0$fDataHsOverLit1 $fDataHsLit $fDataHsLit0 $fDataHsLit1$fDataXBindStmtTc$fDataXBindStmtRn$fDataSyntaxExprTc$fDataSyntaxExprRn$fDataPendingTcSplice$fDataPendingRnSplice$fDataCmdTopTc$fDataArithSeqInfo$fDataArithSeqInfo0$fDataArithSeqInfo1$fDataHsBracketTc $fDataHsQuote$fDataHsQuote0$fDataHsQuote1$fDataHsUntypedSpliceResult$fDataHsUntypedSplice$fDataHsUntypedSplice0$fDataHsUntypedSplice1$fDataHsMatchContext$fDataHsMatchContext0$fDataHsMatchContext1$fDataHsDoFlavour$fDataHsArrowMatchContext$fDataHsStmtContext$fDataHsStmtContext0$fDataHsStmtContext1$fDataApplicativeArg$fDataApplicativeArg0$fDataApplicativeArg1$fDataParStmtBlock$fDataParStmtBlock0$fDataParStmtBlock1$fDataParStmtBlock2$fDataRecStmtTc $fDataStmtLR $fDataStmtLR0 $fDataStmtLR1 $fDataStmtLR2 $fDataStmtLR3 $fDataStmtLR4 $fDataStmtLR5 $fDataStmtLR6 $fDataGRHS $fDataGRHS0 $fDataGRHS1 $fDataGRHS2 $fDataGRHS3 $fDataGRHS4 $fDataGRHSs $fDataGRHSs0 $fDataGRHSs1 $fDataGRHSs2 $fDataGRHSs3 $fDataGRHSs4 $fDataMatch $fDataMatch0 $fDataMatch1 $fDataMatch2 $fDataMatch3 $fDataMatch4$fDataMatchGroup$fDataMatchGroup0$fDataMatchGroup1$fDataMatchGroup2$fDataMatchGroup3$fDataMatchGroup4$fDataHsCmdTop$fDataHsCmdTop0$fDataHsCmdTop1 $fDataHsCmd $fDataHsCmd0 $fDataHsCmd1$fDataHsTupArg$fDataHsTupArg0$fDataHsTupArg1 $fDataHsExpr $fDataHsExpr0 $fDataHsExpr1 $fDataHsPragE$fDataHsPragE0$fDataHsPragE1$fDataDotFieldOcc$fDataDotFieldOcc0$fDataDotFieldOcc1$fDataFieldLabelStrings$fDataFieldLabelStrings0$fDataFieldLabelStrings1$fDataRoleAnnotDecl$fDataRoleAnnotDecl0$fDataRoleAnnotDecl1 $fDataAnnDecl$fDataAnnDecl0$fDataAnnDecl1$fDataAnnProvenance$fDataAnnProvenance0$fDataAnnProvenance1$fDataWarnDecl$fDataWarnDecl0$fDataWarnDecl1$fDataWarnDecls$fDataWarnDecls0$fDataWarnDecls1$fDataRuleBndr$fDataRuleBndr0$fDataRuleBndr1$fDataRuleDecl$fDataRuleDecl0$fDataRuleDecl1$fDataRuleDecls$fDataRuleDecls0$fDataRuleDecls1$fDataForeignExport$fDataForeignExport0$fDataForeignExport1$fDataForeignImport$fDataForeignImport0$fDataForeignImport1$fDataForeignDecl$fDataForeignDecl0$fDataForeignDecl1$fDataDefaultDecl$fDataDefaultDecl0$fDataDefaultDecl1$fDataDerivStrategy$fDataDerivStrategy0$fDataDerivStrategy1$fDataDerivDecl$fDataDerivDecl0$fDataDerivDecl1$fDataInstDecl$fDataInstDecl0$fDataInstDecl1$fDataClsInstDecl$fDataClsInstDecl0$fDataClsInstDecl1 $fDataFamEqn $fDataFamEqn0 $fDataFamEqn1$fDataDataFamInstDecl$fDataDataFamInstDecl0$fDataDataFamInstDecl1$fDataTyFamInstDecl$fDataTyFamInstDecl0$fDataTyFamInstDecl1$fDataHsConDeclGADTDetails$fDataHsConDeclGADTDetails0$fDataHsConDeclGADTDetails1 $fDataConDecl$fDataConDecl0$fDataConDecl1$fDataDerivClauseTys$fDataDerivClauseTys0$fDataDerivClauseTys1$fDataHsDerivingClause$fDataHsDerivingClause0$fDataHsDerivingClause1$fDataHsDataDefn$fDataHsDataDefn0$fDataHsDataDefn1$fDataFamilyInfo$fDataFamilyInfo0$fDataFamilyInfo1$fDataInjectivityAnn$fDataInjectivityAnn0$fDataInjectivityAnn1$fDataFamilyDecl$fDataFamilyDecl0$fDataFamilyDecl1$fDataFamilyResultSig$fDataFamilyResultSig0$fDataFamilyResultSig1$fDataTyClGroup$fDataTyClGroup0$fDataTyClGroup1 $fDataFunDep $fDataFunDep0 $fDataFunDep1$fDataTyClDecl$fDataTyClDecl0$fDataTyClDecl1$fDataSpliceDecl$fDataSpliceDecl0$fDataSpliceDecl1 $fDataHsGroup$fDataHsGroup0$fDataHsGroup1 $fDataHsDecl $fDataHsDecl0 $fDataHsDecl1$fDataHsPatSynDir$fDataHsPatSynDir0$fDataHsPatSynDir1$fDataStandaloneKindSig$fDataStandaloneKindSig0$fDataStandaloneKindSig1$fDataFixitySig$fDataFixitySig0$fDataFixitySig1 $fDataSig $fDataSig0 $fDataSig1 $fDataIPBind $fDataIPBind0 $fDataIPBind1$fDataHsIPBinds$fDataHsIPBinds0$fDataHsIPBinds1$fDataPatSynBind$fDataPatSynBind0$fDataPatSynBind1$fDataPatSynBind2$fDataRecordPatSynField$fDataRecordPatSynField0$fDataRecordPatSynField1$fDataABExport$fDataAbsBinds$fDataHsBindLR$fDataHsBindLR0$fDataHsBindLR1$fDataHsBindLR2$fDataNHsValBindsLR$fDataNHsValBindsLR0$fDataNHsValBindsLR1$fDataHsValBindsLR$fDataHsValBindsLR0$fDataHsValBindsLR1$fDataHsValBindsLR2$fDataHsLocalBindsLR$fDataHsLocalBindsLR0$fDataHsLocalBindsLR1$fDataHsLocalBindsLR2HsParsedModule hpm_module hpm_src_files AnnsModuleam_mainam_decls XModulePshsmodAnn hsmodLayouthsmodDeprecMessagehsmodHaddockModHeader$fOutputableHsModule$fDataXModulePs$fDataAnnsModule$fEqAnnsModule$fDataHsModuleExpectedFunTyOriginExpectedFunTySyntaxOpExpectedFunTyViewPatExpectedFunTyArgExpectedFunTyMatchesExpectedFunTyLamExpectedFunTyLamCaseFRRArrowContext ArrowCmdResTy ArrowCmdAppArrowCmdArrApp ArrowCmdCaseArrowFunArgPos ArgPosInvis ArgPosVis RepPolyFunRepPolyWiredInRepPolyDataCon StmtOriginMonadComprehension DoNotation FRRRecordConFRRRecordUpdate FRRBinder FRRPatBind FRRPatSynArgFRRCaseFRRDataConPatArgFRRNoBindingResArg FRRTupleArgFRRTupleSection FRRUnboxedSum FRRBodyStmtFRRBodyStmtGuard FRRBindStmtFRRBindStmtGuardFRRArrowFRRExpectedFunTyfrr_type frr_context NakedScFlagNakedSc NotNakedSc GivenOrigin GivenSCOrigin OccurrenceOfOccurrenceOfRecSel AppOriginSpecPragOrigin TypeEqOrigin KindEqOrigin IPOccOriginOverLabelOrigin LiteralOrigin NegateOriginArithSeqOriginAssocFamPatOrigin SectionOriginHasFieldOrigin TupleOrigin ExprSigOrigin PatSigOrigin PatOriginProvCtxtOriginRecordUpdOrigin ViewPatOriginScOriginDerivClauseOrigin DerivOriginDCDerivOriginCoerceStandAloneDerivOrigin DefaultOriginDoOrigin DoPatOrigin MCompOriginMCompPatOrigin ProcOriginArrowCmdOrigin AnnOrigin FunDepOrigin1 FunDepOrigin2 InjTFOrigin1ExprHoleOriginTypeHoleOriginPatCheckOrigin ListOriginIfThenElseOrigin BracketOrigin StaticOriginShouldn'tHappenOrigin GhcBug20076InstProvidedOriginNonLinearPatternOriginUsageEnvironmentOfCycleBreakerOrigin FRROriginWantedSuperclassOriginInstanceSigOriginAmbiguityCheckOrigin uo_actual uo_expecteduo_thing uo_visible TyVarBndrsHsTyVarBndrsRn TypedThing HsTypeRnThing TypeThing HsExprRnThing NameThingSigSkol SigTypeSkol ForAllSkol DerivSkolInstSkol FamInstSkolPatSkolIPSkolRuleSkol InferSkol BracketSkolUnifyForAllSkol TyConSkol DataConSkol ReifySkolRuntimeUnkSkolArrowReboundIfSkolUnkSkolReportRedundantConstraintsNoRRCWantRRC UserTypeCtxt FunSigCtxt InfSigCtxt ExprSigCtxt KindSigCtxtStandaloneKindSigCtxt TypeAppCtxt ConArgCtxt TySynCtxt PatSynCtxt PatSigCtxt RuleSigCtxt ForSigCtxtDefaultDeclCtxt InstDeclCtxt SpecInstCtxt GenSigCtxtGhciCtxt ClassSCCtxt SigmaCtxt DataTyCtxtDerivClauseCtxtTyVarBndrKindCtxt DataKindCtxt TySynKindCtxtTyFamResKindCtxtreportRedundantConstraintsredundantConstraintsSpanpprUserTypeCtxt isSigMaybe unkSkolAnon mkSkolemInfo getSkolemInfo mkClsInstSkol pprSkolInfopprSigSkolInfoisVisibleOrigintoInvisibleOrigin isGivenOriginisWantedWantedFunDepOriginisWantedSuperclassOrigin lexprCtOrigin exprCtOriginmatchesCtOrigin grhssCtOrigin pprCtOriginisPushCallStackOrigincallStackOriginFSpprFixedRuntimeRepContextpprFRRArrowContextpprExpectedFunTyOriginpprExpectedFunTyHerald$fOutputableTypedThing$fOutputableTyVarBndrs$fOutputableNakedScFlag$fOutputableStmtOrigin$fOutputableRepPolyFun$fOutputableFRRArrowContext"$fOutputableFixedRuntimeRepContext$fOutputableCtOrigin$fOutputableSkolemInfoAnon$fOutputableSkolemInfo$fUniquableSkolemInfo$fEqUserTypeCtxt$fEqReportRedundantConstraintsCtLoc ctl_originctl_env ctl_t_or_k ctl_depth SubGoalDepth CtFlavourRole CtFlavourGivenWanted RewriterSet CtEvidenceCtGivenCtWanted ctev_pred ctev_evarctev_loc ctev_destctev_rewritersTcEvDest EvVarDestHoleDest UserGiven HasGivenEqs NoGivenEqs LocalGivenEqs MaybeGivenEqs ImplicStatus IC_Solved IC_InsolubleIC_BadTelescope IC_Unsolvedics_dead ImplicationImplicic_tclvlic_infoic_skolsic_given ic_given_eqsic_warn_inaccessibleic_env ic_wantedic_binds ic_need_inner ic_need_outer ic_statusWantedConstraintsWC wc_simplewc_impl wc_errorsCheckTyEqProblemCheckTyEqResult CtIrredReasonIrredShapeReasonNonCanonicalReason ReprEqReasonShapeMismatchReasonAbstractTyConReasonNotConcreteReasonNonConcreteTyConNonConcretisableTyVar ContainsCastContainsForallContainsCoercionTyNotConcreteErrorNCE_FRRnce_locnce_frr_origin nce_reasonsHoleSortExprHoleTypeHoleConstraintHoleHole hole_sorthole_occhole_tyhole_loc DelayedErrorDE_HoleDE_NotConcreteQCInstQCIqci_evqci_tvsqci_pred qci_pend_scCanEqLHSTyVarLHSTyFamLHSCtCDictCan CIrredCanCEqCan CNonCanonical CQuantCancc_evcc_class cc_tyargs cc_pend_sc cc_reasoncc_lhscc_rhs cc_eq_relCtsXiisInsolubleReasoncteOKcterHasNoProblemcteImpredicative cteTypeFamilycteInsolubleOccurscteSolubleOccurs cteProblemcterHasProblemcterHasOnlyProblemcterRemoveProblemcterHasOccursCheckcterClearOccursCheckcterSetOccursCheckSoluble cterFromKindmkNonCanonicalmkNonCanonicalCt mkIrredCtmkGivens ctEvidencectLocctOriginctPred ctRewritersctEvIdwantedEvId_maybemkTcEqPredLikeEv ctFlavourctEqRelcanEqLHS_maybe canEqLHSType canEqLHSKind eqCanEqLHS tyCoVarsOfCttyCoVarsOfCtEvtyCoVarsOfCtListtyCoVarsOfCtEvList tyCoVarsOfCtstyCoVarsOfCtsListtyCoVarsOfCtEvsList tyCoVarsOfWCtyCoVarsOfWCList isGivenLoc isWantedCt isGivenCtgetUserTypeErrorMsgisUserTypeErrorisPendingScDictpendingScDict_maybependingScInst_maybesuperClassesMightHelpgetPendingWantedScssingleCtandCts listToCtsctsEltsconsCtssnocCts extendCtsList andManyCtsemptyCts isEmptyCtspprCtsemptyWC mkSimpleWC mkImplicWC isEmptyWC isSolvedWCandWCunionsWC addSimples addImplics addInsolsaddHolesaddNotConcreteErroraddDelayedErrorsdropMisleadingisSolvedStatusisInsolubleStatusinsolubleImplicnonDefaultableTyVarsOfWC insolubleWCinsolubleWantedCt insolubleEqCt insolubleCtisOutOfScopeHoleimplicationPrototypegetUserGivensFromImplicscheckTelescopeSkolcheckImplicationInvariants pprEvVars pprEvVarThetapprEvVarWithTypewrapTypectEvPredctEvLoc ctEvOrigin ctEvEqRelctEvRolectEvTerm ctEvRewritersctEvExpr ctEvCoercionctEvEvId ctEvUniquetcEvDestUnique setCtEvLocarisesFromGivenssetCtEvPredTypeisWantedisGivenemptyRewriterSetisEmptyRewriterSetaddRewriterSetrewriterSetFromCorewriterSetFromTyperewriterSetFromTypes ctEvFlavourctEvFlavourRole ctFlavourRole eqCanRewriteeqCanRewriteFRinitialSubGoalDepthbumpSubGoalDepthmaxSubGoalDepthsubGoalDepthExceeded mkKindLoc toKindLoc mkGivenLocctLocEnv ctLocLevel ctLocDepth ctLocOrigin ctLocSpanctLocTypeOrKind_maybe setCtLocSpanbumpCtLocDepthsetCtLocOriginupdateCtLocOrigin setCtLocEnvpprCtLoc$fOutputableCanEqLHS$fOutputableHoleSort$fOutputableCheckTyEqResult$fMonoidCheckTyEqResult$fSemigroupCheckTyEqResult$fOutputableCtIrredReason$fOutputableImplicStatus$fMonoidHasGivenEqs$fSemigroupHasGivenEqs$fOutputableHasGivenEqs$fOutputableTcEvDest$fOutputableCtFlavour$fOutputableCtEvidence$fOutputableQCInst$fOutputableCt$fOutputableNotConcreteError$fOutputableHole$fOutputableDelayedError$fOutputableImplication$fOutputableWantedConstraints$fEqSubGoalDepth$fOrdSubGoalDepth$fOutputableSubGoalDepth $fEqCtFlavour$fOutputableRewriterSet$fSemigroupRewriterSet$fMonoidRewriterSet$fEqHasGivenEqs EqualCtListFunEqMapDictMapTcAppMapisEmptyTcAppMap emptyTcAppMap insertTcApp alterTcAppfilterTcAppMap tcAppMapToBag foldTcAppMap emptyDictMapfindDictfindDictsByClassdelDictaddDictaddDictsByClass filterDictspartitionDicts dictsToBag foldDicts emptyFunEqs findFunEqfindFunEqsByTyCon foldFunEqs insertFunEqaddToEqualCtListfilterEqualCtListInertEqs InertCansIC inert_eqs inert_funeqs inert_dicts inert_instsinert_safehask inert_irredsinert_given_eq_lvlinert_given_eqsIS inert_cansinert_cycle_breakersinert_famapp_cacheinert_solved_dictsCycleBreakerVarStackWorkListWLwl_eqswl_rest wl_implicsappendWorkList workListSizeextendWorkListEqextendWorkListNonEqextendWorkListImplicextendWorkListCtextendWorkListCtsisEmptyWorkList emptyWorkListselectWorkItem emptyInert foldTyEqsdelEqfindEqpartitionInertEqspartitionFunEqs addInertItemkickOutRewritableLHSnoGivenNewtypeReprEqsnoMatchableGivenDictsmightEqualLaterprohibitedSuperClassSolvepushCycleBreakerVarStackinsertCycleBreakerBindingforAllCycleBreakerBindings_$fOutputableWorkList$fOutputableInertCans$fOutputableInertSet PmAltConSetPmAltCon PmAltConLikePmAltLit PmEqualityEqualDisjointPossiblyOverlap PmLitValuePmLitIntPmLitRat PmLitChar PmLitString PmLitOverInt PmLitOverRatPmLitOverStringPmLit pm_lit_ty pm_lit_valResidualCompleteMatchesRCM rcm_vanilla rcm_pragmasBotInfoIsBotIsNotBotMaybeBot PmAltConAppPACApaca_conpaca_tvspaca_idsVarInfoVIvi_idvi_posvi_negvi_botvi_rcmTmStateTmStts_factsts_repsts_dirtyTyStateTyStty_st_n ty_st_inertNablasMkNablasNablaMkNabla nabla_ty_st nabla_tm_st initNablasgetRcmisRcmInitialised lookupVarInfolookupVarInfoNT trvVarInfo lookupRefutslookupSolution pmLitTypeemptyPmAltConSetisEmptyPmAltConSetelemPmAltConSetextendPmAltConSetpmAltConSetElems eqPmAltCon pmAltConTypeisPmAltConMatchStrictpmAltConImplBangsliteralToPmLit negatePmLit overloadPmLitpmLitAsStringLitcoreExprAsPmLit$fOutputableTyState$fOutputableBotInfo#$fOutputableResidualCompleteMatches$fOutputablePmLitValue$fOutputablePmLit$fOutputablePmEquality $fEqPmLit$fOutputablePmAltCon $fEqPmAltCon$fOutputablePmAltConApp$fOutputablePmAltConSet$fOutputableVarInfo$fOutputableTmState$fOutputableNabla$fMonoidNablas$fSemigroupNablas$fOutputableNablas$fEqPmEquality$fShowPmEquality $fEqBotInfoPostPre CheckResultcr_retcr_uncov cr_approxRedSetsrs_covrs_divrs_bangs Precision ApproximatePrecise PmPatBind PmEmptyCasepe_varPmGRHSpg_grdspg_rhsPmGRHSspgs_lcls pgs_grhssPmMatchpm_patspm_grhss PmMatchGroupGrdVecSrcInfoPmGrdPmConPmBangPmLetpm_id pm_con_con pm_con_tvs pm_con_dicts pm_con_args_pm_loc _pm_let_expr$fOutputableSrcInfo$fOutputablePmGrd$fOutputableGrdVec$fOutputablePmGRHS$fOutputablePmGRHSs$fOutputablePmMatch$fOutputablePmMatchGroup$fOutputablePmEmptyCase$fOutputablePmPatBind$fMonoidPrecision$fSemigroupPrecision$fOutputablePrecision$fOutputableRedSets$fOutputableCheckResult$fFunctorCheckResult $fEqPrecision$fShowPrecision pprUncoveredCgGuts cg_module cg_tyconscg_bindscg_ccs cg_foreigncg_foreign_files cg_dep_pkgs cg_hpc_info cg_modBreakscg_spt_entriesModGuts mg_module mg_hsc_srcmg_loc mg_exportsmg_deps mg_usages mg_used_th mg_rdr_env mg_fix_envmg_tcsmg_insts mg_fam_insts mg_patsynsmg_rulesmg_binds mg_foreignmg_foreign_filesmg_warnsmg_annsmg_complete_matches mg_hpc_info mg_modBreaks mg_inst_envmg_fam_inst_envmg_boot_exportsmg_safe_haskell mg_trust_pkgmg_docsmg_mnwibRuleEnvre_local_rules re_home_rules re_eps_rulesre_visible_orphsRuleBasemkRule mkSpecRule roughTopNamespprRulesForUserextendRuleInfo addRuleInfoaddIdSpecialisations addRulesToId rulesOfBinds emptyRuleBase mkRuleBaseextendRuleBaseList pprRuleBase mkRuleEnvupdExternalPackageRules updLocalRules addLocalRules emptyRuleEnvgetRules lookupRuleruleCheckProgramWhetherHasFamInstWhetherHasOrphans IfaceExport ModIface_ModIface mi_module mi_sig_of mi_hsc_srcmi_deps mi_usages mi_exports mi_used_th mi_fixitiesmi_warnsmi_annsmi_declsmi_extra_decls mi_globalsmi_insts mi_fam_instsmi_rulesmi_hpcmi_trust mi_trust_pkgmi_complete_matchesmi_docs mi_final_exts mi_ext_fields mi_src_hashIfaceBackendExts IfaceDeclExtsModIfaceBackend mi_iface_hash mi_mod_hash mi_flag_hash mi_opt_hash mi_hpc_hashmi_plugin_hash mi_orphan mi_finsts mi_exp_hashmi_orphan_hash mi_warn_fn mi_fix_fn mi_hash_fnPartialModIfacemi_bootmi_mnwibmi_fixmi_semantic_module mi_free_holesrenameFreeHolesemptyPartialModIfaceemptyFullModIfacemkIfaceHashCacheemptyIfaceHashCache forceModIface$fNFDataModIfaceBackend$fNFDataModIface_$fBinaryModIface_EpsStats n_ifaces_in n_decls_in n_decls_out n_rules_in n_rules_out n_insts_in n_insts_outExternalPackageStateEPS eps_is_booteps_PITeps_free_holeseps_PTE eps_inst_enveps_fam_inst_env eps_rule_base eps_ann_enveps_complete_matcheseps_mod_fam_inst_env eps_statsExternalUnitCacheeuc_epsPackageIfaceTablePackageCompleteMatchesPackageFamInstEnvPackageInstEnvPackageRuleBasePackageTypeEnvemptyPackageIfaceTableinitExternalUnitCacheeucEPSinitExternalPackageState addEpsInStatsHomePackageTableHomeModLinkablehomeMod_bytecodehomeMod_object HomeModInfohm_iface hm_details hm_linkablehomeModInfoByteCodehomeModInfoObjectemptyHomeModInfoLinkable justBytecode justObjectsbytecodeAndObjectsemptyHomePackageTable lookupHptlookupHptDirectlyeltsHpt filterHptallHptanyHptmapHpt delFromHptaddToHptaddHomeModInfoToHpt addListToHpt listToHpt listHMIToHptlookupHptByModulepprHPT$fOutputableHomeModLinkable UnitEnvGraph unitEnv_graphUnitEnvGraphKey HomeUnitGraph HomeUnitEnvhomeUnitEnv_unitshomeUnitEnv_unit_dbshomeUnitEnv_dflagshomeUnitEnv_hpthomeUnitEnv_home_unitUnitEnvue_epsue_current_unitue_home_unit_graph ue_platform ue_nameverueEPS initUnitEnvunsafeGetHomeUnitupdateHpt_lazy updateHpt updateHugue_transitiveHomeDepspreloadUnitsInfo'preloadUnitsInfo mkHomeUnitEnvisUnitEnvInstalledModulelookupHugByModulehugEltsaddHomeModInfoToHug lookupHugunitEnv_insertunitEnv_deleteunitEnv_adjustunitEnv_mapWithKey unitEnv_newunitEnv_singleton unitEnv_mapunitEnv_memberunitEnv_lookup_maybeunitEnv_lookup unitEnv_keys unitEnv_elts unitEnv_hptsunitEnv_foldWithKey unitEnv_unionue_units ue_setUnits ue_unit_dbs ue_setUnitDbsue_hpt ue_setFlagsue_setUnitFlags ue_unitFlags ue_homeUnitue_unsafeHomeUnitue_unitHomeUnitue_all_home_unit_idsue_currentHomeUnitEnvue_setActiveUnitue_currentUnitue_findHomeUnitEnvue_updateHomeUnitEnvue_renameUnitIdassertUnitEnvInvariant$fOutputableHomeUnitEnv$fOutputableUnitEnvGraph$fFunctorUnitEnvGraph$fFoldableUnitEnvGraph$fTraversableUnitEnvGraph mkNamePprCtx mkQualModule mkQualPackagepkgQualHscBackendAction HscUpdate HscRecomp hscs_gutshscs_mod_locationhscs_partial_ifacehscs_old_iface_hashHscRecompStatus HscUpToDateHscRecompNeeded$fOutputableHscBackendActionInteractiveImportIIDeclIIModuleInteractiveContext ic_dflags ic_mod_index ic_imports ic_tythings ic_gre_cache ic_instances ic_fix_env ic_default ic_resumeic_monad ic_int_printic_cwd ic_pluginsemptyInteractiveContext icReaderEnvicInteractiveModule icInScopeTTs icNamePprCtxextendInteractiveContextextendInteractiveContextWithIdssetInteractivePrintNamereplaceImportEnvsubstInteractiveContext$fOutputableInteractiveImportinteractiveInScope ModSummaryms_mod ms_hsc_src ms_location ms_hs_hash ms_obj_datems_dyn_obj_date ms_iface_date ms_hie_date ms_srcimpsms_textual_impsms_ghc_prim_import ms_parsed_mod ms_hspp_file ms_hspp_opts ms_hspp_buf ms_unitidms_installed_mod ms_mod_namems_impsms_plugin_impsms_home_srcimps ms_home_imps msHsFilePath msHiFilePathmsDynHiFilePath msObjFilePathmsDynObjFilePath isBootSummaryms_mnwibmsDeps findTarget$fOutputableModSummary ModNodeKey SummaryNode ModuleGraphModNodeKeyWithUid mnkModuleName mnkUnitIdNodeKey NodeKey_UnitNodeKey_Module NodeKey_LinkModuleGraphNodeInstantiationNode ModuleNodeLinkNodemoduleGraphNodeModulemoduleGraphNodeModSummoduleGraphNodeUnitId nodeKeyUnitIdnodeKeyModNamemapMGunionMG mgTransDepsmgModSummariesmgModSummaries'mgLookupModuleemptyMGisTemplateHaskellOrQQNonBootextendMG extendMGInst extendMG' mkModuleGraphfilterToposortToModules showModMsgsummaryNodeSummarynodeDependenciesmoduleGraphNodes mkNodeKeymsKey$fOutputableModNodeKeyWithUid$fOutputableNodeKey$fOrdModuleGraphNode$fEqModuleGraphNode$fOutputableModuleGraphNode$fFunctorNodeMap$fTraversableNodeMap$fFoldableNodeMap $fEqNodeKey $fOrdNodeKey$fEqModNodeKeyWithUid$fOrdModNodeKeyWithUidFileHeaderPragmaType OptionsPrag IncludePrag LanguagePragDocOptionsPragTransLayoutReasonTransLayout_WhereTransLayout_PipeCmmParserErrorCmmUnknownPrimitiveCmmUnknownMacroCmmUnknownCConvCmmUnrecognisedSafetyCmmUnrecognisedHintLexErrLexErrorLexUnknownPragmaLexErrorInPragmaLexNumEscapeRangeLexStringCharLitLexStringCharLitEOFLexUnterminatedCommentLexUnterminatedOptionsLexUnterminatedQQ LexErrKindLexErrKind_EOFLexErrKind_UTF8LexErrKind_CharNumUnderscoreReasonNumUnderscore_IntegralNumUnderscore_FloatPsErrInPatDetails PEIP_NegApp PEIP_TypeArgsPEIP_RecPatternPEIP_OtherPatDetails ParseContextis_infixincomplete_do_blockPatIncompleteDoBlockYesIncompleteDoBlockNoIncompleteDoBlockPatIsRecursiveYesPatIsRecursiveNoPatIsRecursivePsErrParseDetailsped_th_enabledped_do_in_last_100ped_mdo_in_last_100ped_pat_syn_enabledped_pattern_parsed PsMessagePsUnknownMessagePsHeaderMessagePsWarnBidirectionalFormatCharsPsWarnTransitionalLayoutPsWarnUnrecognisedPragmaPsWarnMisplacedPragmaPsWarnHaddockInvalidPosPsWarnHaddockIgnoreMulti#PsWarnOperatorWhitespaceExtConflictPsErrLambdaCasePsErrEmptyLambdaPsErrNumUnderscoresPsErrPrimStringInvalidCharPsErrMissingBlock PsErrLexer PsErrSuffixAT PsErrParse PsErrCmmLexerPsErrUnsupportedBoxedSumExprPsErrUnsupportedBoxedSumPat#PsErrUnexpectedQualifiedConstructorPsErrTupleSectionInPatPsErrIllegalBangPatternPsErrOpFewArgsPsErrImportQualifiedTwicePsErrImportPostQualifiedPsErrIllegalExplicitNamespacePsErrVarForTyConPsErrIllegalPatSynExportPsErrMalformedEntityStringPsErrDotsInRecordUpdatePsErrPrecedenceOutOfRangePsErrOverloadedRecordDotInvalid%PsErrOverloadedRecordUpdateNotEnabled,PsErrOverloadedRecordUpdateNoQualifiedFieldsPsErrInvalidDataConPsErrInvalidInfixDataCon!PsErrIllegalPromotionQuoteDataConPsErrUnpackDataConPsErrUnexpectedKindAppInDataConPsErrInvalidRecordConPsErrIllegalUnboxedStringInPat#PsErrIllegalUnboxedFloatingLitInPatPsErrDoNotationInPatPsErrIfThenElseInPatPsErrLambdaCaseInPatPsErrCaseInPat PsErrLetInPatPsErrLambdaInPatPsErrArrowExprInPatPsErrArrowCmdInPatPsErrArrowCmdInExprPsErrViewPatInExprPsErrTypeAppWithoutSpacePsErrLazyPatWithoutSpacePsErrBangPatWithoutSpacePsErrUnallowedPragmaPsErrQualifiedDoInCmdPsErrInvalidInfixHolePsErrSemiColonsInCondExprPsErrSemiColonsInCondCmdPsErrAtInPatPosPsErrLambdaCmdInFunAppCmdPsErrCaseCmdInFunAppCmdPsErrLambdaCaseCmdInFunAppCmdPsErrIfCmdInFunAppCmdPsErrLetCmdInFunAppCmdPsErrDoCmdInFunAppCmdPsErrDoInFunAppExprPsErrMDoInFunAppExprPsErrLambdaInFunAppExprPsErrCaseInFunAppExprPsErrLambdaCaseInFunAppExprPsErrLetInFunAppExprPsErrIfInFunAppExprPsErrProcInFunAppExprPsErrMalformedTyOrClDeclPsErrIllegalWhereInDataDeclPsErrIllegalDataTypeContextPsErrParseErrorOnInputPsErrMalformedDeclPsErrUnexpectedTypeAppInDeclPsErrNotADataConPsErrRecordSyntaxInPatSynDeclPsErrEmptyWhereInPatSynDecl!PsErrInvalidWhereBindInPatSynDecl"PsErrNoSingleWhereBindInPatSynDeclPsErrDeclSpliceNotAtTopLevelPsErrInferredTypeVarNotAllowed+PsErrMultipleNamesInStandaloneKindSignaturePsErrIllegalImportBundleFormPsErrUnexpectedTypeInDeclPsErrExpectedHyphenPsErrSpaceInSCCPsErrInvalidPackageName PsErrInvalidRuleActivationMarkerPsErrLinearFunctionPsErrMultiWayIfPsErrExplicitForallPsErrIllegalQualifiedDoPsErrCmmParser#PsErrIllegalTraditionalRecordSyntaxPsErrParseErrorInCmd PsErrInPatPsErrParseRightOpSectionInPat"PsErrIllegalGadtRecordMultiplicityPsErrInvalidCApiImportPsErrMultipleConForNewtypePsErrUnicodeCharLooksLikePsErrParseLanguagePragmaPsErrUnsupportedExtPsErrParseOptionsPragmaPsErrUnknownOptionsPragmaPsError PsWarningnoParseContextincompleteDoBlockfromParseContext$fGenericPsMessage$fShowLexErrKind$fEqLexErrKind$fOrdLexErrKind$fShowNumUnderscoreReason$fEqNumUnderscoreReason$fOrdNumUnderscoreReason$fEqParseContext$fEqPatIncompleteDoBlock$fGenericPsHeaderMessageUnexpectedStatementEmptyStatementGroupErrReasonEmptyStmtsGroupInParallelComp"EmptyStmtsGroupInTransformListCompEmptyStmtsGroupInDoNotationEmptyStmtsGroupInArrowNotationUnrepresentableTypeDescrLinearInvisibleArgumentCoercionsInTypesLookupTHInstNameErrReasonNoMatchesFoundCouldNotDetermineInstance SplicePhaseSplicePhase_RunSplicePhase_CompileAndLinkMatchArgBadMatchesMatchArgMatchesmatchArgFirstMatchmatchArgBadMatchesMatchArgsContext EquationArgs PatternArgs HsDocContext TypeSigCtxStandaloneKindSigCtxPatCtxSpecInstSigCtxDefaultDeclCtxForeignDeclCtx DerivDeclCtxRuleCtx TyDataCtxTySynCtx TyFamilyCtx FamPatCtx ConDeclCtx ClassDeclCtxExprWithTySigCtxTypBrCtx HsTypeCtx HsTypePatCtxGHCiCtx SpliceTypeCtxClassInstanceCtx GenericCtxFixedRuntimeRepErrorInfoFRR_Infofrr_info_originfrr_info_not_concrete PromotionErrTyConPEClassPE FamDataConPEConstrainedDataConPEPatSynPE RecDataConPETermVariablePE NoDataKindsDCRelevantBindingsrelevantBindingNamesAndTys ranOutOfFuel ValidHoleFitsholeFitsrefinementFitsFitsMbSuppressedFitsfitsfitsSuppressedPotentialInstancesmatchesunifiers ImportError MissingModuleModulesDoNotExport CoercibleMsg UnknownRolesTyConIsAbstractOutOfScopeNewtypeConstructor HoleErrorOutOfScopeHoleHoleFitDispConfigHFDCshowWrap showWrapVarsshowTypeshowProv showMatchesNotInScopeError NotInScope NoExactNameSameNameMissingBindingNoTopLevelBindingUnknownSubordinate WhenMatchingExpectedActualInfoExpectedActual!ExpectedActualAfterTySynExpansion ea_expected ea_actualea_expanded_expectedea_expanded_actual AmbiguityInfo AmbiguityNonInjectiveTyFamlead_with_ambig_msg ambig_tyvars SameOccInfoSameOccsameOcc_same_pkg sameOcc_lhs sameOcc_rhs TyVarInfo thisTyVarthisTyVarIsUntouchableotherTy CND_ExtraCannotUnifyVariableReasonCannotUnifyWithPolytype OccursCheck SkolemEscapeDifferentTyVarsRepresentationalEqoccursCheckInterestingTyVarsoccursCheckAmbiguityInfos MismatchEANoEAEA mismatch_mbEA MismatchMsg BasicMismatch KindMismatchTypeEqMismatchCouldNotDeduce mismatch_ea mismatch_item mismatch_ty1 mismatch_ty2mismatch_whenMatchingmismatch_mb_same_occkmismatch_whatkmismatch_expectedkmismatch_actualteq_mismatch_ppr_explicit_kindsteq_mismatch_itemteq_mismatch_ty1teq_mismatch_ty2teq_mismatch_expectedteq_mismatch_actualteq_mismatch_whatteq_mb_same_occcnd_user_givens cnd_wanted cnd_extraTcSolverReportMsg BadTelescope UserTypeErrorReportHoleErrorUntouchableVariableCannotUnifyVariableMismatchFixedRuntimeRepErrorBlockedEqualityExpectingMoreArgumentsUnboundImplicitParamsAmbiguityPreventsSolvingCtCannotResolveInstanceOverlappingInstances UnsafeOverlapuntouchableTyVaruntouchableTyVarImplication mismatchMsgcannotUnifyReasonmismatchTyVarInfomismatchAmbiguityInfomismatchCoercibleInfocannotResolve_itemcannotResolve_unifierscannotResolve_candidatescannotResolve_importErrorscannotResolve_suggestionscannotResolve_relevant_bindingsoverlappingInstances_itemoverlappingInstances_matchesoverlappingInstances_unifiersunsafeOverlap_itemunsafeOverlap_matchunsafeOverlapped ErrorItemEIei_pred ei_evdest ei_flavourei_loc ei_m_reason ei_suppressSolverReportErrCtxtCECcec_enclcec_tidy cec_bindscec_defer_type_errorscec_expr_holescec_type_holescec_out_of_scope_holescec_warn_redundantcec_expand_syns cec_suppressSolverReportWithCtxt reportContext reportContentSolverReportSupplementarySupplementaryBindingsSupplementaryHoleFitsSupplementaryCts SolverReportsr_important_msgsr_supplementarysr_hintsExported IsNotExported IsExportedMissingSignatureMissingTopLevelBindingSigMissingPatSynSigMissingTyConKindSig!AssociatedTyNotParamOverLastTyVar$YesAssociatedTyNotParamOverLastTyVar#NoAssociatedTyNotParamOverLastTyVarAssociatedTyLastVarInKindYesAssocTyLastVarInKindNoAssocTyLastVarInKindHasAssociatedDataFamInsts YesHasAdfs NoHasAdfs"SoleExtraConstraintWildcardAllowed%SoleExtraConstraintWildcardNotAllowedBadAnonWildcardContextWildcardNotLastInConstraint!ExtraConstraintWildcardNotAllowedWildcardsNotAllowedAtAll HasWildcardYesHasWildcard NoHasWildcardDeriveGenericsErrReason*DerivErrGenericsMustNotHaveDatatypeContext%DerivErrGenericsMustNotHaveExoticArgs$DerivErrGenericsMustBeVanillaDataCon&DerivErrGenericsMustHaveSomeTypeParams'DerivErrGenericsMustNotHaveExistentialsDerivErrGenericsWrongArgKindDeriveInstanceBadConstructorDerivErrBadConExistentialDerivErrBadConCovariantDerivErrBadConFunTypesDerivErrBadConWrongArgDerivErrBadConIsGADTDerivErrBadConHasExistentialsDerivErrBadConHasConstraintsDerivErrBadConHasHigherRankTypeDeriveInstanceErrReasonDerivErrNotWellKindedDerivErrSafeHaskellGenericInstDerivErrDerivingViaWrongKindDerivErrNoEtaReduceDerivErrBootFileFoundDerivErrDataConsNotAllInScopeDerivErrGNDUsedOnDataDerivErrNullaryClassesDerivErrLastArgMustBeAppDerivErrNoFamilyInstanceDerivErrNotStockDeriveableDerivErrHasAssociatedDatatypes!DerivErrNewtypeNonDeriveableClassDerivErrCannotEtaReduceEnoughDerivErrOnlyAnyClassDeriveableDerivErrNotDeriveableDerivErrNotAClassDerivErrNoConstructorsDerivErrLangExtRequiredDerivErrDunnoHowToDeriveForTypeDerivErrMustBeEnumType%DerivErrMustHaveExactlyOneConstructorDerivErrMustHaveSomeParametersDerivErrMustNotHaveClassContextDerivErrBadConstructorDerivErrGenericsDerivErrEnumOrProductDeriveAnyClassEnabledYesDeriveAnyClassEnabledNoDeriveAnyClassEnabledUsingGeneralizedNewtypeDerivingYesGeneralizedNewtypeDerivingNoGeneralizedNewtypeDerivingSuggestPartialTypeSignaturesYesSuggestPartialTypeSignaturesNoSuggestPartialTypeSignaturesNotClosedReasonNotLetBoundReason NotTypeClosed NotClosedAllowedDataResKind AnyTYPEKind AnyBoxedKind LiftedKindDataSort DataDeclSortDataInstanceSortDataFamilySortSuggestUnliftedTypesSuggestUnliftedNewtypesSuggestUnliftedDatatypesSuggestUndecidableInstancesYesSuggestUndecidableInstacesNoSuggestUndecidableInstacesHasKinds YesHasKinds NoHasKindsInjectivityErrReasonInjErrRhsBareTyVarInjErrRhsCannotBeATypeFamInjErrRhsOverlapInjErrCannotInferFromRhsIllegalNewtypeReasonDoesNotHaveSingleField IsNonLinearIsGADTHasConstructorContextHasExistentialTyVarHasStrictnessAnnotationFixedRuntimeRepProvenanceFixedRuntimeRepDataConFieldFixedRuntimeRepPatSynSigArgFixedRuntimeRepPatSynSigResShadowedNameProvenanceShadowedNameProvenanceLocalShadowedNameProvenanceGlobalRecordFieldPartRecordFieldConstructorRecordFieldPatternRecordFieldUpdate ArgOrResultResultUnsupportedCallConventionStdCallConvUnsupportedPrimCallConvUnsupportedJavaScriptCallConvUnsupportedExpectedBackendsTHDeclDescriptor InstanceDecl WhereClause LetBinding LetExpressionClssDecl IllegalDeclsIllegalFamDeclsConversionFailReasonIllegalOccNameSumAltArityExceeded IllegalSumAltIllegalSumArity MalformedTypeIllegalLastStatementKindSigsOnlyAllowedOnGADTsIllegalDeclarationCannotMixGADTConsWith98ConsEmptyStmtListInDoBlockNonVarInInfixExprMultiWayIfWithoutAltsCasesExprWithoutAltsImplicitParamsWithOtherBindsInvalidCCallImpent RecGadtNoCons GadtNoConsInvalidTypeInstanceHeaderInvalidTyFamInstLHSInvalidImplicitParamBindingDefaultDataInstDeclFunBindLacksEquationsThingBeingConvertedConvDecConvExpConvPatConvTypeRunSpliceFailReasonConversionFailTypeDataForbidsTypeDataForbidsDatatypeContextsTypeDataForbidsLabelledFields$TypeDataForbidsStrictnessAnnotationsTypeDataForbidsDerivingClauses TcRnMessageTcRnUnknownMessageTcRnMessageWithInfoTcRnWithHsDocContextTcRnSolverReportTcRnRedundantConstraintsTcRnInaccessibleCode"TcRnTypeDoesNotHaveFixedRuntimeRepTcRnImplicitLiftTcRnUnusedPatternBindsTcRnDodgyImportsTcRnDodgyExportsTcRnMissingImportListTcRnUnsafeDueToPluginTcRnModMissingRealSrcSpanTcRnIdNotExportedFromModuleSigTcRnIdNotExportedFromLocalSigTcRnShadowedNameTcRnDuplicateWarningDeclsTcRnSimplifierTooManyIterationsTcRnIllegalPatSynDeclTcRnLinearPatSynTcRnEmptyRecordUpdateTcRnIllegalFieldPunningTcRnIllegalWildcardsInRecordTcRnIllegalWildcardInTypeTcRnDuplicateFieldNameTcRnIllegalViewPatternTcRnCharLiteralOutOfRange!TcRnIllegalWildcardsInConstructorTcRnIgnoringAnnotationsTcRnAnnotationInSafeHaskellTcRnInvalidTypeApplicationTcRnTagToEnumMissingValArgTcRnTagToEnumUnspecifiedResTyTcRnTagToEnumResTyNotAnEnumTcRnTagToEnumResTyTypeData(TcRnArrowIfThenElsePredDependsOnResultTyTcRnIllegalHsBootFileDeclTcRnRecursivePatternSynonymTcRnPartialTypeSigTyVarMismatchTcRnPartialTypeSigBadQuantifierTcRnMissingSignatureTcRnPolymorphicBinderMissingSigTcRnOverloadedSigTcRnTupleConstraintInstTcRnAbstractClassInstTcRnNoClassInstHeadTcRnUserTypeErrorTcRnConstraintInKind TcRnUnboxedTupleOrSumTypeFuncArgTcRnLinearFuncInKindTcRnForAllEscapeErrorTcRnVDQInTermTypeTcRnBadQuantPredHeadTcRnIllegalTupleConstraintTcRnNonTypeVarArgInConstraintTcRnIllegalImplicitParam"TcRnIllegalConstraintSynonymOfKindTcRnIllegalClassInstTcRnOversaturatedVisibleKindArgTcRnBadAssociatedTypeTcRnForAllRankErrTcRnMonomorphicBindingsTcRnFunDepConflictTcRnDupInstanceDeclsTcRnConflictingFamInstDeclsTcRnFamInstNotInjectiveTcRnBangOnUnliftedTypeTcRnLazyBangOnUnliftedTypeTcRnMultipleDefaultDeclarationsTcRnBadDefaultTypeTcRnPatSynBundledWithNonDataConTcRnPatSynBundledWithWrongTypeTcRnDupeModuleExportTcRnExportedModNotImportedTcRnNullExportedModuleTcRnMissingExportListTcRnExportHiddenComponentsTcRnDuplicateExportTcRnExportedParentChildMismatchTcRnConflictingExportsTcRnAmbiguousFieldTcRnMissingFieldsTcRnFieldUpdateInvalidTypeTcRnNoConstructorHasAllFieldsTcRnMixedSelectorsTcRnMissingStrictFieldsTcRnNoPossibleParentForFieldsTcRnBadOverloadedRecordUpdateTcRnStaticFormNotClosedTcRnSpecialClassInstTcRnUselessTypeableTcRnDerivingDefaultsTcRnNonUnaryTypeclassConstraintTcRnPartialTypeSignaturesTcRnCannotDeriveInstanceTcRnLazyGADTPatternTcRnArrowProcGADTPatternTcRnTypeEqualityOutOfScope!TcRnTypeEqualityRequiresOperatorsTcRnIllegalTypeOperatorTcRnIllegalTypeOperatorDeclTcRnGADTMonoLocalBindsTcRnNotInScopeTcRnUntickedPromotedThingTcRnIllegalBuiltinSyntaxTcRnWarnDefaultingTcRnForeignImportPrimExtNotSetTcRnForeignImportPrimSafeAnn TcRnForeignFunctionImportAsValue TcRnFunPtrImportWithoutAmpersandTcRnIllegalForeignDeclBackendTcRnUnsupportedCallConvTcRnIllegalForeignTypeTcRnInvalidCIdentifierTcRnExpectedValueIdTcRnNotARecordSelectorTcRnRecSelectorEscapedTyVarTcRnPatSynNotBidirectionalTcRnSplicePolymorphicLocalVarTcRnIllegalDerivingItemTcRnUnexpectedAnnotationTcRnIllegalRecordSyntaxTcRnUnexpectedTypeSpliceTcRnInvalidVisibleKindArgumentTcRnTooManyBindersTcRnDifferentNamesForTyVarTcRnInvalidReturnKindTcRnClassKindNotConstraintTcRnUnpromotableThingTcRnMatchesHaveDiffNumArgs!TcRnCannotBindScopedTyVarInPatSigTcRnCannotBindTyVarsInPatBindTcRnTooManyTyArgsInConPatternTcRnMultipleInlinePragmasTcRnUnexpectedPragmas!TcRnNonOverloadedSpecialisePragmaTcRnSpecialiseNotVisibleTcRnNameByTemplateHaskellQuoteTcRnIllegalBindingOfBuiltInTcRnPragmaWarningTcRnIllegalHsigDefaultMethodsTcRnBadGenericMethodTcRnWarningMinimalDefIncomplete&TcRnDefaultMethodForPragmaLacksBinding%TcRnIgnoreSpecialisePragmaOnDefMethodTcRnBadMethodErr+TcRnNoExplicitAssocTypeOrDefaultDeclarationTcRnIllegalNewtypeTcRnIllegalTypeDataTcRnTypeDataForbidsTcRnTypedTHWithPolyTypeTcRnSpliceThrewExceptionTcRnInvalidTopDeclTcRnNonExactNameTcRnAddInvalidCorePluginTcRnAddDocToNonLocalDefnTcRnFailedToLookupThInstNameTcRnCannotReifyInstanceTcRnCannotReifyOutOfScopeThing TcRnCannotReifyThingNotInTypeEnvTcRnNoRolesAssociatedWithThingTcRnCannotRepresentTypeTcRnRunSpliceFailureTcRnReportCustomQuasiErrorTcRnInterfaceLookupErrorTcRnUnsatisfiedMinimalDefTcRnMisplacedInstSigTcRnBadBootFamInstDeclTcRnIllegalFamilyInstanceTcRnMissingClassAssocTcRnBadFamInstDeclTcRnNotOpenFamilyTcRnNoRebindableSyntaxRecordDotTcRnNoFieldPunsRecordDotTcRnIllegalStaticExpressionTcRnIllegalStaticFormInSplice%TcRnListComprehensionDuplicateBindingTcRnEmptyStmtsGroupTcRnLastStmtNotExpr TcRnUnexpectedStatementInContextTcRnIllegalTupleSection$TcRnIllegalImplicitParameterBindingsTcRnSectionWithoutParenthesesTcRnLoopySuperclassSolveTcRnCannotDefaultConcretepragma_warning_occpragma_warning_msgpragma_warning_import_modpragma_warning_defined_modbadMethodErrClassNamebadMethodErrMethodNameTcRnMessageDetailedErrInfoerrInfoContexterrInfoSupplementarymkTcRnUnknownMessagepprFixedRuntimeRepProvenancehasKindssuggestUndecidableInstances ppDataSortsuggestPartialTypeSignaturesusingGeneralizedNewtypeDerivingderiveAnyClassEnabled hasWildcardhasAssociatedDataFamInstsassociatedTyLastVarInKind!associatedTyNotParamOverLastTyVar getUserGivenserrorItemOriginerrorItemEqRelerrorItemCtLoc errorItemPreddiscardProvCtxtGivensmkBasicMismatchMsgmkPlainMismatchMsgmkTcRnNotInScopenoValidHoleFitspprRelevantBindings pprPECategory peCategory$fOutputableTypeDataForbids$fOutputableExported$fOutputableErrorItem$fOutputablePromotionErr$fGenericTcRnMessage$fGenericTcRnMessageDetailed%$fGenericEmptyStatementGroupErrReason$fGenericSolverReportWithCtxt$fGenericTcSolverReportMsg"$fGenericCannotUnifyVariableReason$fGenericNotInScopeError$fGenericMismatchMsg$fGenericWhenMatching $fGenericDeriveInstanceErrReason%$fEqAssociatedTyNotParamOverLastTyVar$fEqAssociatedTyLastVarInKind$fEqHasAssociatedDataFamInsts$fEqHasWildcard$fEqDeriveAnyClassEnabled#$fEqUsingGeneralizedNewtypeDeriving"$fShowSuggestPartialTypeSignatures $fEqSuggestPartialTypeSignatures!$fShowSuggestUndecidableInstances$fEqSuggestUndecidableInstances$fShowHasKinds $fEqHasKinds$fGenericIllegalNewtypeReason$fEqUnsupportedCallConvention$fGenericRunSpliceFailReason$fGenericConversionFailReason$fGenericTypeDataForbids BindsTypeUnliftedTypeBinds StrictBindsExhaustivityCheckTypeNegLiteralExtEnabledYesUsingNegLiteralsNotUsingNegLiteralsThRejectionReasonThAmbiguousRecordUpdatesThAbstractClosedTypeFamilyThForeignLabelThForeignExportThMinimalPragmas ThSCCPragmasThNoUserInlineThExoticFormOfTypeThAmbiguousRecordSelectorsThMonadComprehensionSyntax ThCostCentresThExpressionFormThExoticStatementThExoticLiteralThExoticPatternThGuardedLambdasThNegativeOverloadedPatternsThHaddockDocumentationThWarningAndDeprecationPragmasThSplicesWithinDeclBracketsThNonLinearDataConDsArgNum DsMessageDsUnknownMessageDsEmptyEnumerationDsIdentitiesFoundDsOverflowedLiteralsDsRedundantBangPatternsDsOverlappingPatternsDsInaccessibleRhsDsNonExhaustivePatternsDsTopLevelBindsNotAllowed)DsUselessSpecialiseForClassMethodSelector&DsUselessSpecialiseForNoInlineFunction#DsMultiplicityCoercionsNotSupported DsOrphanRuleDsRuleLhsTooComplicatedDsRuleIgnoredDueToConstructorDsRuleBindersNotBound#DsLazyPatCantBindVarsOfUnliftedTypeDsNotYetHandledByTHDsAggregatedViewExpressionsDsUnbangedStrictPatterns"DsCannotMixPolyAndUnliftedBindings DsWrongDoBindDsUnusedDoBind"DsRecBindsNotAllowedForUnliftedTysDsRuleMightInlineFirstDsAnotherRuleMightFireFirstMaxPmCheckModelsMaxUncoveredPatternsMaxBoundMinBoundnegLiteralExtEnabled$fGenericDsMessageBuildingCabalPackageYesBuildingCabalPackageNoBuildingCabalPackageDriverMessageOptspsDiagnosticOpts DriverMessageDriverUnknownMessageDriverPsHeaderMessageDriverMissingHomeModulesDriverUnknownReexportedModulesDriverUnknownHiddenModulesDriverUnusedPackagesDriverUnnecessarySourceImports!DriverDuplicatedModuleDeclarationDriverModuleNotFoundDriverFileModuleNameMismatchDriverFileNotFound DriverStaticPointersNotSupportedDriverBackpackModuleNotFoundDriverUserDefinedRuleIgnoredDriverMixedSafetyImportDriverCannotLoadInterfaceFileDriverInferredSafeModule&DriverMarkedTrustworthyButInferredSafeDriverInferredSafeImportDriverCannotImportUnsafeModuleDriverMissingSafeHaskellModeDriverPackageNotTrusted&DriverCannotImportFromUntrustedPackageDriverRedirectedNoMainDriverHomePackagesNotClosedDriverMessagesGhcMessageOpts psMessageOpts tcMessageOpts dsMessageOptsdriverMessageOpts GhcMessage GhcPsMessageGhcTcRnMessage GhcDsMessageGhcDriverMessageGhcUnknownMessageWarnMsg ErrorMessagesWarningMessagesghcUnknownMessagehoistTcRnMessagehoistDsMessagecheckBuildingCabalPackage$fGenericGhcMessage$fEqBuildingCabalPackage$fGenericDriverMessageHscEnv hsc_dflags hsc_targets hsc_mod_graphhsc_IChsc_NChsc_FChsc_type_env_vars hsc_interp hsc_plugins hsc_unit_env hsc_logger hsc_hooks hsc_tmpfshsc_llvm_config$fContainsDynFlagsHscEnv$fHasLoggerHsc$fHasDynFlagsHsc $fFunctorHsc$fApplicativeHsc $fMonadHsc $fMonadIOHscconstructorCode$fGDiagnosticCodeM1$fGDiagnosticCode:+:$fGDiagnosticCodeM10$fHasTypetyorigf$fHasTypetyorigM1$fConstructorCodeconfJust$fConstructorCodeconfJust0+$fHasTypeProdMaybeSymbolTYPEtyNothingorigfg($fHasTypeProdMaybeSymbolTYPEtyJustorigfg$fHasTypetyorig:*:$fConstructorCodeconfNothingpsHeaderMessageDiagnosticpsHeaderMessageReasonpsHeaderMessageHintssuggestParensAndBlockArgspp_unexpected_fun_appparse_error_in_pat forallSympprFileHeaderPragmaType$fDiagnosticPsMessageTcRnMessageOptstcOptsShowContext!pprTypeDoesNotHaveFixedRuntimeRep pprScopeErrortidySkolemInfotidySkolemInfoAnoninHsDocContextpprHsDocContext$fOutputableImportError$fOutputableSolverReportErrCtxt$fDiagnosticTcRnMessage badMonadBindpprEqn pprContextdots$fDiagnosticDsMessage$fDiagnosticDriverMessage$fDiagnosticGhcMessagemkSrcErrsrcErrorMessages throwErrors throwOneErrorhandleSourceError$fExceptionSourceError$fShowSourceError printMessageshandleFlagWarningsprintOrThrowDiagnosticsmkDriverPsHeaderMessage initDiagOptsinitPrintConfiginitPsMessageOptsinitTcMessageOptsinitDsMessageOptsinitDriverMessageOptsrunHscrunHsc'mkInteractiveHscEnvrunInteractiveHsc hsc_home_unithsc_home_unit_maybe hsc_unitshsc_HPThsc_HUEhsc_HUGhsc_all_home_unit_idshscUpdateHPT_lazy hscUpdateHPT hscUpdateHUGhscEPShptCompleteSigshptAllInstanceshptInstancesBelowhptRuleshptAnns hptAllThingshptSomeThingsBelowUsprepareAnnotations lookupTypelookupIfaceByModule mainModIs hscInterphscUpdateLoggerFlagshscUpdateFlags hscSetFlagshscSetActiveHomeUnithscSetActiveUnitIdhscActiveUnitId discardICCoreMfloatOutLambdasfloatOutConstantsfloatOutOverSatAppsfloatToTopLevelOnlyrunCoreMliftIOWithCount getHscEnv initRuleEnvgetExternalRuleBase getNamePprCtx getSrcSpanM addSimplCount getUniqMaskmapDynFlagsCoreMdropSimplCountgetInteractiveContextgetPackageFamInstEnvgetAnnotationsgetFirstAnnotationsmsgputMsgSfatalErrorMsgSdebugTraceMsgS$fOutputableFloatOutSwitches$fHasModuleCoreM$fHasLoggerCoreM$fHasDynFlagsCoreM$fMonadIOCoreM$fMonadUniqueCoreM$fMonadPlusCoreM$fAlternativeCoreM$fApplicativeCoreM $fMonadCoreM$fFunctorCoreM ccfModuleName ccfFuncName NamePatternPChar PWildcardPEndaddCallerCostCentres$fBinaryNamePattern$fOutputableNamePattern$fBinaryCallerCcFilter$fOutputableCallerCcFilter WarnErrLoggerGhcTunGhcTGhcunGhcGhcMonad getSession setSession withSessiongetSessionDynFlags modifySessionmodifySessionMwithTempSession modifyLogger pushLogHookM popLogHookMputMsgM putLogMsgM withTimingMlogDiagnostics reflectGhcreifyGhcliftGhcTprintExceptiondefaultWarnErrLogger $fGhcMonadGhc$fHasLoggerGhc$fHasDynFlagsGhc$fGhcMonadGhcT$fHasLoggerGhcT$fHasDynFlagsGhcT $fFunctorGhcT$fApplicativeGhcT $fMonadGhcT$fMonadFailGhcT$fMonadFixGhcT$fMonadThrowGhcT$fMonadCatchGhcT$fMonadMaskGhcT $fMonadIOGhcT $fFunctorGhc$fApplicativeGhc $fMonadGhc$fMonadFailGhc $fMonadFixGhc$fMonadThrowGhc$fMonadCatchGhc$fMonadMaskGhc $fMonadIOGhcMetaHook MetaResult MetaRequestMetaEMetaPMetaTMetaDMetaAW metaRequestE metaRequestP metaRequestT metaRequestD metaRequestAW CmmTickScope GlobalScopeSubScope CombinedScope ForeignTarget PrimTarget CmmReturnInfo CmmMayReturnCmmNeverReturnsForeignConvention ConventionNativeDirectCallNativeNodeCall NativeReturnSlowGCUpdFrameOffset CmmFormal CmmActualCmmNodeCmmEntry CmmCommentCmmTick CmmUnwind CmmAssignCmmStoreCmmUnsafeForeignCall CmmBranch CmmCondBranch CmmSwitchCmmCallCmmForeignCallcml_predcml_true cml_false cml_likely cml_targetcml_cont cml_args_regscml_args cml_ret_args cml_ret_offtgtresargsret_argsret_offintrblforeignTargetHints wrapRecExpmapExp mapExpDeep wrapRecExpMmapExpM mapExpDeepM wrapRecExpffoldExp foldExpDeep mapSuccessorsmapCollectSuccessorsisTickSubScopecombineTickScopes$fOutputableConvention$fOutputableCmmReturnInfo$fOutputableForeignConvention$fUserOfRegsrForeignTarget"$fOutputablePPlatformForeignTarget$fOutputableCmmTickScope$fOrdCmmTickScope$fEqCmmTickScope$fDefinerOfRegsGlobalRegCmmNode$fDefinerOfRegsLocalRegCmmNode$fUserOfRegsGlobalRegCmmNode$fUserOfRegsLocalRegCmmNode$fNonLocalCmmNode$fOutputablePPlatformGraph'$fOutputablePPlatformBlock$fOutputablePPlatformBlock0$fOutputablePPlatformBlock1$fOutputablePPlatformBlock2$fOutputablePPlatformCmmNode$fEqForeignTarget$fEqForeignConvention$fEqCmmReturnInfo$fEqConvention $fEqCmmNode ListGraph GenBasicBlock BasicBlock RawCmmStatics CmmStatics GenCmmStatics CmmStaticsRaw CmmStatic CmmStaticLitCmmUninitialised CmmString CmmFileEmbedSectionSectionProtectionReadWriteSectionReadOnlySectionWriteProtectedSection SectionTypeText ReadOnlyDataRelocatableReadOnlyDataUninitialisedData InitArray FiniArrayCString OtherSection ProfilingInfoNoProfilingInfo CmmInfoTablecit_lblcit_repcit_profcit_srtcit_clo CmmStackInfo StackInfo arg_space do_layout CmmTopInfoTopInfo info_tbls stack_info GenCmmGraphCmmGraphg_entryg_graph RawCmmDecl CmmDataDecl CmmDeclSRTsCmmDecl GenCmmDeclCmmProcCmmData RawCmmGroup CmmGroupSRTsCmmGroup GenCmmGroup CmmProgramcmmDataDeclCmmDecl toBlockMap revPostorder toBlockList topInfoTablesectionProtectionblockId pprBBlock pprCmmGroup pprStatic pprSection $fOutputablePPlatformGenCmmGraph$fOutputableCmmStackInfo!$fOutputablePPlatformCmmInfoTable$fOutputablePPlatformCmmTopInfo$fOutputablePPlatformGenCmmDecl$fOutputableCmmStatic$fOutputablePPlatformCmmStatic"$fOutputablePPlatformGenCmmStatics$fOutputablePenvGenBasicBlock$fOutputableGenBasicBlock$fOutputablePenvListGraph$fOutputableListGraph$fFunctorListGraph$fFunctorGenBasicBlock$fFunctorGenCmmDecl$fEqSectionProtection$fShowSectionType$fEqCmmInfoTable$fOrdCmmInfoTable$fEqProfilingInfo$fOrdProfilingInfo TopEnvConfigte_history_sizete_tick_factorSimplMinitSmpl traceSmpl getSimplRulesnewId newJoinId getSimplCounttick checkedTickfreeTick$fMonadIOSimplM$fHasLoggerSimplM$fMonadUniqueSimplM $fMonadSimplM$fApplicativeSimplM$fFunctorSimplM JoinFloats JoinFloat LetFloatsSimplSRDoneExDoneIdContEx SimplFloats sfLetFloats sfJoinFloats sfInScope FloatEnable FloatDisabledFloatNestedOnly FloatEnabled SimplModesm_phasesm_namessm_rules sm_inline sm_eta_expandsm_cast_swizzle sm_uf_opts sm_case_case sm_pre_inlinesm_float_enablesm_do_eta_reduction sm_arity_opts sm_rule_optssm_case_folding sm_case_mergesm_co_opt_optsSimplEnvseMode seFamEnvs seTvSubst seCvSubst seIdSubstseRecIds seInScope seCaseDepth seArityOpts seCaseCase seCaseFolding seCaseMerge seCastSwizzleseDoEtaReduction seEtaExpand seFloatEnableseInlineseNamesseOptCoercionOptssePedanticBottomssePhase sePlatform sePreInline seRuleOptsseRulesseUnfoldingOptssmPedanticBottoms smPlatform emptyFloats isEmptyFloats pprSimplEnv mkSimplEnvupdMode bumpCaseDepth getInScope setInScopeSetsetInScopeFromEsetInScopeFromFaddNewInScopeIds modifyInScopeenterRecGroupRHSs zapSubstEnv setSubstEnvmkContExdoFloatFromRhsemptyLetFloatsisEmptyLetFloatsemptyJoinFloatsisEmptyJoinFloats unitLetFloat unitJoinFloat mkFloatBind extendFloats addLetFloats addJoinFloats addFloats addLetFlts letFloatBinds addJoinFlts mkRecFloatswrapJoinFloatsXwrapJoinFloatsgetTopFloatBinds mapLetFloatssubstId lookupRecBndr simplBinders simplBindersimplNonRecBndr simplRecBndrssimplNonRecJoinBndrsimplRecJoinBndrsgetSubst$fOutputableSimplMode$fOutputableSimplSR$fOutputableFloatFlag$fOutputableLetFloats$fOutputableSimplFloatsValArgTyArgCastByas_dmdas_arg as_hole_ty as_arg_ty RewriteCallTryRules TryInlining TryNothingArgInfoai_funai_args ai_rewriteai_enclai_dmdsai_discsDupFlagNoDup SimplifiedOkToDupFromWhatFromLetFromBeta StaticEnv SimplContStopCastIt ApplyToVal ApplyToTySelect StrictBind StrictArgTickItsc_dup sc_hole_tysc_argsc_envsc_cont sc_arg_tysc_bndrsc_altssc_fromsc_bodysc_fun sc_fun_ty BindContextBC_LetBC_JoinbindContextLevel isSimplified addValArgTo addTyArgTo addCastToisStrictArgInfoargInfoAppArgspushSimplifiedArgspushSimplifiedRevArgs argInfoExpr mkBoringStop mkRhsStop mkLazyArgStop contIsRhs contIsStop contIsDupable contIsTrivialcontResultType contHoleTypecontHoleScaling countArgscontArgs mkArgInfolazyArgContextinterestingCallContextupdModeForStableUnfoldingsupdModeForRulesactiveUnfoldinggetUnfoldingInRuleMatch activeRulepreInlineUnconditionallypostInlineUnconditionally rebuildLamtryEtaExpandRhswantEtaExpansionabstractFloats prepareAltsmkCase isExitJoinId$fOutputableDupFlag$fOutputableArgSpec$fOutputableArgInfo$fOutputableSimplCont simplTopBinds simplExpr simplImpRules LintConfig l_diagOpts l_platforml_flagsl_vars WarnsAndErrsStaticPtrCheck AllowAnywhereAllowAtTopLevelRejectEverywhere LintFlagsLFlf_check_global_idslf_check_inline_loop_breakerslf_check_static_ptrslf_report_unsat_synslf_check_linearitylf_check_fixed_repLintPassResultConfig lpr_diagOpts lpr_platformlpr_makeLintFlagslpr_showLintWarnings lpr_passPprlpr_localsInScope EndPassConfigep_dumpCoreSizesep_lintPassResult ep_namePprCtx ep_dumpFlag ep_prettyPassep_passDetails endPassIOdumpPassResultlintPassResultdisplayLintResultslintCoreBindings' lintUnfoldinglintExpr lintAxioms lintAnnots$fMonadFailLintM $fMonadLintM$fApplicativeLintM$fFunctorLintM$fEqStaticPtrCheck SimplifyOptsso_dump_core_sizes so_iterationsso_modeso_pass_result_cfg so_hpt_rulesso_top_env_cfgSimplifyExprOpts se_fam_instse_modese_top_env_cfg simplifyExpr simplifyPgmCoreToDoCoreDoSimplifyCoreDoPluginPassCoreDoFloatInwardsCoreDoFloatOutwardsCoreLiberateCaseCoreDoPrintCoreCoreDoStaticArgsCoreDoCallArity CoreDoExitify CoreDoDemand CoreDoCprCoreDoWorkerWrapperCoreDoSpecialisingCoreDoSpecConstrCoreCSECoreDoRuleCheck CoreDoNothing CoreDoPasses CoreDesugarCoreDesugarOptCoreTidyCorePrepCoreAddCallerCcsCoreAddLateCcsCorePluginPass bindsOnlyPasspprPassDetails$fOutputableCoreToDoendPassendPassHscEnvIOlintCoreBindingsinitEndPassConfiginitLintPassResultConfiginitLintConfigTHDocsDocLocDeclDocArgDocInstDoc ModuleDoc RoleAnnotEnvDefaultingPlugin dePluginInit dePluginRun dePluginStopFillDefaultingDefaultingPluginResultDefaultingProposaldeProposalTyVardeProposalCandidates deProposalCtsTcPluginRewriteResultTcPluginNoRewriteTcPluginRewriteTotcPluginReductiontcRewriterNewWantedsTcPluginSolveResulttcPluginInsolubleCtstcPluginSolvedCtstcPluginNewCtsTcPlugin tcPluginInit tcPluginSolvetcPluginRewrite tcPluginStop TcPluginM runTcPluginMTcPluginRewriterTcPluginSolver TcPatSynInfoTPSI patsig_namepatsig_implicit_bndrspatsig_univ_bndrs patsig_reqpatsig_ex_bndrs patsig_provpatsig_body_ty TcIdSigInstTISI sig_inst_sigsig_inst_skolssig_inst_theta sig_inst_tau sig_inst_wcs sig_inst_wcx CompleteSig PartialSigsig_bndrsig_ctxtsig_loc psig_name psig_hs_ty TcSigInfoTcIdSig TcPatSynSigTcSigFun WhereFrom ImportByUserImportBySystemImportByPlugin ClosedTypeIdRhsNames IsGroupClosed IdBindingInfo NotLetBound ClosedLet NonClosedLetAGlobalATcIdATyVarATcTyCon APromotionErrtct_idtct_info ArrowCtxt NoArrowCtxtThLevel PendingStuffRnPendingUntypedRnPendingTyped TcPendingThStageSplice RunSpliceCompBrack SpliceTypeTypedUntypedTcBinderTcIdBndrTcIdBndr_ExpTypeTcTvBndr TcBinderStackTcIdSetTcIdTcRef ThBindEnv TcTypeEnvErrCtxttcl_loctcl_ctxttcl_in_gen_code tcl_tclvl tcl_th_ctxt tcl_th_bndrstcl_arrow_ctxttcl_rdrtcl_env tcl_usage tcl_bndrstcl_lietcl_errs NoSelfBootSelfBootsb_mdssb_tcs RecFieldEnvtcg_modtcg_semantic_modtcg_src tcg_rdr_env tcg_default tcg_fix_env tcg_field_env tcg_type_env tcg_inst_envtcg_fam_inst_env tcg_ann_env tcg_exports tcg_importstcg_dus tcg_used_grestcg_keep tcg_th_usedtcg_th_splice_usedtcg_th_needed_deps tcg_dfun_n tcg_mergedtcg_rn_exportstcg_rn_imports tcg_rn_declstcg_dependent_filestcg_th_topdeclstcg_th_foreign_filestcg_th_topnamestcg_th_modfinalizerstcg_th_coreplugins tcg_th_statetcg_th_remote_state tcg_th_docs tcg_ev_binds tcg_tr_module tcg_bindstcg_sigs tcg_imp_specs tcg_warnstcg_annstcg_tcs tcg_ksigs tcg_insts tcg_fam_insts tcg_rules tcg_fords tcg_patsyns tcg_doc_hdrtcg_hpc tcg_self_boottcg_maintcg_safe_infertcg_safe_infer_reasonstcg_tc_plugin_solverstcg_tc_plugin_rewriterstcg_defaulting_pluginstcg_hf_plugins tcg_top_loc tcg_static_wctcg_complete_matches tcg_cc_sttcg_next_wrapper_numFrontendResultFrontendTypecheckIfLclEnvif_modif_bootif_loc if_nsubstif_implicits_env if_tv_env if_id_envIfGblEnvif_doc if_rec_types RewriteEnvREre_loc re_flavour re_eq_rel re_rewritersEnvenv_topenv_umenv_gblenv_lclTcMRnMIfLIfGIfMTcRnTcRnIf NameShape ns_mod_name ns_exportsns_map TcPluginOkTcPluginContradictiontcVisibleOrphanMods bootExports pushErrCtxtpushErrCtxtSameOriginremoveBindingShadowing getPlatformtopStage topAnnStagetopSpliceStageimpLevel outerLevelthLeveltcTyThingTyCon_maybepprTcTyThingCategorytcTyThingCategory mkModDepsemptyImportAvailsplusImportAvails isPartialSighasCompleteSigunsafeTcPluginTcMmkRoleAnnotEnvemptyRoleAnnotEnvlookupRoleAnnot getRoleAnnots lintGblEnv$fContainsModuleEnv$fContainsLoggerEnv$fContainsHooksEnv$fContainsDynFlagsEnv$fHasOccNameTcBinder$fOutputableTcBinder$fOutputableThStage$fOutputableIdBindingInfo$fOutputableTcTyThing$fOutputableWhereFrom$fOutputableTcIdSigInfo$fOutputableTcIdSigInst$fOutputableTcPatSynInfo$fOutputableTcSigInfo$fOutputableDefaultingProposal$fContainsModuleTcGblEnv$fFunctorTcPluginM$fApplicativeTcPluginM$fMonadTcPluginM$fMonadFailTcPluginM $fEqDocLoc $fOrdDocLocHoleFitPluginR hfPluginInit hfPluginRun hfPluginStop candPlugin fitPlugin FitPlugin CandPlugin TypedHoleth_relevant_cts th_implicsth_holepprHoleFitCandhfIsLcl$fOutputableTypedHole$fOrdHoleFitCandidate$fHasOccNameHoleFitCandidate$fNamedThingHoleFitCandidate$fOutputableHoleFitCandidate$fEqHoleFitCandidate $fOrdHoleFit$fOutputableHoleFit $fEqHoleFitfrontendFrontendPluginAction staticPluginsexternalPlugins loadedPluginsloadedPluginDeps CorePluginPluginRecompileForceRecompileNoForceRecompileMaybeRecompilespPluginExternalPluginepPluginepUnitepModulelpPluginlpModulePluginWithArgspaPlugin paArgumentsinstallCoreToDostcPlugindefaultingPlugin holeFitPlugin driverPluginpluginRecompileparsedResultActionrenamedResultActiontypeCheckResultActionspliceRunActioninterfaceLoadAction ParsedResultparsedResultModuleparsedResultMessages PsMessages psWarningspsErrorsCommandLineOption lpModuleNamepluginRecompile' purePlugin impurePlugin flagRecompile defaultPluginkeepRenamedSourcepluginsWithArgs withPlugins mapPlugins withPlugins_defaultFrontendPluginloadExternalPlugins$fMonoidPluginRecompile$fSemigroupPluginRecompile$fOutputablePluginRecompile PhaseHookTPhaseT_Unlit T_FileArgsT_CppT_HsPp T_HscRecompT_Hsc T_HscPostTc T_HscBackendT_CmmCppT_CmmT_CcT_AsT_Js T_ForeignJs T_LlvmOpt T_LlvmLlc T_LlvmMangleT_MergeForeigndsForeignsHooktcForeignImportsHooktcForeignExportsHookhscFrontendHookhscCompileCoreExprHookghcPrimIfaceHook runPhaseHook runMetaHooklinkHookrunRnSpliceHookgetValueSafelyHookcreateIservProcessHook stgToCmmHookcmmToRawCmmHookDsForeignsHook ArchiveEntryfilenamefiletimefileownfilegrpfilemodefilesizefiledataafilter isBSDSymdef isGNUSymdefparseAr writeBSDAr writeGNUArloadArloadObj $fEqArchive $fShowArchive$fSemigroupArchive$fMonoidArchive$fEqArchiveEntry$fShowArchiveEntry FrameworkOptsfoFrameworkPathsfoCmdlineFrameworksLinkInfoPoint writePoint readPointfreshreprfindunion equivalent $fEqPointCondALWAYSEQQGEGEUGTTGULELEULTTLUNENEGPOSCARRYOFLOPARITY NOTPARITYcondToUnsigned maybeFlipCondmaybeInvertCond$fEqCondRootedEdgePathdompdomdomTreepdomTreeidomipdompddfsrpddfsfromAdj fromEdgestoAdjtoEdgesparents ancestorsasGraphasTree$fApplicativeS$fMonadS $fFunctorSSLTSLESGESGTULTULEUGEUGTOLTOLEOGEOGTUOLTUOLEUOGEUOGTNEVERVSVCis_ident is_symbolis_anyis_spaceis_loweris_upperis_digit is_alphanumhexDigit octDecDigit is_decdigit is_hexdigit is_octdigit is_bindigitOrdGrunOrdGrDynGraph&matchmkGraphlabNodesmatchAnynoNodes nodeRangelabEdgesUDecompUContextGDecompDecompMContextContextAdjUPathLPathLPunLPathUEdgeLEdgeUNodeLNodeordersizeufoldgmapnmapemapnemapnodesedgestoEdgetoLEdge edgeLabelnewNodesgeleminsNodeinsEdgedelEdgedelLEdge delAllLEdgeinsNodesinsEdgesdelNodesdelEdgesbuildGrmkUGraph gfiltermap labnfilternfilter labfiltersubgraphcontextlab lneighborssucprelsuclpreoutinnoutdegindegdegnode'lab'labNode' neighbors' lneighbors'suc'pre'lsuc'lpre'out'inn'outdeg'indeg'deg'hasEdge hasNeighborhasLEdgehasNeighborAdjequalprettify prettyPrint $fOrdLPath $fEqLPath $fShowLPath$fEqGroupEdges $fOrdOrdGr $fEqOrdGr $fReadOrdGr $fShowOrdGr$fShowGroupEdges$fReadGroupEdgesUGrGr $fBifunctorGr $fFunctorGr $fDynGraphGr $fGraphGr$fReadGr$fShowGr$fEqGr$fEqFromListCounting$fShowFromListCounting$fReadFromListCounting $fGenericGr condNegate condUnsignedmemoiseUniqueFunnodeId nodeClass nodeColor nodeConflictsnodeExclusionsnodePreference nodeCoalescegraphMapTriv initGraphgraphMapModifynewNodeIdentTxtIitxt SaneDouble unSaneDoubleJUOpNotOpBNotOpNegOpPlusOpNewOpTypeofOpDeleteOpVoidOpPreIncOp PostIncOpPreDecOp PostDecOpJOpEqOp StrictEqOpNeqOp StrictNeqOpGtOpGeOpLtOpLeOpAddOpSubOpMulOpDivOpModOp LeftShiftOp RightShiftOp ZRightShiftOpBAndOpBOrOpBXorOpLAndOpLOrOp InstanceofOpInOpJValJVarJListJDoubleJIntJStrJRegExJHashJFuncUnsatValJExprValExprSelExprIdxExpr InfixExprUOpExprIfExprApplExpr UnsatExprJsLabelJStatDeclStat ReturnStatIfStat WhileStat ForInStat SwitchStatTryStat BlockStatApplStatUOpStat AssignStat UnsatBlock LabelStat BreakStat ContinueStat IdentSupplyrunIdentSupplyLAndLOrBNotBXorBAndBOrModDivMulSubAddNegateNotPostDecPreDecPostIncPreIncNewnewIdentSupplypseudoSaturateidentFS $fNFDataJOp $fNFDataJUOp$fShowSaneDouble$fOrdSaneDouble$fEqSaneDouble$fShowIdentSupply$fOrdIdentSupply$fEqIdentSupply$fFunctorIdentSupply$fNFDataIdentSupply $fMonoidJStat$fSemigroupJStat $fEqJStat$fGenericJStat $fEqJExpr$fGenericJExpr$fEqJVal $fGenericJVal $fShowIdent $fEqIdent$fUniquableIdent$fDataSaneDouble$fFractionalSaneDouble$fNumSaneDouble$fGenericSaneDouble$fNFDataSaneDouble $fShowJUOp$fEqJUOp $fOrdJUOp $fEnumJUOp $fDataJUOp $fGenericJUOp $fShowJOp$fEqJOp$fOrdJOp $fEnumJOp $fDataJOp $fGenericJOpComposcomposJMGadtJMGIdJMGStatJMGExprJMGValJMacrojtoGADT jfromGADT mapExprIdent mapStatIdentmapIdentidentsSidentsEidentsVcomposOp composOpM composOpM_ composOpFold jsSaturate $fJMacroJVal $fJMacroJExpr $fJMacroJStat $fJMacroIdent$fComposJMGadtStackMapstackMapNextFreeSlotstackMapAssignment StackSlot emptyStackMapgetStackSlotFor getStackUseRegSubSubL16SubL8SubL8HClassG32ClassG16ClassG8ClassF64worstboundsqueese $fShowRegSub $fEnumRegSub $fOrdRegSub $fEqRegSub$fShowRegClass$fEnumRegClass classOfReg regsOfClassregNameregAlias sectionType SettingsErrorSettingsError_MissingDataSettingsError_BadData initSettings llvmFixupAsmtoRegMap toVRegMap trivColorableJsToDocjsToDocRRenderJs renderJsS renderJsE renderJsV renderJsIrenderJs renderJs'defaultRenderJsjsToDocrenderPrefixJsrenderPrefixJs' braceNest hangBrace flattenBlocks pprStringLit$fOutputableJVal$fOutputableJExpr $fJsToDocList$fJsToDocList0$fJsToDocIdent $fJsToDocJVal$fJsToDocJExpr$fJsToDocJStatpretty ghcjsRenderJs prettyBlockToStattoStatToJExprtoJExprtoJExprFromListjLamjVarjForIn jForEachInjTryCatchFinallyvarjStringjFordecljhEmptyjhSinglejhAdd jhFromListnullStat.==..===..!=..!==..>..>=..<..<=..||..&&..<<..>>..>>>.typeofif_ifSjwhenSifBlockSif10if01appappSreturnSloop loopBlockSpreIncrS postIncrSpreDecrS postDecrSoff64off32off16off8mask8mask16 signExtend8 signExtend16|=||=assignAllEqual assignAllassignAllReverseOrder declAssignAllnull_zero_one_two_three_ undefined_true_false_ returnStackmath_logmath_sinmath_cosmath_tanmath_exp math_acos math_asin math_atanmath_absmath_pow math_sqrt math_asinh math_acosh math_atanh math_sinh math_cosh math_tanh math_expm1 math_log1p math_fround dataFieldNamedataFieldNames allocData allocClsA$fFractionalJExpr $fNumJExpr$fToJExpr(,,,,,)$fToJExpr(,,,,)$fToJExpr(,,,) $fToJExpr(,,) $fToJExpr(,)$fToJExprFastString$fToJExprIdent $fToJExprChar$fToJExprInteger $fToJExprInt$fToJExprDouble $fToJExprMap$fToJExprUniqMap $fToJExprJVal $fToJExprBool $fToJExpr()$fToJExprJExpr $fToJExprList $fToStatList $fToStatJExpr $fToStatList0 $fToStatJStat $fToSatFUN $fToSatList $fToSatJExpr $fToSatJStat $fToSatList0StgRetRet1Ret2Ret3Ret4Ret5Ret6Ret7Ret8Ret9Ret10SpecialStackStgRegR1R2R3R4R5R6R7R8R9R10R11R12R13R14R15R16R17R18R19R20R21R22R23R24R25R26R27R28R29R30R31R32R33R34R35R36R37R38R39R40R41R42R43R44R45R46R47R48R49R50R51R52R53R54R55R56R57R58R59R60R61R62R63R64R65R66R67R68R69R70R71R72R73R74R75R76R77R78R79R80R81R82R83R84R85R86R87R88R89R90R91R92R93R94R95R96R97R98R99R100R101R102R103R104R105R106R107R108R109R110R111R112R113R114R115R116R117R118R119R120R121R122R123R124R125R126R127R128spstackr1r2r3r4 jsRegToInt intToJSRegjsRegmaxRegminReg regsFromR1 regsFromR2 jsRegsFromR1 jsRegsFromR2$fToJExprStgReg$fToJExprSpecial$fToJExprStgRet $fEqStgRet $fOrdStgRet $fShowStgRet $fEnumStgRet$fBoundedStgRet $fIxStgRet $fShowSpecial $fEqSpecial $fEqStgReg $fOrdStgReg $fShowStgReg $fEnumStgReg$fBoundedStgReg $fIxStgReg StgLiftConfigc_targetProfilec_liftLamsRecArgsc_liftLamsNonRecArgsc_liftLamsKnown$fShowStgLiftConfig$fReadStgLiftConfig$fEqStgLiftConfig$fOrdStgLiftConfigBitmapmkBitmapintsToReverseBitmapmAX_SMALL_BITMAP_SIZE CmmConfig cmmProfilecmmOptControlFlow cmmDoLintingcmmOptElimCommonBlks cmmOptSinkcmmOptThreadSanitizercmmGenStackUnwindInstrcmmExternalDynamicRefscmmDoCmmSwitchPlanscmmSplitProcPoints cmmPlatform dumpGraphdotGraph lookupNodegetNodeaddNodemodNode addConflict delConflict addConflicts addExclusion addExclusions addCoalesce delCoalesce addPreference coalesceGraph coalesceNodes freezeNodefreezeOneInGraphfreezeAllInGraph scanGraph validateGraphslurpNodeConflictCountsetColor colorGraph ppSourceStats popCntLabel pdepLabel pextLabel bSwapLabel bRevLabelclzLabelctzLabelword2FloatLabelatomicRMWLabel xchgLabel cmpxchgLabelatomicReadLabelatomicWriteLabelintBSmoduleGlobalSymbolmoduleExportsSymbol mkJsSymbolBS mkJsSymbolmkFreshJsSymbol mkRawSymbol NCGConfig ncgPlatform ncgAsmContext ncgThisModulencgProcAlignmentncgExternalDynamicRefsncgPICncgInlineThresholdMemcpyncgInlineThresholdMemsetncgSplitSectionsncgRegsIterative ncgRegsGraph ncgAsmLintingncgDoConstantFolding ncgSseVersion ncgBmiVersionncgDumpRegAllocStagesncgDumpAsmStatsncgDumpAsmConflicts ncgCfgWeightsncgCfgBlockLayoutncgCfgWeightlessLayoutncgDwarfEnabledncgDwarfUnwindingsncgDwarfStripBlockInfoncgExposeInternalSymbolsncgDwarfSourceNotesncgCmmStaticPredncgEnableShortcuttingncgComputeUnwindingncgEnableDeadCodeElimination ncgWordWidthncgSpillPreallocSizeplatformWordWidthBlankEpAnnotationsNoBlankEpAnnotations BlankSrcSpanBlankSrcSpanFileNoBlankSrcSpanshowAstDataFull showAstData$fEqBlankEpAnnotations$fShowBlankEpAnnotations$fEqBlankSrcSpan$fShowBlankSrcSpannoWarnLookupIdSubst extendInScope Supernodefreshen PureSupernode superLabel mapLabelsNullCollapseVizunNCVVizCollapseMonadconsumeByInGraph splitGraphAt finalGraph MonadUniqSM liftUniqSMrunNullCollapsecollapseInductiveGraph$fMonadUniqSMNullCollapseViz$$fVizCollapseMonadNullCollapseVizgrs$fFunctorNullCollapseViz$fApplicativeNullCollapseViz$fMonadNullCollapseViz$fMonadUniqueNullCollapseVizTyConSetisEmptyTyConSet emptyTyConSet unitTyConSet mkTyConSetextendTyConSetListextendTyConSet unionTyConSetunionTyConSets minusTyConSet elemTyConSetdelFromTyConSetfilterTyConSetintersectTyConSetdisjointTyConSetdelListFromTyConSetintersectsTyConSet ThreadStatusRunningBlockedFinishedDied ClosureTypePapCon Blackhole StackFrame ExprValData ExprResultExprCont ExprInlinePrimRes PrimInline PRPrimCall TypedExpr typex_typ typex_expr JSFFITypeInt8Type Int16Type Int32Type Int64Type Word8Type Word16Type Word32Type Word64Type DoubleType ByteArrayTypePtrTypeRefTypeExpFunisIOresultObjUnit oiSymbolsoiClInfooiStaticoiStatoiRaw oiFExports oiFImports LinkableUnit luObjUnit luIdExportsluOtherExportsluIdDepsluPseudoIdDeps luOtherDeps luRequired luForeignRefs ForeignJSRefforeignRefSrcSpanforeignRefPatternforeignRefSafetyforeignRefCConvforeignRefArgsforeignRefResult StaticLitBoolLitIntLitNullLit DoubleLit StringLitBinLitLabelLit StaticArg StaticObjArg StaticLitArg StaticConArg StaticUnboxedStaticUnboxedBoolStaticUnboxedIntStaticUnboxedDoubleStaticUnboxedStringStaticUnboxedStringOffset StaticVal StaticFun StaticThunk StaticData StaticList StaticInfosiVarsiValsiCCSlotId SlotUnknown GlobalIdCacheIdCache OtherSymbIdKeyIdTypeIdPlainIdEntry IdConEntryVarTypePtrVVoidVDoubleVIntVLongVAddrVRtsObjVObjVArrVCIStatic CIStaticRefs staticRefsCITypeCIFunCIThunkCIConCIPap CIBlackhole CIStackFramecitAritycitRegscitConstructorCILayoutCILayoutVariableCILayoutUnknown CILayoutFixed layoutSizelayoutCIRegs CIRegsUnknown ciRegsSkip ciRegsTypes ClosureInfociVarciRegsciNameciLayoutciTypeciStatic csInlinePushcsInlineBlackholecsInlineLoadRegs csInlineEnter csInlineAlloc csTraceRts csAssertRts csBoundsCheck csDebugAlloccsTraceForeigncsProf csContext GenGroupStateggsToplevelStatsggsClosureInfo ggsStaticggsStack ggsStackDepth ggsExtraDepsggsGlobalIdCacheggsForeignRefsGenState gsSettingsgsModulegsIdgsIdents gsUnfloatedgsGroupgsGlobalGctNumctJsNamethreadStatusNumthreadStatusJsName$fNFDataCIType$fToJExprCIStatic$fToJExprVarType$fNFDataVarType$fNFDataCILayout$fNFDataCIRegs$fOrdOtherSymb$fNFDataStaticUnboxed$fToJExprStaticLit$fOutputableStaticLit$fOutputableStaticArg$fOutputableTypedExpr$fToJExprClosureType$fShowThreadStatus$fEqThreadStatus$fOrdThreadStatus$fEnumThreadStatus$fBoundedThreadStatus$fShowClosureType$fEqClosureType$fOrdClosureType$fEnumClosureType$fBoundedClosureType$fEqExprValData$fEqExprResult $fEqExpFun $fOrdExpFun $fShowExpFun$fShowJSFFIType$fOrdJSFFIType $fEqJSFFIType$fEnumJSFFIType$fGenericForeignJSRef$fEqStaticInfo$fShowStaticInfo$fGenericStaticInfo $fEqStaticVal$fShowStaticVal$fGenericStaticVal $fEqStaticArg$fShowStaticArg$fGenericStaticArg $fEqStaticLit$fShowStaticLit$fGenericStaticLit$fEqStaticUnboxed$fOrdStaticUnboxed$fShowStaticUnboxed$fGenericStaticUnboxed $fEqStackSlot$fOrdStackSlot $fEqOtherSymb $fEqIdKey $fOrdIdKey $fEnumIdType $fEqIdType $fOrdIdType$fEqClosureInfo$fShowClosureInfo$fGenericClosureInfo $fEqCIRegs $fOrdCIRegs $fShowCIRegs$fGenericCIRegs $fEqCILayout $fOrdCILayout$fShowCILayout$fGenericCILayout $fEqVarType $fOrdVarType $fEnumVarType$fBoundedVarType $fShowVarType$fGenericVarType $fEqCIStatic$fGenericCIStatic$fSemigroupCIStatic$fMonoidCIStatic$fShowCIStatic $fEqCIType $fOrdCIType $fShowCIType$fGenericCITypetraceRts assertRtsclName clTypeNamestackFrameSizewithRegs IndexEntry idxSymbols idxOffset ExportedFun funModule funSymbol BlockDepsblockBlockDeps blockFunDeps DepsLocation ObjectFile ArchiveFileInMemoryDeps depsModule depsRequireddepsHaskellExported depsBlocksObject objModuleName objHandleobjPayloadOffsetobjDepsobjIndex isGlobalUnit putObjectisJsObjectFilegetObjectHeader getObjectBody getObject readObjectreadObjectDepsgetObjectUnitsreadObjectUnits$fBinaryStaticLit$fBinaryStaticArg$fBinaryStaticUnboxed$fBinaryStaticVal$fBinaryStaticInfo$fBinaryCIType$fBinaryCIStatic$fBinaryCILayout $fBinaryJUOp $fBinaryJOp$fBinaryCIRegs$fBinaryVarType$fBinaryJSFFIType$fBinaryClosureInfo$fBinarySaneDouble $fBinaryIdent $fBinaryJVal $fBinaryJExpr $fBinaryJStat$fBinaryExpFun$fBinaryForeignJSRef$fBinaryExportedFun$fOutputableExportedFun$fBinaryBlockDeps $fBinaryDeps$fOutputableDeps$fBinaryIndexEntry$fOutputableDepsLocation$fEqExportedFun$fOrdExportedFunGhcjsEnvlinkerArchiveDeps LinkedObj ObjLoaded JSLinkConfiglcNoJSExecutables lcNoHsMain lcOnlyOutlcNoRts lcNoStats generateAllJsdefaultJSLinkConfig newGhcjsEnv$fOutputableLinkedObj closureEntry_closureField1_closureField2_ closureMeta_ closureCC_ jTyObject closureTypeentryClosureTypeisThunkisThunk' isBlackholeisFunisFun'isPapisPap'isConisCon'conTagconTag' closureEntry closureMeta closureCC closureField1 closureField2funArity funArity'papArity funOrPapArityExprCtx ctxTargetctxEvaluatedIds ctxSrcSpanctxLneFrameVarsctxLneFrameSize initExprCtx ctxSetTarget ctxSetTopctxAssertEvaluated ctxSetSrcSpanctxUpdateLneFramectxClearLneFramectxIsEvaluatedctxIsLneBindingctxIsLneLiveVarctxLneBindingStackSizectxLneShrinkStackassignToTypedExprsassignToExprCtx assignCoerce1 GlobalOcc global_ident global_id global_countrunG modifyGroup emitGlobal addDependency emitToplevel emitStaticemitClosureInfo emitForeign resetGroup assertRtsStat getSettingsgetGlobalIdCachesetGlobalIdCache globalOccsinitCostCentresemitCostCentreDeclemitCostCentreStackDeclenterCostCentreFunenterCostCentreThunksetCCpushRestoreCCS jCurrentCCSjCafCCS jSystemCCS profiling ifProfiling ifProfilingMprofStat costCentreLblcostCentreStackLblsingletonCCSLblccsVarJ SlotCountNoSlotOneSlotTwoSlotsisUnboxableCon isUnboxable slotCountvarSize varSlotCountisVoidisPtr isSingleVar isMultiVar isMatchabletyConVtidVttypeVtuTypeVt primRepVt typePrimRep' tyConPrimRep' kindPrimRep' primTypeVtargVt dataConType isBoolDataCon fixedLayout stackSlotType idPrimReps typePrimReps primRepSize assocPrimRepsassocIdPrimReps assocIdExprsmight_be_a_function mkArityTag toTypeList$fOutputableSlotCount$fShowSlotCount $fEqSlotCount$fOrdSlotCountsinkPgm freshUnique freshIdentcachedIdentForId identForId identForIdN identsForIdidentForEntryIdidentForDataConEntryIdvarForId varForIdN varsForId varForEntryIdvarForDataConEntryIdidentForDataConWorkervarForDataConWorker declVarsForId resetSlots isolateSlotssetSlotsgetSlotsaddUnknownSlotsaddSlots dropSlotspushpush'adjSp'adjSpN'adjSpadjSpNpushNpushN'pushNNpushNN'pushOptimized' pushLneFramepopSkiploadSkippopSkipIpopNbhStats updateThunk updateThunk'genLit genStaticLitgenDependencyDataCopyCC DontCopyCCClosureclEntryclField1clField2clMetaclCCclosureInfoStatclosure conClosure newClosure assignClosure copyClosuregenConallocConallocUnboxedCon allocDynamicE allocDynamicgenArggenIdArg genIdArgIgenIdStackArgIallocConStaticallocUnboxedConStaticallocateStaticList jsStaticArg jsStaticArgs genPrimCall saturateFFIgenForeignCall mkUnarisedIds mkUnarisedIdmkStgAltTypeFromStgAlts bindersOfX bindersOfTopbindersOfTopBindsidArgsstripStgTicksTopstripStgTicksTopE showStgStats$fEqCounterType$fOrdCounterTypedepSortWithAnnotStgPgmannBindingFreeVars StgDebugOptsstgDebug_infoTableMap"stgDebug_distinctConstructorTablescollectDebugInformationbcPrepBinding getPrimTyOfprimTyDescCharppPrimTyConStgTypetemplateHaskellNamesthSynthLibqqLib mkTHModulelibFunlibTcthFunthTcthClsthConqqFun liftClassNamequoteClassName qTyConName nameTyConNamefieldExpTyConName patTyConNamefieldPatTyConName expTyConName decTyConName decsTyConName typeTyConNamematchTyConNameclauseTyConNamefunDepTyConName predTyConName codeTyConNameinjAnnTyConNameoverlapTyConNamemodNameTyConName returnQName bindQName sequenceQName newNameNameliftNameliftStringName mkNameName mkNameG_vName mkNameG_dNamemkNameG_tcName mkNameLName mkNameQName mkNameSName mkModNameName unTypeNameunTypeCodeNameunsafeCodeCoerceName liftTypedName charLName stringLName integerLName intPrimLName wordPrimLNamefloatPrimLNamedoublePrimLName rationalLNamestringPrimLName charPrimLNamelitPNamevarPNametupPNameunboxedTupPNameunboxedSumPNameconPName infixPName tildePName bangPNameasPName wildPNamerecPName listPNamesigPName viewPName fieldPatName matchName clauseNamevarENameconENamelitENameappEName appTypeEName infixEName infixAppName sectionLName sectionRNamelamEName lamCaseEName lamCasesENametupENameunboxedTupENameunboxedSumEName condEName multiIfENameletEName caseENamedoENamemdoEName compEName fromEName fromThenEName fromToENamefromThenToEName listENamesigEName recConEName recUpdEName staticENameunboundVarEName labelENameimplicitParamVarEName getFieldENameprojectionEName fieldExpName guardedBName normalBName normalGEName patGEName bindSNameletSName noBindSNameparSNamerecSNamefunDNamevalDName dataDName newtypeDName typeDataDName tySynDName classDNameinstanceWithOverlapDName standaloneDerivWithStrategyDNamesigDName kiSigDName defaultDNamedefaultSigDName forImpDName pragInlDNamepragOpaqueDName pragSpecDNamepragSpecInlDNamepragSpecInstDName pragRuleDNamepragCompleteDName pragAnnDName dataInstDNamenewtypeInstDNametySynInstDNameopenTypeFamilyDNameclosedTypeFamilyDNamedataFamilyDName infixLDName infixRDName infixNDNameroleAnnotDName patSynDNamepatSynSigDNameimplicitParamBindDNamecxtNamenoSourceUnpackednessNamesourceNoUnpackNamesourceUnpackNamenoSourceStrictnessNamesourceLazyNamesourceStrictName normalCNamerecCName infixCName forallCName gadtCName recGadtCNamebangName bangTypeNamevarBangTypeNameunidirPatSynNameimplBidirPatSynNameexplBidirPatSynNameprefixPatSynNameinfixPatSynNamerecordPatSynName forallTNameforallVisTNamevarTNameconTName tupleTNameunboxedTupleTNameunboxedSumTName arrowTName mulArrowTName listTNameappTName appKindTNamesigTName equalityTNamelitTName promotedTNamepromotedTupleTNamepromotedNilTNamepromotedConsTName wildCardTName infixTNameimplicitParamTName numTyLitName strTyLitName charTyLitName plainTVName kindedTVNameplainInvisTVNamekindedInvisTVNamespecifiedSpecNameinferredSpecName nominalRNamerepresentationalRName phantomRName inferRName starKNameconstraintKName noSigName kindSigName tyVarSigNameinjectivityAnnName cCallName stdCallName cApiCallName primCallNamejavaScriptCallName unsafeNamesafeNameinterruptibleName ruleVarNametypedRuleVarName funDepName tySynEqnNamevalueAnnotationNametypeAnnotationNamemoduleAnnotationNamederivClauseNamestockStrategyNameanyclassStrategyNamenewtypeStrategyNameviaStrategyName expQTyConNamedecsQTyConNametypeQTyConName patQTyConName stmtTyConName conTyConNamebangTypeTyConNamevarBangTypeTyConNameruleBndrTyConNametySynEqnTyConName roleTyConNamederivClauseTyConName kindTyConNametyVarBndrUnitTyConNametyVarBndrSpecTyConNamederivStrategyTyConName quoteExpName quotePatName quoteDecName quoteTypeNamenoInlineDataConNameinlineDataConNameinlinableDataConNameconLikeDataConNamefunLikeDataConNameallPhasesDataConNamefromPhaseDataConNamebeforePhaseDataConNameoverlappableDataConNameoverlappingDataConNameoverlapsDataConNameincoherentDataConName liftClassKey quoteClassKey expTyConKey matchTyConKeyclauseTyConKey qTyConKey expQTyConKey patTyConKey stmtTyConKey conTyConKey typeQTyConKey typeTyConKey decTyConKeybangTypeTyConKeyvarBangTypeTyConKeyfieldExpTyConKeyfieldPatTyConKey nameTyConKey patQTyConKeyfunDepTyConKey predTyConKey predQTyConKeytyVarBndrUnitTyConKey decsQTyConKeyruleBndrTyConKeytySynEqnTyConKey roleTyConKeyinjAnnTyConKey kindTyConKeyoverlapTyConKeyderivClauseTyConKeyderivStrategyTyConKey decsTyConKeytyVarBndrSpecTyConKey codeTyConKeymodNameTyConKeynoInlineDataConKeyinlineDataConKeyinlinableDataConKeyconLikeDataConKeyfunLikeDataConKeyallPhasesDataConKeyfromPhaseDataConKeybeforePhaseDataConKeyoverlappableDataConKeyoverlappingDataConKeyoverlapsDataConKeyincoherentDataConKey returnQIdKey bindQIdKeysequenceQIdKey liftIdKey newNameIdKey mkNameIdKeymkNameG_vIdKeymkNameG_dIdKeymkNameG_tcIdKey mkNameLIdKey mkNameSIdKey unTypeIdKeyunTypeCodeIdKeyliftTypedIdKeymkModNameIdKeyunsafeCodeCoerceIdKey mkNameQIdKey charLIdKey stringLIdKey integerLIdKey intPrimLIdKeywordPrimLIdKeyfloatPrimLIdKeydoublePrimLIdKeyrationalLIdKeystringPrimLIdKeycharPrimLIdKeyliftStringIdKey litPIdKey varPIdKey tupPIdKeyunboxedTupPIdKeyunboxedSumPIdKey conPIdKey infixPIdKey tildePIdKey bangPIdKeyasPIdKey wildPIdKey recPIdKey listPIdKey sigPIdKey viewPIdKey fieldPatIdKey matchIdKey clauseIdKey varEIdKey conEIdKey litEIdKey appEIdKey appTypeEIdKey infixEIdKey infixAppIdKey sectionLIdKey sectionRIdKey lamEIdKey lamCaseEIdKeylamCasesEIdKey tupEIdKeyunboxedTupEIdKeyunboxedSumEIdKey condEIdKey multiIfEIdKey letEIdKey caseEIdKeydoEIdKey compEIdKey fromEIdKeyfromThenEIdKey fromToEIdKeyfromThenToEIdKey listEIdKey sigEIdKey recConEIdKey recUpdEIdKey staticEIdKeyunboundVarEIdKey labelEIdKeyimplicitParamVarEIdKey mdoEIdKeygetFieldEIdKeyprojectionEIdKey fieldExpIdKey guardedBIdKey normalBIdKey normalGEIdKey patGEIdKey bindSIdKey letSIdKey noBindSIdKey parSIdKey recSIdKey funDIdKey valDIdKey dataDIdKey newtypeDIdKey tySynDIdKey classDIdKeyinstanceWithOverlapDIdKeyinstanceDIdKey sigDIdKey forImpDIdKey pragInlDIdKeypragSpecDIdKeypragSpecInlDIdKeypragSpecInstDIdKeypragRuleDIdKey pragAnnDIdKeydataFamilyDIdKeyopenTypeFamilyDIdKeydataInstDIdKeynewtypeInstDIdKeytySynInstDIdKeyclosedTypeFamilyDIdKey infixLDIdKey infixRDIdKey infixNDIdKeyroleAnnotDIdKey!standaloneDerivWithStrategyDIdKeydefaultSigDIdKey patSynDIdKeypatSynSigDIdKeypragCompleteDIdKeyimplicitParamBindDIdKey kiSigDIdKey defaultDIdKeypragOpaqueDIdKeytypeDataDIdKeycxtIdKeynoSourceUnpackednessKeysourceNoUnpackKeysourceUnpackKeynoSourceStrictnessKey sourceLazyKeysourceStrictKey normalCIdKey recCIdKey infixCIdKey forallCIdKey gadtCIdKey recGadtCIdKey bangIdKeybangTKey varBangTKeyunidirPatSynIdKeyimplBidirPatSynIdKeyexplBidirPatSynIdKeyprefixPatSynIdKeyinfixPatSynIdKeyrecordPatSynIdKey forallTIdKeyforallVisTIdKey varTIdKey conTIdKey tupleTIdKeyunboxedTupleTIdKeyunboxedSumTIdKey arrowTIdKey listTIdKey appTIdKey appKindTIdKey sigTIdKeyequalityTIdKey litTIdKeypromotedTIdKeypromotedTupleTIdKeypromotedNilTIdKeypromotedConsTIdKeywildCardTIdKeyimplicitParamTIdKey infixTIdKey numTyLitIdKey strTyLitIdKeycharTyLitIdKey plainTVIdKey kindedTVIdKeyplainInvisTVIdKeykindedInvisTVIdKey nominalRIdKeyrepresentationalRIdKey phantomRIdKey inferRIdKey starKIdKeyconstraintKIdKey noSigIdKey kindSigIdKey tyVarSigIdKeyinjectivityAnnIdKey cCallIdKey stdCallIdKey cApiCallIdKey primCallIdKeyjavaScriptCallIdKey unsafeIdKey safeIdKeyinterruptibleIdKey funDepIdKeymulArrowTIdKey tySynEqnIdKey quoteExpKey quotePatKey quoteDecKey quoteTypeKey ruleVarIdKeytypedRuleVarIdKeyvalueAnnotationIdKeytypeAnnotationIdKeymoduleAnnotationIdKeyderivClauseIdKeystockStrategyIdKeyanyclassStrategyIdKeynewtypeStrategyIdKeyviaStrategyIdKeyspecifiedSpecKeyinferredSpecKeylift_RDR liftTyped_RDRunsafeCodeCoerce_RDR mkNameG_dRDR mkNameG_vRDRconE_RDRlitE_RDRappE_RDR infixApp_RDR stringL_RDR intPrimL_RDR wordPrimL_RDRfloatPrimL_RDRdoublePrimL_RDRstringPrimL_RDR charPrimL_RDRLiveVars bindingRefsexprRefs hasExport collectTopIds collectIds removeTick liveStaticliveVarsstgTopBindLive stgRhsLive stgExprLivestgLetNoEscapeLiveisUpdatableRhs stgLneLive' stgLneLivestgLneLiveExpr isInlineExprrtsApplygenApp$fShowApplySpec $fEqApplySpec$fOrdApplySpec$fShowApplyConv $fEqApplyConv$fOrdApplyConvgarbageCollector resetRegisterresetResultVarclosureConstructors stackManipbitsIdx bhLneStatsdeclRegsregGettersSettersloadRegs assignRegs assignRegs'declRets closureTypesrtsDeclsrtsText rtsDeclsTextrtsrts'TagEnvTEte_envte_get te_bytecode TagSigEnv InferStgAlt InferStgRhs InferStgExprInferStgBindingInferStgTopBindingcombineAltInfo getBinderIdinitEnv makeTaggednoSig lookupSig lookupInfo isDunnoSig isTaggedInfo extendSigEnv$fOutputableTagEnv InstructionregUsageOfInstrpatchRegsOfInstrisJumpishInstrjumpDestsOfInstrpatchJumpInstr mkSpillInstr mkLoadInstrtakeDeltaInstr isMetaInstrmkRegRegMoveInstrtakeRegRegMoveInstr mkJumpInstrmkStackAllocInstrmkStackDeallocInstrpprInstr mkCommentRegUsageRUwritesnoUsage$fShowRegUsageLRegKeyLRegSet emptyLRegSet nullLRegSet insertLRegSet elemLRegSetdeleteFromLRegSet sizeLRegSet plusLRegSet elemsLRegSetstgCse$fTrieMapStgArgMap$fFunctorStgArgMap$fTrieMapConAppMap$fFunctorConAppMapinitStaticPtrs TickishType ProfNotesHpcTicks Breakpoints SourceNotestick_loc tick_pathtick_ids tick_label TicksConfig ticks_passesticks_profAutoticks_countEntriesaddTicksToBindsstripTicksTopHsExprisGoodSrcSpan' $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickishType$fEqTickDensitywriteMixEntries hpcInitCodereadElfSectionByNamereadElfNoteAsString makeElfNote SelfLoopInfoSequelReturnAssignTo$fOutputableSequelEAIndex EAIndexNoneEABase EABaseNone EABaseReg EABaseRipAddrMode AddrBaseIndexImmAddrImmImmInt ImmIntegerImmCLblImmLitImmIndexImmFloat ImmDoubleImmConstantSumImmConstantDiffvirtualRegSqueezerealRegSqueeze strImmLitlitToImm addrOffset addrModeRegsspRelfirstxmmlastxmmlastintargRegs allMachRegNosclassOfRealRegshowRegeaxebxecxedxesiediebpespraxrbxrcxrdxrsirdirbprspr8r9r10r11r12r13r14r15xmm0xmm1xmm2xmm3xmm4xmm5xmm6xmm7xmm8xmm9xmm10xmm11xmm12xmm13xmm14xmm15ripRelxmmcallClobberedRegs allArgRegs allIntArgRegs allFPArgRegsinstrClobberedRegsallocatableRegsFreeRegs noFreeRegs releaseReg initFreeRegs getFreeRegs allocateReg$fShowFreeRegs$fOutputableFreeRegswidthMax detEltsUFMdetEltsUniqMap builderCommas WasmCodeGenMWasmCodeGenState wasmPlatform defaultSyms funcTypes funcBodies dataSectionsctors localRegslocalRegsCountwasmUniqSupplyBrTableIntervalbti_lo bti_count WasmControlWasmPush WasmBlockWasmLoop WasmIfTopWasmBrWasmFallthrough WasmBrTable WasmTailCall WasmActionsWasmSeqWasmStatements SomeWasmExprWasmExpr WasmInstr WasmCommentWasmNopWasmDropWasmUnreachable WasmConst WasmSymConstWasmLoad WasmStore WasmGlobalGet WasmGlobalSet WasmLocalGet WasmLocalSet WasmLocalTee WasmCCallWasmCCallIndirect WasmConcatWasmReinterpret WasmTruncSat WasmConvertWasmAddWasmSubWasmMulWasmDivWasmRemWasmAndWasmOrWasmXorWasmEqWasmNeWasmLtWasmGtWasmLeWasmGeWasmShlWasmShrWasmI32Extend8SWasmI32Extend16SWasmI64Extend8SWasmI64Extend16SWasmI64Extend32SWasmI64ExtendI32WasmI32WrapI64WasmF32DemoteF64WasmF64PromoteF32WasmAbsWasmNegWasmCondSignageSignedUnsignedFuncBody funcLocalsfuncBody LocalInfo GlobalInfo DataSectiondataSectionKinddataSectionAlignmentdataSectionContentsDataSectionContentDataI8DataI16DataI32DataI64DataF32DataF64DataSymDataSkip DataASCII DataIncBinDataSectionKind SectionData SectionRODataSymKindSymDataSymFunc SymVisibility SymUndefined SymStatic SymDefaultSymNameWasmFunctionTypeft_pops ft_pushesTypeList TypeListNil TypeListCons SomeWasmType WasmTypeTagTagI32TagI64TagF32TagF64WasmTypeI32I64F32F64someWasmTypesFromTypeListwasmControlCastinitialWasmCodeGenState wasmGetsM wasmPlatformM wasmWordTypeMwasmWordCmmTypeM wasmStateM wasmModifyM wasmExecMwasmUniq!$fTestEqualityWasmTypeWasmTypeTag$fEqSomeWasmType$fOutputableBrTableInterval$fFunctorWasmCodeGenM$fApplicativeWasmCodeGenM$fMonadWasmCodeGenM$fShowBrTableInterval $fEqSymKind $fEqSymName$fIsStringSymName $fShowSymName$fUniquableSymName $fOrdSymName$fShowWasmTypeTagWasmIfinclusiveInterval entryBlocks NatBasicBlock NatCmmDeclNatCmm floatToBytes doubleToBytespprASCII pprString pprFileEmbedpprSectionHeader LlvmCastOpLM_TruncLM_ZextLM_Sext LM_FptruncLM_Fpext LM_Fptoui LM_Fptosi LM_Uitofp LM_Sitofp LM_Ptrtoint LM_Inttoptr LM_Bitcast LlvmCmpOp LM_CMP_Eq LM_CMP_Ne LM_CMP_Ugt LM_CMP_Uge LM_CMP_Ult LM_CMP_Ule LM_CMP_Sgt LM_CMP_Sge LM_CMP_Slt LM_CMP_Sle LM_CMP_Feq LM_CMP_Fne LM_CMP_Fgt LM_CMP_Fge LM_CMP_Flt LM_CMP_Fle LlvmMachOp LM_MO_Add LM_MO_Sub LM_MO_Mul LM_MO_UDiv LM_MO_SDiv LM_MO_URem LM_MO_SRem LM_MO_FAdd LM_MO_FSub LM_MO_FMul LM_MO_FDiv LM_MO_FRem LM_MO_Shl LM_MO_LShr LM_MO_AShr LM_MO_AndLM_MO_Or LM_MO_XorLlvmLinkageTypeInternalLinkOnceWeak Appending ExternWeakExternallyVisibleExternalPrivateLlvmParameterListType FixedArgsVarArgsLlvmCallConventionCC_Ccc CC_Fastcc CC_ColdccCC_GhcCC_Ncc CC_X86_Stdcc LlvmCallTypeStdCallTailCall LlvmFuncAttr AlwaysInline InlineHintOptSizeNoReturnNoUnwindReadNoneReadOnlySspSspReq NoRedZoneNoImplicitFloatNaked LlvmParamAttrZeroExtSignExtInRegByValSRetNoAlias NoCaptureNest LlvmParameterLlvmFunctionDeclsLlvmFunctionDecldecName funcLinkagefuncCc decReturnType decVarargs decParams funcAlign LlvmStatic LMComment LMStaticLit LMUninitType LMStaticStr LMStaticArray LMStaticStrucLMStaticStrucULMStaticPointerLMTruncLMBitcLMPtoILMAddLMSubLlvmLitLMIntLit LMFloatLit LMNullLit LMVectorLit LMUndefLitLlvmVar LMGlobalVar LMLocalVar LMNLocalVarLMLitVarLMConstGlobalConstantAliasLMAlign LMSectionLlvmTypeLMIntLMFloatLMDouble LMFloat80 LMFloat128 LMPointerLMArrayLMVectorLMLabelLMVoidLMStruct LMStructULMAlias LMMetadata LMFunction LlvmAliasLMStringLMGlobal getGlobalVargetGlobalValueppTypeppParams garbageLit getVarType getLitType getStatTypegetLinkpLiftpVarLiftpLower pVarLowerisIntisFloat isPointerisVectorisGloballlvmWidthInBitsi128i64i32i16i8i1i8PtrllvmWord llvmWordPtrppDoublenarrowFpwidenFpppFloat ppCommaJoin ppSpaceJoin$fOutputableLlvmParamAttr$fOutputableLlvmFuncAttr$fOutputableLlvmCallConvention$fOutputableLlvmLinkageType$fOutputableLlvmFunctionDecl$fOutputableLlvmType$fOutputableLlvmMachOp$fOutputableLlvmCmpOp$fOutputableLlvmCastOp$fEqLlvmCastOp $fEqLlvmCmpOp$fEqLlvmMachOp $fEqLlvmVar $fEqLlvmLit$fEqLlvmFunctionDecl $fEqLlvmType$fEqLlvmLinkageType$fEqLlvmParameterListType$fShowLlvmParameterListType$fEqLlvmCallConvention$fEqLlvmCallType$fShowLlvmCallType$fEqLlvmFuncAttr$fEqLlvmParamAttr $fEqLMConstMetaDecl MetaNamed MetaUnnamed MetaAnnotMetaExprMetaStrMetaNodeMetaVar MetaStructMetaId$fOutputableMetaId $fEqMetaAnnot $fEqMetaExpr $fEqMetaId $fOrdMetaId $fEnumMetaIdLlvmExpressionAllocaLlvmOpCompareExtractExtractVInsertMallocLoadALoad GetElemPtr AtomicRMWCmpXChgCallCallMPhiAsmMExpr LlvmStatement AssignmentFenceBranchBranchIfCommentMkLabelStoreSwitch UnreachableNopMetaStmt LlvmAtomicOpLAO_XchgLAO_AddLAO_SubLAO_AndLAO_NandLAO_OrLAO_XorLAO_MaxLAO_MinLAO_UmaxLAO_UminLlvmSyncOrdering SyncUnord SyncMonotonic SyncAcquire SyncRelease SyncAcqRel SyncSeqCstSingleThreaded LlvmFunctions LlvmFunctionfuncDeclfuncArgs funcAttrsfuncSect funcPrefix LlvmModule modComments modAliasesmodMeta modGlobals modFwdDeclsmodFuncs LlvmBlocks LlvmBlock blockLabel blockStmts LlvmBlockId$fEqLlvmStatement$fEqLlvmExpression$fShowLlvmAtomicOp$fEqLlvmAtomicOp$fShowLlvmSyncOrdering$fEqLlvmSyncOrdering ppLlvmModuleppLlvmComments ppLlvmComment ppLlvmGlobals ppLlvmGlobal ppLlvmAliases ppLlvmAlias ppLlvmMetas ppLlvmMetappLlvmFunctionsppLlvmFunctionppLlvmFunctionDeclsppLlvmFunctionDeclppName ppPlainNameppLitppVar ppTypeLitlmGlobalRegVarlmGlobalRegArg alwaysLivestgTBAAtopNstackNheapNrxNbaseNtbaagetTBAAFormatII8II16II32II64FF32FF64 intFormat floatFormat isIntFormat isFloatFormat cmmTypeFormat formatToWidth formatInBytes $fShowFormat $fEqFormat mkVirtualReg regDotColor AddrRegReg AddrRegImmLOHIHAHIGHERAHIGHESTAtoRegNo fits16Bits makeImmediatefRegr0tocr30f1tmpRegdW_LANG_HaskelldW_TAG_array_typedW_TAG_lexical_blockdW_TAG_pointer_typedW_TAG_compile_unitdW_TAG_structure_typedW_TAG_typedefdW_TAG_subroutine_typedW_TAG_subrange_typedW_TAG_base_typedW_TAG_file_typedW_TAG_subprogramdW_TAG_variabledW_TAG_auto_variabledW_TAG_arg_variabledW_TAG_ghc_src_note dW_AT_namedW_AT_stmt_list dW_AT_low_pc dW_AT_high_pcdW_AT_languagedW_AT_comp_dirdW_AT_producerdW_AT_externaldW_AT_frame_basedW_AT_use_UTF8dW_AT_linkage_namedW_AT_ghc_tick_parentdW_AT_ghc_span_filedW_AT_ghc_span_start_linedW_AT_ghc_span_start_coldW_AT_ghc_span_end_linedW_AT_ghc_span_end_coldW_CHILDREN_nodW_CHILDREN_yes dW_FORM_addr dW_FORM_data2 dW_FORM_data4dW_FORM_string dW_FORM_flagdW_FORM_block1dW_FORM_ref_addr dW_FORM_ref4dW_FORM_flag_presentdW_ATE_addressdW_ATE_boolean dW_ATE_float dW_ATE_signeddW_ATE_signed_chardW_ATE_unsigneddW_ATE_unsigned_chardW_CFA_set_locdW_CFA_undefineddW_CFA_same_valuedW_CFA_def_cfadW_CFA_def_cfa_offsetdW_CFA_def_cfa_expressiondW_CFA_expressiondW_CFA_offset_extended_sfdW_CFA_def_cfa_sfdW_CFA_def_cfa_offset_sfdW_CFA_val_offsetdW_CFA_val_expression dW_CFA_offset dW_OP_addr dW_OP_deref dW_OP_consts dW_OP_minus dW_OP_mul dW_OP_plus dW_OP_lit0 dW_OP_breg0dW_OP_call_frame_cfadwarfInfoSectiondwarfAbbrevSectiondwarfLineSectiondwarfFrameSectiondwarfGhcSectiondwarfARangesSection dwarfSectiondwarfInfoLabeldwarfAbbrevLabeldwarfLineLabeldwarfFrameLabel dwarfRegNodwarfReturnRegNoEdgeInfotransitionSource edgeWeightTransitionSource CmmSource AsmCodeGen trans_cmmNode trans_infoCfgEdgeedgeFromedgeToedgeInfoCFG EdgeWeightweightToDouble mkWeightInfoadjustEdgeWeight setEdgeWeight getCfgNodeshasNodesanityCheckCfg filterEdgesshortcutWeightMapaddImmediateSuccessoraddEdge addWeightEdgegetSuccEdgesSortedgetSuccessorEdges getEdgeInfo reverseEdges infoEdgeListedgeList getSuccessorspprEdgeWeightsaddNodesBetween getCfgProcgetCfg optimizeCFG loopMembers loopLevelsloopInfomkGlobalWeights$fOutputableEdgeWeight$fOutputableBranchInfo$fOutputableEdgeInfo$fOutputableCfgEdge $fOrdCfgEdge $fEqCfgEdge$fOutputableLoopInfo$fNonLocalBlockNode $fEqEdgeInfo$fEqTransitionSource$fEqBranchInfo$fEqEdgeWeight$fOrdEdgeWeight$fEnumEdgeWeight$fNumEdgeWeight$fRealEdgeWeight$fFractionalEdgeWeightLiveBasicBlockLiveInfoliveBorn liveDieRead liveDieWrite LiveInstrInstrSRInstrSPILLRELOAD LiveCmmDeclBlockMapRegMap emptyRegMap mapBlockTop mapBlockTopMmapSCCMmapGenBlockTopmapGenBlockTopMslurpConflictsslurpReloadCoalesce stripLivepprLiveCmmDeclmapLiveCmmDeclstripLiveBlockeraseDeltasLivepatchEraseLivepatchRegsLiveInstrcmmTopLiveness regLivenessreverseBlocksInTops$fOutputableInstrSR$fInstructionInstrSR$fOutputablePenvLiveInstr$fOutputableLiveInstr$fOutputablePPlatformLiveInfo$fFunctorLiveInstr$fFunctorInstrSRRA_State ra_blockassig ra_freeregsra_assigra_deltara_stackra_us ra_spills ra_config ra_fixups RegAllocStatsra_spillInstrs ra_fixupList SpillReason SpillAlloc SpillClobber SpillLoad SpillJoinRR SpillJoinRMLocInMemInBothBlockAssignmentlookupBlockAssignmentlookupFirstUsedemptyBlockAssignmentupdateBlockAssignment regsOfLoc$fOutputableLoc$fEqLoc $fShowLoc$fOrdLoc$fEqReadingOrWriting$fOrdReadingOrWritingbinSpillReasonscountRegRegMovesNatpprStatsRegM getConfigrunRspillRloadR getFreeRegsR setFreeRegsR getAssigR setAssigRgetBlockAssigRsetBlockAssigR setDeltaR getDeltaR getUniqueR recordSpillrecordFixupBlock $fMonadRegM$fApplicativeRegM $fFunctorRegM cleanSpills$fOutputableStore$fUniquableStore SpillStatsspillStoreLoadregSpill accSpillSL$fOutputableSpillStats regCoalesce slurpJoinMovs SpillCostInfoSpillCostRecordzeroSpillCostInfoplusSpillCostInfoplusSpillCostRecordslurpSpillCostInfo chooseSpilllifeMapFromSpillCostInfopprSpillCostRecordAddrReg allGpArgRegs allFpArgRegs $fEqAddrMode$fShowAddrMode$fEqImm $fShowImmtargetVirtualRegSqueezetargetRealRegSqueezetargetClassOfRealRegtargetMkVirtualRegtargetRegDotColortargetClassOfRegRegAllocStatsStartRegAllocStatsSpillRegAllocStatsColored raLiveCmmraGraph raSpillCosts raPlatformraCode raCoalesced raSpillStats raSpilledraGraphColoredraCodeCoalesced raPatched raSpillCleanraFinalraSRMspprStatsSpillspprStatsLifetimespprStatsConflictpprStatsLifeConflict countSRMsaddSRM$fOutputableRegAllocStats$fFunctorRegAllocStatsregAllocshowBitsOperandOpRegOpRegExt OpRegShiftOpImm OpImmShiftOpAddrRegShiftExtShift ShiftModeSLSLSLSRSASRSRORExtModeEUXTBEUXTHEUXTWEUXTXESXTBESXTHESXTWESXTXTBlockTLabelTRegCOMMENTMULTILINE_COMMENTANNLOCATIONLDATANEWBLOCKDELTASXTBUXTBSXTHUXTHPUSH_STACK_FRAMEPOP_STACK_FRAMEADDCMNCMPMSUBMULSDIVSMULHSMULLSUBUDIVSBFMUBFMSBFXUBFXANDANDSASRBICBICSEONEORLSLLSRMOVMOVKMVNORNORRRORTSTSTRSTLRLDRLDARSTPLDPCSETCBZCBNZJBBLBCONDDMBSYFCVTSCVTFFCVTZSFABSstackFrameHeaderSize spillSlotSize stackAlign maxSpillSlotsspillSlotToOffsetcallerSavedRegistersallocMoreStackinstrConopRegxzrwzrip0_xx0x1x2x3x4x5x6x7x8x9x10x11x12x13x14x15x16x17x18x19x20x21x22x23x24x25x26x27x28x29x30x31_dd0d1d2d3d4d5d6d7d8d9d10d11d12d13d14d15d16d17d18d19d20d21d22d23d24d25d26d27d28d29d30d31 opRegUExt opRegSExt$fOutputableRegUsage $fEqOperand $fShowOperand $fEqShiftMode$fShowShiftMode $fEqExtMode $fShowExtModeJumpDest DestBlockIdgetJumpDestBlockId canShortcutshortcutStatics shortcutJump$fOutputableJumpDest pprNatCmmDeclprimRepCmmType slotCmmType typeCmmTypeprimRepForeignHinttypeForeignHint mkIntCLitzeroCLitzeroExpr mkWordCLitmkByteStringCLitmkFileEmbedLit mkDataLits mkRODataLits mkStgWordCLitpackHalfWordsCLit mkLblExpr cmmOffsetExpr cmmOffset cmmRegOff cmmOffsetLit cmmLabelOffcmmIndex cmmIndexExpr cmmLoadIndex cmmLoadBWord cmmLoadGCWord cmmRegOffB cmmOffsetBcmmOffsetExprB cmmLabelOffB cmmOffsetLitBcmmOffsetExprW cmmOffsetW cmmRegOffW cmmOffsetLitW cmmLabelOffW cmmLoadIndexW cmmOrWord cmmAndWord cmmNeWord cmmEqWord cmmULtWord cmmUGeWord cmmUGtWord cmmSLtWord cmmUShrWord cmmAddWord cmmSubWord cmmMulWord cmmQuotWord cmmNegate cmmToWord cmmMkAssigntAG_MASK mAX_PTR_TAG cmmTagMaskcmmPointerMaskcmmUntag cmmIsTaggedcmmIsNotTagged cmmConstrTag1 regsOverlap regUsedIn mkLiveness modifyGraph ofBlockMaptoBlockListEntryFirst%toBlockListEntryFirstFalseFallthrough ofBlockList mapGraphNodesmapGraphNodes1foldlGraphBlocks blockTicksbaseExprspExpr spLimExprhpExpr hpLimExprcurrentTSOExprcurrentNurseryExprcccsExpr closureName closureLFInfoclosureInfoLabel CallMethodEnterItJumpToItReturnItInferedReturnItSlowCall DirectEntryDynTagNonVoidCgLocCmmLocLneLoc isKnownFun fromNonVoid nonVoidIdsassertNonVoidIdsnonVoidStgArgsassertNonVoidStgArgs addIdReps addArgReps argPrimRep mkLFArgumentmkLFLetNoEscape mkLFReEntrant mkLFThunk mkConLFInfomkSelectorLFInfo mkApLFInfo mkLFImported mkLFStringLit isSmallFamily tagForCon tagForAritylfDynTag isLFThunk isLFReEntrantnodeMustPointToIt getCallMethod mkCmmInfo mkClosureInfoblackHoleOnEntryisStaticClosureclosureUpdReqd lfUpdatableclosureReEntrantclosureFunInfofunTagisToplevClosurestaticClosureLabelclosureSlowEntryLabelclosureLocalEntryLabelmkClosureInfoTableLabelmkDataConInfoTablecafBlackHoleInfoTableindStaticInfoTablestaticClosureNeedsLink$fOutputablePPlatformCgLoc$fOutputableNonVoid$fOutputableCallMethod $fEqNonVoid $fShowNonVoidArgRepPNVFV16V32V64 argRepStringtoArgRepisNonV argRepSizeWidArgRepslowCallPattern$fOutputableArgRep $fEqArgReprewriteTopBinds$fMonadUniqueRM $fFunctorRM $fMonadRM$fApplicativeRM baseRegOffsetget_GlobalReg_addrregTableOffsetget_Regtable_addr_from_offsetfixStgRegisterscmmImplementSwitchPlansconstantFoldNodeconstantFoldExpr cmmMachOpFoldcmmMachOpFoldM InitOrFini IsInitArray IsFiniArrayisInitOrFiniArraycmmToC $fFunctorTE$fApplicativeTE $fMonadTE UnwindExprUwConstUwRegUwDerefUwLabelUwPlusUwMinusUwTimes UnwindTable UnwindPoint DebugBlock dblProceduredblLabel dblCLabel dblHasInfoTbl dblParentdblTicks dblSourceTick dblPosition dblUnwind dblBlocks cmmDebugGencmmDebugLabels cmmDebugLink debugToMappprUnwindTable toUnwindExpr$fOutputablePPlatformUnwindExpr $fOutputablePPlatformUnwindPoint$fOutputablePPlatformDebugBlock$fEqUnwindExprDestImmPrefetchVariantNTALvl0Lvl1Lvl2UNWINDCMOVMOVZxLMOVSxLLEAADCSBBMUL2IMULIMUL2DIVIDIVADD_CCSUB_CCORXORNOTNEGIBSWAPSHLSARSHRBTNOPX87StoreCVTSS2SDCVTSD2SS CVTTSS2SIQ CVTTSD2SIQCVTSI2SSCVTSI2SDFDIVSQRTTESTSETCCPUSHPOPJMPJXXJXX_GBLJMP_TBLCALLCLTDFETCHGOTFETCHPCPOPCNTLZCNTTZCNTBSFBSRPDEPPEXTPREFETCHLOCKXADDCMPXCHGXCHGMFENCEarchWordFormat RegCode64Reg64NatM DwarfFiles NatM_Statenatm_us natm_delta natm_importsnatm_pic natm_config natm_fileidnatm_debug_mapnatm_cfgNcgImpl ncgConfig cmmTopCodeGengenerateJumpTableForInstrpprNatCmmDeclSpprNatCmmDeclHncgAllocMoreStackncgMakeFarBranchesextractUnwindPointsinvertCondBranches mkNatM_StateinitNat getUniqueNat getDeltaNat getCfgWeights setDeltaNatgetThisModuleNat addImportNat updateCfgNataddNodeBetweenNataddImmediateSuccessorNat getBlockIdNatgetNewLabelNat getNewRegNat getNewReg64 localReg64getPicBaseMaybeNat getPicBaseNat getFileId getDebugBlock$fHasModuleNatM$fMonadUniqueNatM $fFunctorNatM$fApplicativeNatM $fMonadNatM sequenceTopbackendMaintainsCfg$fOutputableBlockChain$fOrdBlockChain$fEqBlockChainDwarfFrameBlockdwFdeBlkHasInfo dwFdeUnwindDwarfFrameProc dwFdeProc dwFdeHasInfo dwFdeBlocks DwarfFrame dwCieLabel dwCieInit dwCieProcs DwarfARangedwArngStartLabeldwArngEndLabel DwarfInfoDwarfCompileUnitDwarfSubprogram DwarfBlock DwarfSrcNote dwChildrendwName dwProducer dwCompDir dwLowLabel dwHighLabeldwLabeldwParentdwMarker dwSrcSpanpprAbbrevDecls pprDwarfInfopprDwarfARanges pprDwarfFrame wordAlignpprBytepprHalf pprData4' pprDwWordpprWord pprLEBWord pprLEBInt sectionOffset$$fOutputablePPlatformDwarfFrameBlock$fEqDwarfAbbrev$fEnumDwarfAbbrevdwarfGen RewriteFun TransferFunDataflowLatticefact_bot fact_join JoinedFactChanged NotChangedNewFactOldFactFact changedIf analyzeCmmBwd analyzeCmmFwd rewriteCmmBwdgetFact joinOutFacts joinFacts mkFactBasefoldNodesBwdOOfoldRewriteNodesBwdOO CmmLocalLive liveLatticecmmLocalLivenesscmmGlobalLivenessgen_kill liveLatticeLcmmLocalLivenessL gen_killLcmmSinkGraphWithDominators gwd_graphgwd_dominatorsgwd_rpnumberingRPNum DominatorSetImmediateDominator EntryNodeds_label ds_parentdominatorsMemberintersectDominatorsgraphWithDominators gwdRPNumbergwdDominatorsOfgwdDominatorTree$fOutputableDominatorSet$fOutputableRPNum $fShowRPNum $fEqRPNum $fOrdRPNum$fEqDominatorSetstructuredControl$fOutputableContainingSyntax$fOutputableContextalignmentFromWordTypeglobalInfoFromCmmGlobalRegsupportedCmmGlobalRegs onCmmGroup execWasmAsmMasmTellEverything$fMonoidWasmAsmM$fSemigroupWasmAsmM$fFunctorWasmAsmM$fApplicativeWasmAsmM$fMonadWasmAsmMncgWasm Reducibility Reducible Irreducible reducibility asReducible"$fSupernodeCmmSuperNullCollapseViz$fPureSupernodeCmmSuper$fSemigroupCmmSuper$fEqReducibility$fShowReducibility ParamLocation RegisterParam StackParamassignArgumentsPos assignStackrealArgRegsCoverallArgRegsCover$fOutputableParamLocationcmmLint cmmLintGraph$fFunctorCmmLint$fApplicativeCmmLint$fMonadCmmLintTransferJumpRetJumpRetCgStmtCgLabelCgLastCgForkCmmAGraphScoped CmmAGraph catAGraphsmkLabelmkMiddlemkLast outOfLinelgraphOfAGraph labelAGraphmkNopmkAssignmkStoremkJump mkRawJump mkJumpExtra mkCbranchmkSwitchmkReturnmkBranch mkFinalCallmkCallReturnsTomkJumpReturnsTo mkUnsafeCallmkUnwind stackStubExpr copyInOflow copyOutOflow mkCallEntry noExtraStacktoCall $fEqTransferVirtualHpOffset HeapUsagevirtHprealHpCgState MkCgState cgs_stmtscgs_tops cgs_binds cgs_hp_usg cgs_uniqs ReturnKindAssignedDirectly ReturnedToCgIdInfocg_idcg_lfcg_locFCodeinitCrunCfixCheapHWM initHpUsagegetStatesetState getHpUsage setHpUsage setVirtHp getVirtHp setRealHpgetBindssetBinds newUniquenewTempinitFCodeState getSelfLoop withSelfLoop withSequel getSequelwithUpdFrameOffgetUpdFrameOffgetTickyCtrLabelsetTickyCtrLabel getTickScope tickScopegetStgToCmmConfig getProfile getContext getModuleNameforkClosureBody forkLneBodycodeOnlyforkAlts forkAltPairgetCodeRgetCode getCodeScoped getHeapUsage emitLabel emitCommentemitTick emitUnwind emitAssign emitStore emitStore'emitemitDecl emitOutOfLineemitProcWithStackFrameemitProcWithConventiongetCmmmkCmmIfThenElsemkCmmIfThenElse' mkCmmIfGoto mkCmmIfGoto' mkCmmIfThen mkCmmIfThen'mkCall mkCmmCall aGraphToGraph$fOutputablePPlatformCgIdInfo$fMonadUniqueFCode $fMonadFCode$fApplicativeFCode$fFunctorFCodeCmmParseunECVarNFunNLabelN loopDeclswithNamenewLocalnewLabelnewFunctionName newImport lookupLabel lookupNamecode$fMonadUniqueCmmParse$fMonadCmmParse$fApplicativeCmmParse$fFunctorCmmParse litIdInfo lneIdInfo rhsIdInfo mkRhsInit idInfoToAmodemaybeLetNoEscapeaddBindC addBindsC getCgIdInfogetCgInfo_maybe bindToReg rebindToReg bindArgToRegbindArgsToRegsidToReg newStringCLitnewByteStringCLitcgLit mkSimpleLitIPEStats ipe_totalipe_closure_types ipe_fallback ipe_skipped addToMemLbl addToMemLblEaddToMem addToMemEmkTaggedObjectLoad tagToClosureemitBarf emitRtsCallemitRtsCallWithResultemitRtsCallGencallerSaveVolatileRegscallerSaveGlobalRegcallerRestoreGlobalReg emitDataLitsemitRODataLits emitDataCon assignTempnewUnboxedTupleRegsemitMultiAssign emitSwitchemitCmmLitSwitchwhenUpdRemSetEnabledemitUpdRemSetPushemitUpdRemSetPushThunkcmmInfoTableToInfoProvEntfallbackIpeStatsclosureIpeStatsskippedIpeStatsconvertInfoProvMap$fOutputableIPEStats$fMonoidIPEStats$fSemigroupIPEStats mkTickBoxinitHpc annotateTSANemitIpeBufferListNode cmmCfgOptscmmCfgOptsProc replaceLabelsremoveUnreachableBlocksProcelimCommonBlocksmkEmptyContInfoTable cmmToRawCmm srtEscapeclosureInfoPtr entryCode getConstrTagcmmGetClosureType infoTableinfoTableConstrTaginfoTableSrtBitmapinfoTableClosureType infoTablePtrsinfoTableNonPtrs funInfoTable funInfoAritystdInfoTableSizeWfixedInfoTableSizeWprofInfoTableSizeWmaxStdInfoTableSizeWmaxRetInfoTableSizeWstdInfoTableSizeBstdSrtBitmapOffsetstdClosureTypeOffset stdPtrsOffsetstdNonPtrsOffsetconInfoTableSizeBcheckFunctionArgTagscheckConArgsStaticcheckConArgsDyn whenCheckTagsemitTagAssertionemitArgTagCheckcheckArgcheckArgStaticLDLDFARLASTFARSTUSTCLISLIMRCMPLBCCBCCFARMTCTRBCTRBCTRLADDOADDCADDEADDZEADDISSUBFSUBFOSUBFCSUBFEMULLMULLOMFOVMULHUANDCNANDORISXORISEXTSCNTLZSLSRSRARLWINMCLRLICLRRIFADDFSUBFMULFNEGFCMPFCTIWZFCTIDZFCFIDFRSPCRNORMFCRMFLRHWSYNCISYNCLWSYNCRIRIRegRIImmmakeFarBranchesFR frAllocateReg frGetFreeRegsfrInitFreeRegs frReleaseReg $fFRFreeRegs $fFRFreeRegs0 $fFRFreeRegs1 $fFRFreeRegs2 joinToTargetsCmmMakeDynamicReferenceM addImport ReferenceKind DataReference CallReference JumpReferencecmmMakeDynamicReferenceneedImportedSymbolspprGotDeclarationpprImportedSymbolinitializePicBase_ppcinitializePicBase_x86$fCmmMakeDynamicReferenceMNatM$fEqReferenceKind InstrBlockncgX86 ncgX86_64$fInstructionInstrncgPPC ncgAArch64Status ReachedBy ProcPoint ProcPointSetprocPointAnalysiscallProcPointsminimalProcPointSetsplitAtProcPointsattachContInfoTables$fOutputableStatuslintStgTopBindings LogQueueQueueLogQueue logQueueIdlogQueueMessageslogQueueSemaphore newLogQueuefinishLogQueue writeLogQueue parLogActionnewLogQueueQueue initLogQueue allLogQueues logThread FunDepEqnFDEqnfd_qtvsfd_eqsfd_pred1fd_pred2fd_loc pprEquationinstFDimproveFromAnotherimproveFromInstEnvcheckInstCoveragecloseWrtFunDeps checkFunDeps$fOutputableFunDepEqn$fFunctorFunDepEqn hsLPatType hsPatType hsLitType lhsExprType hsExprType hsWrapperTypeLiftM FloatLangStartBindingGroupEndBindingGroupPlainTopBinding LiftedBindinge_confige_subst e_expansionsdecomposeStgBinding mkStgBinding collectFloatsrunLiftMaddTopStringLitstartBindingGroupendBindingGroupaddLiftedBinding withSubstBndrwithSubstBndrswithLiftedBndrwithLiftedBndrssubstOccisLiftedformerFreeVars$fOutputableFloatLang$fMonadUniqueLiftM$fFunctorLiftM$fApplicativeLiftM $fMonadLiftM LibCaseOpts lco_thresholdlco_unfolding_opts liberateCase doStaticArgsexitifyProgram cseProgram cseOneExprgenExpr genEntryTypegenBody loadLiveFungenStaticRefsRhs genStaticRefs $fEqBranch$fFunctorBranchstgToJS CoreToStgOptscoreToStg_platformcoreToStg_ways"coreToStg_AutoSccsOnIndividualCafscoreToStg_InfoTableMapcoreToStg_ExternalDynamicRefscoreToStg_stgDebugOpts coreToStg $fMonadCtsM$fApplicativeCtsM $fFunctorCtsM $fEqHowBound $fEqLetInfocallArityAnalProgram callArityRHS StaticPtrOpts opt_platform opt_gen_cstub opt_mk_stringopt_static_ptr_info_dataconopt_static_ptr_dataconsptCreateStaticBindssptModuleInitCode FloatSpecFloatMeStayPut LevelTypeBndrLvl JoinCeilLvlLevel LevelledBndr LevelledBind LevelledExprfloatSpecLevel tOP_LEVEL incMinorLvl asJoinCeilLvlltLvlltMajLvlisTopLvl isJoinCeilLvl setLevels $fEqLevel$fOutputableLevel$fOutputableFloatSpec $fEqLevelType floatOutwards$fOutputableFloatBinds floatInwards$fOutputableFloatInBindIsRecDataConResultDefinitelyRecursiveNonRecursiveOrUnsureUnboxingDecision DontUnboxDoUnbox DropAbsentDataConPatContextdcpc_dc dcpc_tc_argsdcpc_co dcpc_argsWwOptsMkWwOpts wo_fam_envswo_simple_opts wo_cpr_anal wo_modulewo_unlift_strict mkWwBodiesisWorkerSmallEnoughneedsVoidWorkerArg boringSplit usefulSplit canUnboxArgmkWWstr mkWWstr_onemkAbsentFillerdubiousDataConInstArgTys findTypeShape isRecDataCon$fOutputableUnboxingDecision$fOutputableIsRecDataConResult$fEqIsRecDataConResult$fShowIsRecDataConResult DmdAnalOptsdmd_strict_dicts dmd_do_boxitydmd_unbox_widthdmd_max_worker_argsdmdAnalProgram$fOutputableAnalEnvcprAnalProgram$fOutputableSigEnv wwTopBindsevDelayedError evCallStack BuildMessageBuildMsg BuildErrorEOFenableProcessJobsreadCreateProcessWithExitCode' replaceVarreadProcessEnvWithExitCode c_locale_env getGccEnv runSomethingrunSomethingResponseFilerunSomethingFilteredrunSomethingWith handleProcbuilderMainLoop readerProc parseError breakColon breakIntColon linesPlatformneededLinkArgs getLinkerInfogetLinkerInfo'getCompilerInfogetAssemblerInfogetCompilerInfo'runUnlitaugmentImportsrunCpprunPprunCc isContainedInaskLdrunAs runLlvmOpt runLlvmLlcrunClang runEmscriptenfigureLlvmVersionrunLinkrunMergeObjectsrunAraskOtoolrunInstallNameTool runRanlib runWindrestouchJSOptionCPPgetInstalledPackageLibDirsgetInstalledPackageHsLibs commonCppDefs jsExeFileNamegetOptionsFromJsFile $fEqJSOption $fOrdJSOption inferTagsfingerprintDynFlagsfingerprintOptFlagsfingerprintHpcFlagsinitStgToJSConfiginitStgToCmmConfiginitStgPprOptsinitStgLiftConfiginitStgDebugOptsinitFrameworkOptsinitTicksConfig initBangOptsinitFinderOptsinitCoreToStgOpts initRuleOptsinitLiberateCaseOpts initArityOptsinitLlvmCgConfig initNCGConfig initCmmConfiginitFinderCacheflushFinderCacheslookupFileCachefindImportedModulefindPluginModulefindExactModulefindExposedPackageModuleaddModuleToFinderaddHomeModuleToFinder uncacheModulefindHomeModulemkHomeModLocationmkHomeModLocation2mkHiOnlyModLocation mkObjPathmkHiPath mkStubPathsfindObjectLinkableMaybefindObjectLinkableBCOOpts bco_n_jobs interpCmd withIServ withIServ_evalStmt abandonStmtevalIO evalStringevalStringToIOString mallocData mkCostCentres createBCOs addSptEntrycostCentreStackInfo newBreakArraystoreBreakpointbreakpointStatusgetBreakpointVar getClosure seqHValue initObjLinker lookupSymbol lookupClosurepurgeLookupSymbolCacheloadDLL loadArchive unloadObjaddLibrarySearchPathremoveLibrarySearchPath resolveObjsfindSystemLibrary iservCall readIServ writeIServ stopInterpmkFinalizedHValuefreeHValueRefswormhole wormholeReffromEvalResult getModBreaksinterpreterProfiledinterpreterDynamic mkModBreaksinitOptCoercionOptsinitSimpleOpts initBCOOpts initEvalOptsinitWorkWrapOptslinkBCOlookupStaticPtrlookupIElinkFail nameToCLabelgetUnitLinkOptscollectLinkOptscollectArchivesgetLibsrunInjectRPathsgetUnitFrameworkOptsgetFrameworkOpts loadFramework mkExtraObjmkExtraObjToLinkIntoBinarymkNoteObjsToLinkIntoBinary getLinkInfoplatformSupportsSavingLinkOptsghcLinkInfoSectionNameghcLinkInfoNoteName checkLinkInfohaveRtsOptsFlags initSysTools copyHandlecopyWithHeaderCppOptscppUseCccppLinePragmasdoCppgetGhcVersionPathName applyCDefsoffsetIncludePaths jsLinkBinary embedJsFilemaybeCreateManifest linkDynLib libmLinkOpts linkBinary linkStaticLibspecConstrProgram$fOutputableValue$fOutputableHowBound$fOutputableCall$fOutputableArgOcc$fOutputableScUsage$fOutputableCallPatLlvmM UnresStatic UnresLabelLlvmData LlvmUnresDataLiveGlobalRegsLlvmBasicBlock LlvmCmmDecl cmmToLlvmTypewidthToLlvmFloatwidthToLlvmInt llvmFunTy llvmFunSig llvmFunAlign llvmInfAlignllvmFunSection llvmFunArgsisFPR padLiveArgsllvmStdFunAttrs tysToParams llvmPtrBitsrunLlvm withClearVars varInsert funInsert varLookup funLookup markStackReg checkStackReggetMetaUniqueId getLlvmVer dumpIfSetLlvm renderLlvm markUsedVar getUsedVars setUniqMeta getUniqMetaghcInternalFunctionsstrCLabel_llvm getGlobalPtr llvmDefLabelgenerateExternDeclsaliasify$fMonadUniqueLlvmM$fHasLoggerLlvmM$fFunctorLlvmM$fApplicativeLlvmM $fMonadLlvmM genLlvmDatagenData pprLlvmDatapprLlvmCmmDecl infoSection genLlvmProc$fMonoidLlvmAccum$fSemigroupLlvmAccum $fEqSignage $fShowSignage llvmCodeGen nativeCodeGen cmmNativeGen!$fCmmMakeDynamicReferenceMCmmOptM$fMonadCmmOptM$fApplicativeCmmOptM$fFunctorCmmOptM codeOutputoutputForeignStubsprofilingInitCode ipInitCodeccsTypeccType storeCurCCS mkCCostCentremkCCostCentreStackcostCentreFrom staticProfHdr dynProfHdrinitUpdFrameProfsaveCurrentCostCentrerestoreCurrentCostCentre profDynAlloc profAllocinitInfoTableProv emitSetCCCldvRecordCreateldvEnterClosureldvEnter emitPrimCallwithNewTickyCounterFunwithNewTickyCounterLNEwithNewTickyCounterThunkwithNewTickyCounterStdThunkwithNewTickyCounterConemitTickyCounterTagtickyPushUpdateFrametickyUpdateFrameOmittedtickyEnterDynContickyEnterThunktickyUpdateBhCaf tickyEnterFun tickyEnterLNEtickyReturnOldContickyReturnNewContickyUnboxedTupleReturntickyDirectCalltickyKnownCallTooFewArgstickyKnownCallExacttickyKnownCallExtraArgs tickySlowCalltickySlowCallPat tickyDynAlloctickyAllocHeaptickyAllocPrimtickyAllocThunk tickyAllocPAPtickyHeapChecktickyStackCheck tickyTagged tickyUntagged tickyTagSkip$fToJsonTickyClosureType ClosureHeaderNoHeader StdHeader ThunkHeaderFieldOffOrPaddingFieldOffPadding emitReturnemitCalladjustHpBackwards directCallslowCallgetHpRelOffsetmkVirtHeapOffsetsWithPaddingmkVirtHeapOffsetsmkVirtConstrOffsetsmkVirtConstrSizes mkArgDescr getArgAmodegetNonVoidArgAmodesemitClosureProcAndInfoTableemitClosureAndInfoTable cgForeignCall emitCCallemitCCallNeverReturnsemitForeignCallemitSaveThreadStatesaveThreadState emitSaveRegsemitRestoreRegsemitPushArgRegsemitPopArgRegsemitCloseNurseryemitLoadThreadStateloadThreadStateemitOpenNursery BinderInfo BindsClosure BoringBinderSkeleton ClosureSkRhsSkAltSkBothSkNilSkbinderInfoBndrtagSkeletonTopBind goodToLift closureGrowth$fOutputableSkeleton$fOutputableBndrBinderInfo$fOutputableBinderInfo stgLiftLamsBCInstrSTKCHECKPUSH_LPUSH_LLPUSH_LLLPUSH8PUSH16PUSH32PUSH8_WPUSH16_WPUSH32_WPUSH_G PUSH_PRIMOPPUSH_BCO PUSH_ALTSPUSH_ALTS_TUPLE PUSH_PAD8 PUSH_PAD16 PUSH_PAD32 PUSH_UBX8 PUSH_UBX16 PUSH_UBX32PUSH_UBX PUSH_ADDR PUSH_APPLY_N PUSH_APPLY_V PUSH_APPLY_F PUSH_APPLY_D PUSH_APPLY_L PUSH_APPLY_P PUSH_APPLY_PPPUSH_APPLY_PPPPUSH_APPLY_PPPPPUSH_APPLY_PPPPPPUSH_APPLY_PPPPPPSLIDEALLOC_APALLOC_AP_NOUPD ALLOC_PAPMKAPMKPAPUNPACKPACKLABELTESTLT_ITESTEQ_ITESTLT_WTESTEQ_W TESTLT_I64 TESTEQ_I64 TESTLT_I32 TESTEQ_I32 TESTLT_I16 TESTEQ_I16 TESTLT_I8 TESTEQ_I8 TESTLT_W64 TESTEQ_W64 TESTLT_W32 TESTEQ_W32 TESTLT_W16 TESTEQ_W16 TESTLT_W8 TESTEQ_W8TESTLT_FTESTEQ_FTESTLT_DTESTEQ_DTESTLT_PTESTEQ_PCASEFAILCCALLPRIMCALLSWIZZLEENTERRETURN RETURN_TUPLEBRK_FUN LocalLabel getLocalLabelProtoBCO protoBCONameprotoBCOInstrsprotoBCOBitmapprotoBCOBitmapSize protoBCOArity protoBCOExpr protoBCOFFIs bciStackUse$fOutputableLocalLabel$fOutputableBCInstr$fOutputableProtoBCO$fEqLocalLabel$fOrdLocalLabelmkITbls bcoFreeNames assembleBCOsassembleOneBCOmkNativeCallInfoLitiNTERP_STACK_CHECK_THRESH$fMonadAssembler$fApplicativeAssembler$fFunctorAssembler byteCodeGen$fOutputableDiscr$fHasDynFlagsBcM $fMonadBcM$fApplicativeBcM $fFunctorBcM $fEqDiscr $fOrdDiscrallocDynClosureallocDynClosureCmmallocHeapClosure emitSetDynHdrmkStaticClosureFieldsmkStaticClosureentryHeapCheckentryHeapCheck' altHeapCheckaltHeapCheckReturnsTonoEscapeHeapCheckheapStackCheckGenSRTMap ModuleSRTInfo thisModule dedupSRTsflatSRTs moduleSRTMapCAFEnvCAFSet cafAnalDatacafAnalemptySRT srtMapNonCAFsdoSRTs$fOutputablePenvSomeLabel$fOutputablePenvModuleSRTInfo $fEqSomeLabel$fOrdSomeLabel $fEqSRTEntry $fOrdSRTEntry$fEqCAFfyLabel$fOrdCAFfyLabel$fOutputablePenvSRTEntry$fOutputablePenvCAFfyLabelcgOpAppshouldInlinePrimOpcmmLayoutStacksetInfoTableStackMap$fOutputableStackMap$fOutputableStackSlot cmmPipelinegenerateCgIPEStublookupEstimatedTicks typeNatTyConstypeNatAddTyContypeNatSubTyContypeNatMulTyContypeNatDivTyContypeNatModTyContypeNatExpTyContypeNatLogTyContypeNatCmpTyContypeSymbolCmpTyContypeSymbolAppendTyContypeConsSymbolTyContypeUnconsSymbolTyContypeCharToNatTyContypeNatToCharTyContypeNatCoAxiomRulestypeCharCmpTyCon knownKeyNameslookupKnownKeyNameisKnownKeyNamelookupKnownNameInfoghcPrimExportsghcPrimDeclDocsmaybeCharLikeConmaybeIntLikeConisNumericClassisStandardClass cgTopRhsCon buildDynCon bindConArgscgBindcgExprcgTopRhsClosureemitBlackHoleCodepushUpdateFrameemitUpdateFramecodeGenHieName ExternalName LocalName KnownKeyName TyVarScopeResolvedScopesUnresolvedScopeScope LocalScope ModuleScopeDeclTypeFamDecSynDecDataDecConDec PatSynDecClassDecInstDecBindType RegularBind InstanceBindRecFieldContext RecFieldDeclRecFieldAssign RecFieldMatch RecFieldOccImportImportAs ImportHidingExport EvBindDeps getEvBindDeps EvVarSource EvPatternBind EvSigBind EvWrapperBindEvImplicitBind EvInstBind EvLetBind isSuperInstcls ContextInfoUse MatchBindIEThingTyDeclValBind PatternBind ClassTyDeclDecl TyVarBindRecFieldEvidenceVarBindEvidenceVarUseIdentifierDetails identType identInfoNodeIdentifiers IdentifierNodeInfonodeAnnotationsnodeTypenodeIdentifiersNodeAnnotationnodeAnnotConstr nodeAnnotType NodeOrigin SourceInfo GeneratedInfoSourcedNodeInfogetSourcedNodeInfoHieASTsourcedNodeInfonodeSpan nodeChildrenHieASTsgetAstsHiePathHieArgs HieTypeFixRoll HieTypeFlatHieTypeHTyVarTyHAppTy HTyConApp HForAllTyHFunTyHQualTyHLitTyHCastTy HCoercionTy TypeIndexHieFile hie_hs_file hie_module hie_typeshie_asts hie_exports hie_hs_srcSpan hieVersion pprNodeIdents pprIdentifier pprBindSpan hieNameOcc toHieName$fBinaryHieArgs$fBinaryHieType$fBinaryNodeOrigin$fOutputableNodeOrigin$fBinaryNodeAnnotation$fOutputableNodeAnnotation$fOrdNodeAnnotation$fBinaryEvBindDeps$fOrdEvBindDeps$fEqEvBindDeps$fOutputableEvVarSource$fBinaryEvVarSource$fBinaryIEType$fOutputableIEType$fBinaryRecFieldContext$fOutputableRecFieldContext$fBinaryBindType$fOutputableBindType$fBinaryDeclType$fOutputableDeclType $fBinaryScope$fOutputableScope$fBinaryTyVarScope$fOutputableTyVarScope$fBinaryContextInfo$fOutputableContextInfo$fBinaryIdentifierDetails$fMonoidIdentifierDetails$fSemigroupIdentifierDetails$fOutputableIdentifierDetails$fOutputableNodeInfo$fBinaryNodeInfo$fOutputableSourcedNodeInfo$fBinarySourcedNodeInfo$fOutputableHieAST$fBinaryHieAST$fOutputableHieASTs$fBinaryHieASTs$fBinaryHieFile$fOutputableHieName $fOrdHieName $fEqHieName$fFunctorHieASTs$fFoldableHieASTs$fTraversableHieASTs$fFunctorHieAST$fFoldableHieAST$fTraversableHieAST$fFunctorSourcedNodeInfo$fFoldableSourcedNodeInfo$fTraversableSourcedNodeInfo$fFunctorNodeInfo$fFoldableNodeInfo$fTraversableNodeInfo$fEqIdentifierDetails$fFunctorIdentifierDetails$fFoldableIdentifierDetails$fTraversableIdentifierDetails$fEqContextInfo$fOrdContextInfo$fEqTyVarScope$fOrdTyVarScope $fEqScope $fOrdScope $fDataScope $fEqDeclType $fOrdDeclType$fEnumDeclType $fEqBindType $fOrdBindType$fEnumBindType$fEqRecFieldContext$fEnumRecFieldContext$fOrdRecFieldContext $fEqIEType $fEnumIEType $fOrdIEType$fEqEvVarSource$fOrdEvVarSource$fOutputableEvBindDeps$fEqNodeAnnotation$fEqNodeOrigin$fEnumNodeOrigin$fOrdNodeOrigin$fEqHieTypeFix$fFunctorHieType$fFoldableHieType$fTraversableHieType $fEqHieType$fFunctorHieArgs$fFoldableHieArgs$fTraversableHieArgs $fEqHieArgs HieTypeStateHTStyMaphtyTable freshIndex EvidenceInfo evidenceVar evidenceSpan evidenceTypeevidenceDetailsRefMapgenerateReferencesMap renderHieTyperesolveVisibilityfoldType selectPointfindEvidenceUsegetEvidenceTreesAtPointgetEvidenceTreehieTypeToIface initialHTSfreshTypeIndex compressTypesrecoverFullType getTypeIndexresolveTyVarScopesresolveTyVarScopeLocalgetNameBinding getNameScopegetNameBindingInClassgetNameScopeAndBindinggetScopeFromContextgetBindSiteFromContext flattenAstsmallestContainingSatisfyingselectLargestContainedByselectSmallestContaining definedInAstsgetEvidenceBindDepsisEvidenceBindisEvidenceContext isEvidenceUse isOccurrencescopeContainsSpan combineAst insertAstnodeInfo emptyNodeInfosourcedNodeIdentscombineSourcedNodeInfocombineNodeInfo mergeAstsrightOfleftOf startsRightOf mergeSortAstssimpleNodeInfolocOnlymkScopeAmkScopemkLScope mkLScopeA mkLScopeN combineScopesmkSourcedNodeInfo makeNodeAmakeNode makeTypeNodeA makeTypeNode$fOutputableEvidenceInfo$fEqEvidenceInfo$fOrdEvidenceInfo$fFunctorEvidenceInfo DiffIdentDiffdiffFilediffAstsdiffAstnormalizeIdentsdiffListeqDiffvalidAstvalidateScopes HieHeader HieFileResulthie_file_result_versionhie_file_result_ghc_versionhie_file_resulthieMagic writeHieFilereadHieFileWithVersion readHieFile badIfaceFilehiModuleNameMismatchWarn homeModErrorcannotFindInterfacecantFindInstalledErrmayShowLocationscannotFindModule cantFindErrMonadPaddError addWarning addFatalErrorgetBitallocateCommentsPallocatePriorCommentsPallocateFinalCommentsPExtBitsFfiBitInterruptibleFfiBit CApiFfiBit ArrowsBitThBit ThQuotesBitIpBitOverloadedLabelsBitExplicitForallBit BangPatBitPatternSynonymsBit HaddockBit MagicHashBitRecursiveDoBitQualifiedDoBitUnicodeSyntaxBitUnboxedParensBitDatatypeContextsBitMonadComprehensionsBitTransformComprehensionsBitQqBitRawTokenStreamBitAlternativeLayoutRuleBitALRTransitionalBitRelaxedLayoutBitNondecreasingIndentationBitSafeHaskellBitTraditionalRecordSyntaxBitExplicitNamespacesBit LambdaCaseBitBinaryLiteralsBitNegativeLiteralsBitHexFloatLiteralsBitStaticPointersBitNumericUnderscoresBit StarIsTypeBitBlockArgumentsBitNPlusKPatternsBitDoAndIfThenElseBit MultiWayIfBit GadtSyntaxBitImportQualifiedPostBitLinearTypesBitNoLexicalNegationBitOverloadedRecordDotBitOverloadedRecordUpdateBit InRulePragBitInNestedCommentBitUsePosPragsBitunPPStatebufferoptionswarningserrors tab_first tab_countlast_tkprev_loc prev_loc2last_loclast_lenloc lex_statesrcfilesalr_pending_implicit_tokensalr_next_token alr_last_loc alr_contextalr_expecting_ocurlyalr_justClosedExplicitLetBlockeof_posheader_comments comment_q hdk_comments HdkCommentHdkCommentNextHdkCommentPrevHdkCommentNamedHdkCommentSection ParserOpts pExtsBitmap pDiagOptspSupportedExts ParseResultTokenITasITcaseITclassITdata ITdefault ITderivingITdoITelseIThiding ITforeignITifITimportITinITinfixITinfixlITinfixr ITinstanceITletITmodule ITnewtypeITof ITqualifiedITthenITtypeITwhereITforallITexportITlabel ITdynamicITsafeITinterruptibleITunsafe ITstdcallconv ITccallconv ITcapiconvITprimcallconvITjavascriptcallconvITmdoITfamilyITroleITgroupITbyITusing ITpatternITstaticITstock ITanyclassITviaITunit ITsignature ITdependency ITrequires ITinline_prag ITopaque_prag ITspec_pragITspec_inline_prag ITsource_prag ITrules_pragITwarning_pragITdeprecated_prag ITline_prag ITcolumn_prag ITscc_prag ITunpack_pragITnounpack_prag ITann_pragITcomplete_prag ITclose_pragIToptions_pragITinclude_pragITlanguage_pragITminimal_pragIToverlappable_pragIToverlapping_pragIToverlaps_pragITincoherent_pragITctypeITcomment_line_pragITdotdotITcolonITdcolonITequalITlamITlcaseITlcasesITvbarITlarrowITrarrowITdarrowITlollyITminus ITprefixminusITbangITtildeITat ITtypeApp ITpercentITstarITdotITprojITbiglamITocurlyITccurly ITvocurly ITvccurlyITobrack ITopabrack ITcpabrackITcbrackIToparenITcparen IToubxparen ITcubxparenITsemiITcomma ITunderscore ITbackquote ITsimpleQuoteITvaridITconidITvarsymITconsymITqvaridITqconid ITqvarsym ITqconsym ITdupipvarid ITlabelvaridITcharITstring ITinteger ITrational ITprimchar ITprimstring ITprimint ITprimword ITprimfloat ITprimdoubleITopenExpQuoteITopenPatQuoteITopenDecQuoteITopenTypQuote ITcloseQuoteITopenTExpQuoteITcloseTExpQuoteITdollarITdollardollar ITtyQuote ITquasiQuote ITqQuasiQuoteITprocITrec IToparenbar ITcparenbar ITlarrowtail ITrarrowtail ITLarrowtail ITRarrowtail ITunknownITeof ITdocComment ITdocOptions ITlineCommentITblockCommentPFailedPOkwarnoptfailMsgP failLocMsgP getPState setSrcLoc getRealSrcLoc setLastToken adjustChar nextIsEOF pushLexState popLexState getLexState activeContextxtestxsetxunset mkParserOptsdisableHaddock initPragStateinitParserStategetCommentsForgetPriorCommentsForgetFinalCommentsFor getEofPos addPsMessagegetPsErrorMessages getPsMessages popContextpushModuleContext srcParseFaillexerlexerDbglexTokenStream mkParensEpAnnallocateCommentsallocatePriorCommentsallocateFinalCommentscommentToAnnotation$fOutputableToken$fMonadP$fApplicativeP $fFunctorP $fMonadPP $fEnumExtBits$fShowHdkComment$fShowLayoutContext $fShowToken $fShowOpWsPV ImpExpQcSpec ImpExpQcName ImpExpQcTypeImpExpQcWildcard ImpExpSubSpec ImpExpAbs ImpExpAll ImpExpList ImpExpAllWithDisambTDmkHsAppTyHeadPV mkHsAppTyPVmkHsAppKindTyPV mkHsOpTyPVmkUnpackednessPV DisambECPInfixOpFunArg ecpFromCmd' ecpFromExp'mkHsProjUpdatePV mkHsLamPV mkHsLetPV superInfixOp mkHsOpAppPV mkHsCasePV mkHsLamCasePV superFunArg mkHsAppPV mkHsAppTypePVmkHsIfPVmkHsDoPV mkHsParPV mkHsVarPV mkHsLitPV mkHsOverLitPVmkHsWildCardPV mkHsTySigPVmkHsExplicitListPV mkHsSplicePV mkHsRecordPV mkHsNegAppPVmkHsSectionR_PV mkHsViewPatPV mkHsAsPatPV mkHsLazyPatPV mkHsBangPatPVmkSumOrTuplePVrejectPragmaPV DisambInfixOp mkHsVarOpPV mkHsConOpPVmkHsInfixHolePVFbindECPunECPUnpackednessPragma RuleTyTmVar LRuleTyTmVarmkTyClDmkInstD mkClassDeclmkTyData mkTySynonymmkStandaloneKindSigmkTyFamInstEqn mkDataFamInst mkTyFamInst mkFamDecl mkSpliceDeclmkRoleAnnotDeclfromSpecTyVarBndrsfromSpecTyVarBndrannBindsfixValbindsAnn stmtsAnchorstmtsLoc cvTopDecls cvBindGroupmkPatSynMatchGroup mkConDeclH98 mkGadtDeclsetRdrNameSpace mkRuleBndrsmkRuleTyVarBndrscheckRuleTyVarBndrNamescheckRecordSyntaxcheckEmptyGADTscheckExpBlockArgumentscheckCmdBlockArguments checkContextcheckImportDecl checkPatterncheckPattern_detailsplaceHolderPunRhs checkValDefcheckValSigLhsmkBangTyaddUnpackednessPcheckMonadComp ecpFromExp ecpFromCmddataConBuilderCondataConBuilderDetails checkPrecPmkRecConstrOrUpdatemkRdrRecordUpdmkRdrRecordConmkInlinePragmamkOpaquePragmamkImport parseCImportmkExport mkExtNamemkModuleImpExp mkTypeImpExpcheckImportSpecmkImpExpSubSpecwarnPrepositiveQualifiedModule!failNotEnabledImportQualifiedPostfailImportQualifiedTwicewarnStarIsType failOpFewArgsrunPV hintBangPatmkMultTymkTokenLocationstarSym mkRdrGetFieldmkRdrProjection $fMonadPPV $fMonadPV$fApplicativePV$fDisambTDDataConBuilder$fDisambTDHsType$fDisambInfixOpRdrName$fDisambInfixOpHsExpr$fDisambECPPatBuilder$fDisambECPHsExpr$fDisambECPHsCmd $fFunctorPV$fFoldablePV_Result$fFunctorPV_Result$fTraversablePV_ResultconvertToHsDeclsconvertToHsExpr convertToPatconvertToHsTypethRdrNameGuesses $fMonadCvtM'$fApplicativeCvtM'$fCvtFlagSpecificitySpecificity $fCvtFlag()()$fFunctorCvtM'lexStringLiterallexHsDocCmmParserConfigcmmpParserOpts cmmpPDConfigcmmpStgToCmmConfigPDConfig pdProfilepdSanitizeAlignmentPDunPDliftP failMsgPD getPDConfig getHomeUnitId $fMonadPD$fApplicativePD $fFunctorPDinitParserOptsinitCmmParserConfig specProgram$fOutputableSpecEnv$fOutputableDictBind$fOutputableFloatedDictBinds$fOutputableSpecArg$fOutputableCallInfo$fOutputableCallInfoSetCmmToken CmmT_SpecChar CmmT_DotDotCmmT_DoubleColonCmmT_ShrCmmT_ShlCmmT_GeCmmT_LeCmmT_EqCmmT_Ne CmmT_BoolAnd CmmT_BoolOr CmmT_CLOSURECmmT_INFO_TABLECmmT_INFO_TABLE_RETCmmT_INFO_TABLE_FUNCmmT_INFO_TABLE_CONSTRCmmT_INFO_TABLE_SELECTOR CmmT_else CmmT_export CmmT_section CmmT_gotoCmmT_if CmmT_call CmmT_jump CmmT_foreign CmmT_never CmmT_prim CmmT_reserve CmmT_return CmmT_returns CmmT_import CmmT_switch CmmT_case CmmT_default CmmT_push CmmT_unwind CmmT_bits8 CmmT_bits16 CmmT_bits32 CmmT_bits64 CmmT_bits128 CmmT_bits256 CmmT_bits512 CmmT_float32 CmmT_float64 CmmT_gcptrCmmT_GlobalReg CmmT_Name CmmT_StringCmmT_Int CmmT_FloatCmmT_EOF CmmT_False CmmT_True CmmT_likely CmmT_Relaxed CmmT_Acquire CmmT_Release CmmT_SeqCstcmmlex$fShowCmmToken parseCmmFile extractDocsmkDocStructuremkDocStructureFromExportListmkDocStructureFromDeclsgetNamedChunksmkMapsgetMainDeclBinder sigNameNoLoc getInstLoc subordinates conArgDocs h98ConArgDocsgadtConArgDocs con_arg_docsisValD classDecls declTypeDocs nubByNametypeDocs sigTypeDocstopDeclsungroup collectDocs filterDecls filterClasses isUserSigmkDecls extractTHDocs unionArgMapsDsM DsMetaValDsBoundDsSplice DsMetaEnvDsLclEnvdsl_metadsl_loc dsl_nablasDsGblEnvds_modds_fam_inst_envds_gbl_rdr_envds_name_ppr_ctxds_msgs ds_if_envds_complete_matchesds_cc_stds_next_wrapper_num$fContainsModuleDsGblEnvinitSimplifyExprOptsinitSimplifyOpts initSimplModeinitGentleSimplModelintInteractiveExpr countEntriesccState collectCCsaddLateCostCentresMGaddLateCostCentresPgmaddLateCostCentres core2core LRenamingRenaming renameFromrenameTo IncludeDeclidUnitId idModRenamingidSignatureInclude LHsUnitDecl HsUnitDeclDeclDIncludeDLHsUnitHsUnit hsunitName hsunitBody LHsModuleId HsModuleId HsModuleVarLHsModuleSubst HsModuleSubst LHsUnitIdHsUnitId HsComponentId hsPackageName hsComponentId$fOutputableHsComponentIdparseIdentifieraddHaddockToModule$fMonoidLowerLocBound$fSemigroupLowerLocBound$fMonoidUpperLocBound$fSemigroupUpperLocBound$fMonoidColumnBound$fSemigroupColumnBound$fMonoidLocRange$fSemigroupLocRange$fApplicativeHdkA$fHasHaddockGenLocated$fHasHaddockGenLocated0$fHasHaddockHsWildCardBndrs$fHasHaddockHsScaled$fHasHaddockGenLocated1$fHasHaddockGenLocated2$fHasHaddockGenLocated3$fHasHaddockGenLocated4$fHasHaddockHsDataDefn$fHasHaddockHsDecl$fHasHaddockGenLocated5$fHasHaddockGenLocated6$fHasHaddockGenLocated7$fHasHaddockGenLocated8$fHasHaddockList $fFunctorHdkA $fFunctorHdkM$fApplicativeHdkM $fMonadHdkM$fShowColumnBound$fShowUpperLocBound$fShowLowerLocBound$fSemigroupHasInnerDocs$fMonoidHasInnerDocsparseModuleNoHaddockparseSignature parseImportparseStatementparseDeclarationparseExpression parsePatternparseTypeSignature parseStmt parseType parseBackpack parseHeader parseModuleisStmt hasImportisImportisDecl getImports mkPrelImportsgetOptionsFromFile getOptionstoArgscheckProcessArgsResultcompileEmptyStubcompileForeignbadReexportedBootThingmissingBootThingcheckBootDeclM tcMatchesFun tcGRHSsPatAnnoBodyrnStmtsrnLExprrnExprHoleFitSortingAlgsortHoleFitsByGraphsortHoleFitsBySizezonkSubsgetHoleFitDispConfiggetHoleFitSortingAlg pprHoleFitaddHoleFitDocsgetLocalBindingstcFilterHoleFits tcSubsumeswithoutUnificationtcCheckHoleFitfindValidHoleFitsfinishTHrunRemoteModFinalizersrunQuasilookupThName_mayberunMetaDrunMetaTrunMetaPrunMetaEtcTopSpliceExpr runAnnotation runTopSplicetcUntypedBrackettcTypedBracket tcTypedSplice tcIfaceDeclstcIfaceCompleteMatchestcIfaceAnnotationstcIfaceFamInst tcIfaceInst tcIfaceRules tcIfaceDecl tcSyntaxOpGen tcSyntaxOp tcInferRho tcInferRhoNCtcExpr tcPolyExprtcCheckMonoExprtcCheckMonoExprNC tcMonoExpr tcMonoExprNCtcCheckPolyExprtcCheckPolyExprNC tcSubMult unifyKind unifyType tcInitTidyEnvIsExtraConstraintYesExtraConstraintNoExtraConstraintinitTc initTcWithGblinitTcInteractive initTcRnIf discardResult getTopEnv updTopEnv getGblEnv updGblEnv setGblEnv getLclEnv updLclEnv setLclEnv restoreLclEnvgetEnvssetEnvsupdEnvs restoreEnvsxoptMdoptMgoptMwoptMsetXOptM unsetXOptM unsetGOptM unsetWOptM whenDOptM whenGOptM whenWOptM whenXOptM unlessXOptM getGhcModewithoutDynamicNow updTopFlags getEpsVargetEps updateEps updateEps_getHpt getEpsAndHug withException newArrowScopeescapeArrowScopenewUniqueSupplycloneLocalNamenewName newNameAt newSysName newSysLocalIdnewSysLocalIdsnewTcRef readTcRef writeTcRefupdTcReftraceTctraceRn traceOptTcRn dumpOptTcRndumpTcRnprintForUserTcRntraceIf traceOptIf getIsGHCi getGHCiMonadgetInteractivePrintNametcIsHsBootOrSigtcIsHsigtcSelfBootInfogetGlobalRdrEnv getRdrEnvs getFixityEnvextendFixityEnvgetRecFieldEnvgetDeclaredDefaultTysaddDependentFilesinGeneratedCode setSrcSpan setSrcSpanAaddLocMaddLocMAwrapLocM wrapLocAM wrapLocMA wrapLocFstM wrapLocFstMA wrapLocSndM wrapLocSndMA wrapLocM_ wrapLocMA_ getErrsVar setErrsVarfailWithfailAtaddErrAtmkDetailedMessageaddErrscheckErr addMessagesdiscardWarnings mkTcRnMessagereportDiagnosticsreportDiagnostic checkNoErrs whenNoErrsifErrsM failIfErrsM getErrCtxt setErrCtxt addErrCtxt addErrCtxtMaddLandmarkErrCtxtaddLandmarkErrCtxtM popErrCtxt getCtLocM setCtLocM askNoErrstryCaptureConstraintscaptureConstraintstcCollectingUsagetcScalingUsagetcEmitBindingUsageattemptMrecoverMmapAndRecoverM mapAndReportMfoldAndRecoverMtryTc discardErrstryTcDiscardingErrsaddErrTc addErrTcM failWithTc failWithTcMcheckTccheckTcMfailIfTc failIfTcMwarnIf diagnosticTc diagnosticTcMaddDiagnosticTcaddDiagnosticTcMaddDetailedDiagnosticaddTcRnDiagnostic addDiagnosticaddDiagnosticAt mkErrInfodebugTc addTopEvBinds newTcEvBindsnewNoTcEvBindscloneEvBindsVargetTcEvTyCoVarsgetTcEvBindsMapsetTcEvBindsMap addTcEvBindchooseUniqueOccTcgetConstraintVarsetConstraintVaremitStaticConstraintsemitConstraints emitSimple emitSimplesemitImplicationemitImplications emitInsolubleemitDelayedErrorsemitHole emitHolesemitNotConcreteErrordiscardConstraintspushLevelAndCaptureConstraints pushTcLevelM_ pushTcLevelM getTcLevel setTcLevelisTouchableTcM getLclTypeEnv setLclTypeEnvtraceTcConstraintsemitAnonTypeHoleemitNamedTypeHole recordThUserecordThSpliceUserecordThNeededRuntimeDeps keepAlivegetStagegetStageAndBindLevelsetStageaddModFinalizersWithLclEnvrecordUnsafeInfer finalSafeModefixSafeInstancesgetLocalRdrEnvsetLocalRdrEnv mkIfLclEnv initIfaceTcRn initIfaceLoadinitIfaceLoadModuleinitIfaceCheck initIfaceLclinitIfaceLclWithSubst getIfModulefailIfMforkMsetImplicitEnvM getCCIndexM getCCIndexTcM$fMonadUniqueIOEnv$fOutputableIsExtraConstraintloadSysInterfacenewGlobalBinderrnTopSpliceDecls rnSpliceDecl rnSplicePat rnSpliceTypeCandidatesQTvsDVdv_kvsdv_tvsdv_cvs ConcreteHolenewMetaKindVarnewMetaKindVars newEvVarsnewEvVarnewWantedWithLoc newWanted newWantedscloneWantedCtEv cloneWantedcloneWC emitWanted emitWantedEqs emitWantedEqemitWantedEvVaremitWantedEvVarsemitNewExprHolenewDictnewImplicationnewCoercionHolefillCoercionHoleisFilledCoercionHoleunpackCoercionHoleunpackCoercionHole_maybecheckCoercionHolenewConcreteHolenewInferExpTypenewInferExpTypeFRRreadExpType_maybereadScaledExpType readExpTypecheckingExpType_maybecheckingExpTypescaledExpTypeToType expTypeToTypeinferResultToTypetcInfer tcInferFRRensureMonoType promoteTcTypenewMetaTyVarNamenewAnonMetaTyVarnewSkolemTyVar newTyVarTyVarcloneTyVarTyVarnewConcreteTyVarnewPatSigTyVarnewCycleBreakerTyVarnewMetaDetailsnewTauTvDetailsAtLevelcloneMetaTyVar readMetaTyVarisFilledMetaTyVar_maybeisFilledMetaTyVarisUnfilledMetaTyVarwriteMetaTyVarwriteMetaTyVarRefnewMultiplicityVar newFlexiTyVarnewNamedFlexiTyVarnewFlexiTyVarTynewFlexiTyVarTysnewOpenTypeKindnewOpenFlexiTyVarTynewOpenFlexiTyVarnewOpenBoxedTypeKind newMetaTyVarsnewMetaTyVarsX newMetaTyVarXnewMetaTyVarTyVarX newWildCardXnewMetaTyVarTyAtLevelcandidateKindVars delCandidatespartitionCandidatescandidateQTyVarsWithBinderscandidateQTyVarsOfTypecandidateQTyVarsOfTypescandidateQTyVarsOfKindcandidateQTyVarsOfKindsquantifyTyVarsisQuantifiableTvzonkAndSkolemiseskolemiseQuantifiedTyVar defaultTyVardoNotQuantifyTyVarspromoteMetaTyVarTopromoteTyVarSetzonkTcTypeAndFVzonkTyCoVarsAndFVzonkDTyCoVarSetAndFVzonkTyCoVarsAndFVList zonkTcTyVarszonkTyCoVarKindzonkImplication zonkEvVarzonkWC zonkSimpleszonkCtzonkSkolemInfozonkSkolemInfoAnon zonkTcType zonkTcTypeszonkCo zonkTcTyVarzonkTcTyVarsToTcTyVarszonkTcTyVarToTcTyVarzonkInvisTVBinderzonkId zonkCoVarzonkTidyTcTypezonkTidyTcTypeszonkTidyOriginzonkTidyOriginszonkTidyFRRInfostidyCttidyHoletidyDelayedError tidyEvVaranyUnfilledCoercionHoles$fOutputableCandidatesQTvs$fMonoidCandidatesQTvs$fSemigroupCandidatesQTvs"$fMonoidUnfilledCoercionHoleMonoid%$fSemigroupUnfilledCoercionHoleMonoidhasFixedRuntimeRephasFixedRuntimeRep_syntacticmakeTypeConcretenewInteractiveBinderallocateGlobalBinderifaceExportNames lookupOriglookupNameCacheexternaliseName setNameModule tcIfaceLclIdextendIfaceIdEnv tcIfaceTyVarlookupIfaceTyVarlookupIfaceVarextendIfaceTyVarEnvextendIfaceEnvslookupIfaceTop newIfaceName newIfaceNamestrace_iftrace_hi_diffsMethInfo TcMethInfo mkNewTyConRhs buildDataCon buildPatSyn buildClassnewImplicitBindernewTyConRepNameemptyNameShape mkNameShapeextendNameShapenameShapeExportssubstNameShapemaybeSubstNameShape tcRnModIfacetcRnModExports rnModIface rnModExportsBinSymbolTablebin_symtab_nextbin_symtab_map TraceBinIFace QuietBinIFace CheckHiWay IgnoreHiWayreadBinIfaceHeader readBinIfacegetWithUserData writeBinIfaceputWithUserDataputSymbolTablegetSymbolTableputName getSymtabName$fEqCheckHiWaytcLookupImported_maybe importDeclcheckWiredInTyConifCheckWiredInThingneedWiredInHomeIfaceloadSrcInterfaceloadSrcInterface_maybeloadModuleInterfaceloadModuleInterfacesloadInterfaceForNameloadInterfaceForModuleloadWiredInHomeIfaceloadUserInterfaceloadPluginInterface loadInterfacemoduleFreeHolesPrecisefindAndReadIface writeIface readIface ifaceStats showIfacepprModIfaceSimple pprModIface$fOutputableWarningstypecheckIfacetypecheckWholeCoreBindingstypecheckIfacesForMergingtypecheckIfaceForInstantiate tcHiBootIfacetcTopIfaceBindings tcIfaceExprtcIfaceOneShot tcIfaceGlobalhydrateCgBreakInfo UsageConfiguc_safe_implicit_imps_req mkUsedNames mkUsageInfoinitUsageConfig LookingForlf_whichlf_where WhereLooking WL_Anywhere WL_Global WL_LocalTop WL_LocalOnly WhatLooking WL_AnythingWL_Constructor WL_RecFieldWL_NonemkUnboundNameRdrreportUnboundName'reportUnboundName unboundName unboundNameX notInScopeErrunknownNameSuggestionsnameSpacesRelated$fEqWhatLooking MiniFixityEnvaddLocalFixitieslookupFixityRnlookupFixityRn_helplookupTyFixityRnlookupFieldFixityRn tcAnnotationsannCtxt DsWarning MatchResult MR_Infallible MR_Fallible DsWrapper EquationInfoEqnInfoeqn_patseqn_origeqn_rhsDsMatchContext idDsWrapperrunMatchResultfixDsinitDsTcinitDsinitDsWithModGutsinitTcDsForSolver newUniqueIdduplicateLocalDs newPredVarDs newSysLocalDsnewFailLocalDsnewSysLocalsDs getGhcModeDs getPmNablas updPmNablas getSrcSpanDs putSrcSpanDs putSrcSpanDsA diagnosticDs errDsCoreExpr failWithDsfailDsmkNamePprCtxDsdsLookupGlobaldsLookupGlobalId dsLookupTyCondsLookupDataCondsLookupConLikedsGetFamInstEnvs dsGetMetaEnvdsGetCompleteMatchesdsLookupMetaEnvdsExtendMetaEnvdiscardWarningsDspprRuntimeTrace getCCIndexDsM$fMonadThingsIOEnv$fOutputableDsMatchContext$fApplicativeMatchResult$fOutputableEquationInfo$fFunctorMatchResult dsLocalBinds dsSyntaxExprdsLExprdsExprmatchSinglePatVar matchSimply matchWrapper dsHsWrapper MkCaseAltalt_pat alt_wrapper alt_resultselectSimpleMatchVarLselectMatchVarsselectMatchVarfirstPat shiftEqns matchCanFailalwaysFailMatchResultcantFailMatchResultextractMatchResultcombineMatchResultsadjustMatchResultDs wrapBindswrapBindseqVarmkCoLetMatchResultmkViewMatchResultmkEvalMatchResultmkGuardedMatchResultmkCoPrimCaseMatchResultmkCoAlgCaseMatchResultmkCoSynCaseMatchResult mkErrorAppDs mkFailExpr mkCoreAppDs mkCoreAppsDsmkCastDsmkSelectorBinds mkLHsPatTupmkVanillaTuplePatmkBigLHsVarTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsPatTupIdshareFailureHandlerdsHandleMonadicFailure mkOptTickBoxmkBinaryTickBoxdecideBangHood isTrueLHsExprtracePmtraceWhenFailPmmkPmIdallPmCheckWarnings overlapping exhaustive redundantBangexhaustiveWarningFlagisMatchContextPmCheckedneedToRunPmCheck dsGuardeddsGRHSsdsCCallmkFCallunboxArg boxResult resultWrapper RecompReasonUnitDepRemovedModulePackageChangedSourceFileChangedThisUnitIdChanged ImpurePluginPluginsChangedPluginFingerprintChangedModuleInstChanged HieMissing HieOutdatedSigsMergeChanged ModuleChanged ModuleRemoved ModuleAddedModuleChangedRawModuleChangedIface FileChanged CustomReason FlagsChangedOptimFlagsChangedHpcFlagsChangedMissingBytecodeMissingObjectFileMissingDynObjectFileMissingDynHiFileMismatchedDynHiFileObjectsChangedLibraryChanged CompileReason MustCompile RecompBecauseMaybeValidated UpToDateItem OutOfDateItemRecompileRequiredUpToDateNeedsRecompileneedsRecompileBecauseoutOfDateItemBecauserecompileRequired recompThen checkOldIfaceaddFingerprints$fOutputableRecompReason$fOutputableCompileReason$fOutputableMaybeValidated$fMonoidRecompileRequired$fSemigroupRecompileRequired$fOutputableRecompileRequired$fBinaryIfaceIdExtras$fBinaryIfaceDeclExtras$fOutputableIfaceDeclExtras$fEqRecompileRequired$fFunctorMaybeValidated$fEqCompileReason$fEqRecompReasongetLoaderStateextendLoadedEnvdeleteFromLoadedEnvloadNamewithExtendedLoadedEnvshowLoaderStateinitLoaderStateloadCmdLineLibsloadExpr loadDecls loadModuleunload loadPackages dsPrimCall dsJsFExport dsJsImportdsJsFExportDynamic InstBindings ib_tyvarsib_binds ib_pragmas ib_extensions ib_derivedInstInfoiSpeciBinds lookupGloballookupGlobal_maybeioLookupDataConaddTypecheckedBindstcLookupLocatedGlobaltcLookupGlobaltcLookupGlobalOnlytcLookupDataContcLookupPatSyntcLookupConLike tcLookupClass tcLookupTyCon tcLookupAxiomtcLookupLocatedGlobalIdtcLookupLocatedClasstcLookupLocatedTyContcLookupInstance tcGetInstEnvssetGlobalTypeEnvtcExtendGlobalEnvImplicittcExtendGlobalEnvtcExtendTyConEnv tcTyThBinderstcExtendGlobalValEnvtcExtendRecEnvtcLookupLocatedtcLookupLcl_maybetcLookup tcLookupTyVar tcLookupIdtcLookupIdMaybetcLookupLocalIdstcLookupTcTyCongetInLocalScopetcExtendKindEnvListtcExtendKindEnvtcExtendTyVarEnvtcExtendNameTyVarEnvisTypeClosedLetBndrtcExtendRecIdstcExtendSigIdstcExtendLetEnv tcExtendIdEnvtcExtendIdEnv1tcExtendIdEnv2tcExtendLocalTypeEnv tcCheckUsagetcExtendBinderStacktcInitOpenTidyEnvtcAddDataFamConPlaceholderstcAddPatSynPlaceholdersgetTypeSigNames tcExtendRulescheckWellStagedtopIdLvltcMetaTy isBrackStagetcGetDefaultTysiDFunIdpprInstInfoDetailssimpleInstInfoClsTysimpleInstInfoTysimpleInstInfoTyCon newDFunNamenewFamInstTyConNamenewFamInstAxiomNamemkStableIdFromStringmkStableIdFromName mkWrapperName pprBinders wrongThingErr$fOutputableInstInfo ZonkFlexi DefaultFlexiSkolemiseFlexiRuntimeUnkFlexiNoFlexiZonkEnv tcShortCutLit shortCutLit hsOverLitName emptyZonkEnvmkEmptyZonkEnv initZonkEnv zonkTopBndrs zonkTyBndrs zonkTyBndrsXzonkTyVarBindersXzonkTyVarBinderX zonkTopExpr zonkTopLExpr zonkTopDecls zonkTcEvBinds zonkEvBinds zonkTyVarOcc lookupTyVarXzonkTcTypeToTypezonkTcTypeToTypeXzonkTcTypesToTypesX zonkCoToCozonkScaledTcTypesToTypesXzonkTcMethInfoToMethInfoX$fOutputableZonkEnvdsLit dsOverLitwarnAboutIdentitieswarnAboutOverflowedOverLitwarnAboutOverflowedLitwarnAboutEmptyEnumerations tidyLitPattidyNPat matchLiteralshsLitKey matchNPatsmatchNPlusKPatsdesugarPatBinddesugarEmptyCasedesugarMatches desugarGRHSsnewMethodFromName topSkolemisetopInstantiateinstantiateSigmainstTyVarsWithinstCallinstCallConstraints instDFunTypeinstStupidThetatcInstInvisibleTyBinderstcInstInvisibleTyBindersNtcInstInvisibleTyBinder tcInstTypetcInstTypeBndrstcSkolDFunTypetcSuperSkolTyVarstcInstSkolTyVarstcInstSkolTyVarsXtcInstSuperSkolTyVarsXtcSkolemiseInvisibleBndrsfreshenTyVarBndrsfreshenCoVarBndrsXnewOverloadedLit mkOverLit tcSyntaxNamegetOverlapFlag tcGetInsts newClsInsttcExtendLocalInstEnvmatchActualFunTySigmamatchActualFunTysRhomatchExpectedFunTysmatchExpectedListTymatchExpectedTyConAppmatchExpectedAppTy tcWrapResult tcWrapResultOtcWrapResultMonounifyExpectedType tcSubTypePat tcSubType tcSubTypeDStcSubTypeSigmatcSubTypeAmbiguitytcSkolemiseScopedtcTopSkolemisetcSkolemiseExpTypecheckConstraintscheckTvConstraintsemitResidualTvConstraintbuildTvImplicationbuildImplicationForuTypestartSolvingByUnificationswapOverTyVarsmatchExpectedFunKind checkTyVarEq checkTyFamEq checkTypeEqcheckFamInstConsistencytcInstNewTyCon_maybetcLookupDataFamInsttcLookupDataFamInst_maybetcTopNormaliseNewTypeTF_maybetcExtendLocalFamInstEnvreportInjectivityErrors reportConflictingInjectivityErrstcGetFamInstEnvsmkTypeableBindstyConIsTypeable$fFunctorKindRepM$fApplicativeKindRepM$fMonadKindRepMnewLocalBndrRnnewLocalBndrsRnbindLocalNamesbindLocalNamesFVcheckDupRdrNamescheckDupRdrNamesN checkDupNamescheckShadowedRdrNamescheckDupAndShadowedNamescheckInferredVarsnoNestedForallsContextsErraddNoNestedForallsContextsErraddFvRnmapFvRn mapMaybeFvRnwarnUnusedTopBindscheckUnusedRecordWildcardwarnUnusedLocalBindswarnUnusedMatcheswarnUnusedTypePatternswarnForallIdentifier mkFieldEnvaddNameClashErrRn dupNamesErrbadQualBndrErr typeAppErrbadFieldConErr checkTupSize checkCTupSize wrapGenSpan genHsAppsgenHsApp genLHsVargenHsVar genAppTypegenHsIntegralLit genHsTyLitgenSimpleConPat genVarPat genWildPatgenSimpleFunBind genFunBind HsSigCtxt TopSigCtxt LocalBindCtxt ClsDeclCtxt HsBootCtxt RoleAnnotCtxtAmbiguousResultUnambiguousGreAmbiguousFieldsChildLookupResult NameNotFoundIncorrectParent FoundChildnewTopSrcBinderlookupTopBndrRnlookupLocatedTopConstructorRnlookupLocatedTopConstructorRnNlookupLocatedTopBndrRnlookupLocatedTopBndrRnNlookupInstDeclBndrlookupFamInstNamelookupConstructorFieldslookupRecFieldOcclookupRecFieldOcc_updatelookupSubBndrOcc_helpercombineChildLookupResultlookupLocatedOccRnlookupLocatedOccRnConstrlookupLocatedOccRnRecFieldlookupLocatedOccRnNonelookupLocalOccRn_maybelookupLocalOccThLvl_maybe lookupOccRnlookupLocalOccRnlookupTypeOccRnlookupOccRn_maybelookupExprOccRnlookupGlobalOccRn_maybelookupGlobalOccRnlookupInfoOccRnlookupGreAvailRnaddUsedDataCons addUsedGRE addUsedGREslookupSigOccRnlookupSigOccRnNlookupSigCtxtOccRnNlookupSigCtxtOccRnlookupLocalTcNames dataTcOccslookupIfThenElselookupSyntaxNamelookupSyntaxExpr lookupSyntaxlookupSyntaxNameslookupQualifiedDoExprlookupQualifiedDolookupNameWithQualifierlookupQualifiedDoName$fMonoidDisambigInfo$fSemigroupDisambigInfo$fOutputableDisambigInfo$fOutputableChildLookupResult$fOutputableHsSigCtxt$fEqFieldsOrSelectors InstanceWhatBuiltinEqInstanceBuiltinTypeableInstanceBuiltinInstance LocalInstanceTopLevInstance iw_dfun_id iw_safe_over ClsInstResult NoInstanceOneInstNotSure cir_new_theta cir_mk_evcir_what AssocInstInfo NotAssociated InClsInstai_class ai_tyvars ai_inst_envisNotAssociated safeOverlapinstanceReturnsDictConmatchGlobalInst$fOutputableInstanceWhat$fOutputableClsInstResultMaybeNewFreshCachedTouchabilityTestResultTouchableSameLevelTouchableOuterLevel UntouchableTcSaddInertForAll addInertCankickOutAfterUnificationaddInertSafehaskinsertSafeOverlapFailureTcSgetSafeOverlapFailures addSolvedDictgetSolvedDictssetSolvedDicts updInertTcS getInertCans setInertCans updInertCans updInertDictsupdInertSafehaskupdInertIrreds getInertEqsgetInnermostGivenEqLevelgetInertInsolsgetInertGivensgetPendingGivenScsgetUnsolvedInertsgetHasGivenEqsremoveInertCtslookupFamAppInertlookupInertDictlookupSolvedDictlookupFamAppCacheextendFamAppCache foldIrredswrapTcS wrapErrTcS wrapWarnTcSfailTcSwarnTcS addErrTcSpanicTcS ctLocWarnTcStraceTcSrunTcPluginTcSgetGlobalRdrEnvTcSbumpStepCountTcS csTraceTcS traceFireTcSrunTcSrunTcSEarlyAbortrunTcSEqualities runTcSInertsrunTcSWithEvBinds setEvBindsTcS nestImplicTcSnestTcSemitImplicationTcSemitTvImplicationTcS getTcSInerts setTcSInertspushLevelNoWorkListupdWorkListTcS emitWorkNCemitWorkgetTcEvBindsVar unifyTyVarreportUnificationstouchabilityTestgetDefaultInfo getWorkListselectNextWorkItem getInstEnvsgetFamInstEnvsrecordUsedGREscheckWellStagedDFunpprEq pprKickedresetUnificationFlagsetUnificationFlag newFlexiTcSTy instFlexiXisFresh freshGoals getEvExpr setEvBind setWantedEqsetWantedEvTermsetEvBindIfWanted newGivenEvVarnewBoundEvVarIdnewGivenEvVarsemitNewWantedEq newWantedEqnewWantedEvVarNC newWantedNCcheckReductionDepthmatchFam matchFamTcMbreakTyEqCycle_maybe rewriterView$fHasDynFlagsTcS$fMonadThingsTcS$fHasModuleTcS$fMonadUniqueTcS$fMonadFailTcS $fMonadIOTcS $fMonadTcS$fApplicativeTcS $fMonadFixTcS"$fOutputableTouchabilityTestResult $fFunctorTcSrewriterewriteForErrorsrewriteArgsNom rewriteType$fHasDynFlagsRewriteM$fApplicativeRewriteM$fMonadRewriteM$fFunctorRewriteMStopOrContinue ContinueWith canonicalizesolveCallStackmakeSuperClasses continueWithstopWithandWhenContinuerewriteEqEvidence unifyWanted$fOutputableStopOrContinue$fFunctorStopOrContinuesolveSimpleGivenssolveSimpleWanteds$fOutputableInteractResultrnLHsDoc rnLDocDecl rnDocDeclrnHsDoc FreeKiTyVarsNegationHandlingReassociateNegationKeepNegationIntactWarnUnusedForallsNoWarnUnusedForallsHsPatSigTypeScoping AlwaysBind NeverBind rnHsSigWcTypernHsPatSigType rnHsWcTypernHsPatSigTypeBindingVars rnHsSigTypernImplicitTvOccs rnLHsType rnLHsTypesrnScaledLHsTypernHsType rnLHsKindrnHsKind rnLHsTypeArgs rnContextrnMaybeContextrnLTyVarbindSigTyVarsFV bindHsQTyVarsbindHsOuterTyVarBndrsbindHsForAllTelescopebindLHsTyVarBndrsbindLHsTyVarBndrnewTyVarNameRnrnConDeclFields lookupField mkOpAppRn mkNegAppRn mkOpFormRn mkConOpPatRncheckPrecMatchcheckSectionPrecfilterInScopeMextractHsTyArgRdrKiTyVarsextractHsTyRdrTyVarsextractHsTyRdrTyVarsKindVarsextractHsTysRdrTyVarsextractRdrKindSigVarsextractConDeclGADTDetailsTyVarsextractDataDefnKindVarsextractHsOuterTvBndrsnubLnubN$fOutputableRnTyKiWhat$fOutputableRnTyKiEnv$fOutputableWarnUnusedForalls$fOutputableOpNameHsRecFieldContext HsRecFieldCon HsRecFieldPat HsRecFieldUpd NameMakerCpsRnliftCpsliftCpsWithConttopRecNameMakerisTopRecNameMakerlocalRecNameMakerrnPatsrnPatapplyNameMaker rnBindPat rnHsRecFieldsrnHsRecUpdFieldsrnLit rnOverLit $fMonadCpsRn$fApplicativeCpsRn$fFunctorCpsRnreportUnsolvedreportAllUnsolvedwarnAllUnsolvedwarnDefaultingsolverReportMsg_ExpectedActuals InferModeApplyMREagerDefaultingNoRestrictionscaptureTopConstraintssimplifyTopImplic simplifyToppushLevelAndSolveEqualitiespushLevelAndSolveEqualitiesXsolveEqualitiessimplifyAndEmitFlatConstraintsreportUnsolvedEqualitiessimplifyTopWantedssimplifyAmbiguityChecksimplifyInteractivesimplifyDefault tcCheckGivenstcCheckWanteds tcNormalisefindInferredDiffgrowThetaTyVarssimplifyWantedsTcM solveWanteds approximateWC$fOutputableInferModeGenerateInhabitingPatternsModeCaseSplitTopLevel MinimalCoverPhiCtsPhiCtPhiTyCt PhiCoreCtPhiConCt PhiNotConCtPhiBotCt PhiNotBotCtaddPhiCtsNablasaddPhiCtNablas isInhabitedgenerateInhabitingPatterns"$fOutputableTopNormaliseTypeResult$fOutputablePhiCt*$fOutputableGenerateInhabitingPatternsMode"$fEqGenerateInhabitingPatternsMode$$fShowGenerateInhabitingPatternsMode CheckActionCAunCAcheckMatchGroup checkGRHSscheckEmptyCase checkPatBind$fFunctorCheckAction getLdiNablas pmcPatBindpmcGRHSs pmcMatchesaddTyCsaddCoreScrutTmCsaddHsScrutTmCs $fMonoidCIRB$fSemigroupCIRB$fEqFormatReportWarningsMode dsTopLHsBinds dsLHsBindsdsSpecdsWarnOrphanRuledecomposeRuleLhs dsTcEvBinds_s dsTcEvBinds dsEvBindsdsEvTermmatchConFamily matchPatSynmatchEquationsmatchSinglePat dsListComp dsMonadComp dsBracket$fRepTVSpecificitySpecificity $fRepTV()() dsProcExpr dsValBinds HFSNoSorting HFSBySizeHFSBySubsumptionrelevantCtEvidence isFlexiTyVar$fEqHoleFitSortingAlg$fOrdHoleFitSortingAlgcheckValidTypecheckValidMonoType checkTySynRhscheckEscapingKindcheckValidThetaarityErrcheckValidInstHeadvalidDerivPredcheckValidInstancecheckValidCoAxiomcheckValidCoAxBranchcheckValidTyFamEqncheckValidAssocTyFamDefltcheckTyConTelescope$fOutputableTypeOrKindCtxt$fOutputableExpandMode$fOutputableValidityEnv$fEqTypeOrKindCtxt ContextKindTheKindAnyKindOpenKind SAKS_or_CUSKSAKSCUSKInitialKindStrategyInitialKindCheckInitialKindInferHoleModeHM_Sig HM_FamPatHM_VTA HM_TyAppPat funsSigCtxt addSigCtxt pprSigCtxt tcHsSigWcTypekcClassSigTypetcClassSigType tcHsSigTypetcStandaloneKindSig tcHsDerivtcDerivStrategytcHsClsInstType tcHsTypeApp tcFamTyPats tcHsOpenTypetcHsLiftedTypetcHsOpenTypeNCtcHsLiftedTypeNCtcCheckLHsTypetcInferLHsTypetcInferLHsTypeKindtcInferLHsTypeUnsaturatedtcMult tcHsContext tcLHsPredTypebindNamedWildCardBinders kcDeclHeadercheckForDuplicateScopedTyVars outerTyVarsouterTyVarBndrsscopedSortOuterbindOuterSigTKBndrs_TvbindOuterFamEqnTKBndrs_Q_TvbindOuterFamEqnTKBndrstcOuterTKBndrstcExplicitTKBndrsbindExplicitTKBndrs_SkolbindExplicitTKBndrs_TvbindExplicitTKBndrs_Q_SkolbindExplicitTKBndrs_Q_TvbindImplicitTKBndrs_SkolbindImplicitTKBndrs_TvbindImplicitTKBndrs_Q_SkolbindImplicitTKBndrs_Q_TvbindTyClTyVarsbindTyClTyVarsAndZonkzonkAndScopedSortkindGeneralizeAlletaExpandAlgTyConcheckDataKindSigcheckClassKindSigtcbVisibilitiestcHsPartialSigTypetcHsPatSigType tcLHsKindSig funAppCtxtaddTyConFlavCtxt$fOutputableHoleMode$fOutputableTcTyMode$fOutputableSAKS_or_CUSKImportDeclUsage rnImportsrenameRawPkgQual renamePkgQualcalculateAvailsextendGlobalRdrEnvRngetLocalNonValBindersnewRecordSelector mkChildEnv findChildrenreportUnusedNamesfindImportUsagegetMinimalImportsprintMinimalImports checkConName rnTopBindsLHSrnTopBindsLHSBootrnTopBindsBootrnLocalBindsAndThenrnLocalValBindsLHS rnValBindsRHSrnLocalValBindsRHSmakeMiniFixityEnv rnMethodBinds renameSigs rnMatchGrouprnGRHSsrnGRHSrnSrcFixityDecl rnSrcDecls addTcgDUs rnWarningTxt findSplice SpliceInfospliceDescription spliceSource spliceIsDeclspliceGeneratedrnTypedBracketrnUntypedBracket rnTypedSplicernUntypedSpliceExpr traceSplicecheckThLocalNamemkExpandedExpr$fOutputableMonadNames$fOutputableStmtTreeinitializeSessionPluginsloadFrontendPluginforceLoadModuleInterfacesforceLoadNameModuleInterfaceforceLoadTyCongetValueSafelygetHValueSafelylessUnsafeCoercelookupRdrNameInModuleForPlugins TcPragEnv tcIdSigName tcSigInfoNamecompleteSigPolyId_maybetcTySigs tcUserTypeSiglhsSigWcTypeContextSpanlhsSigTypeContextSpancompleteSigFromIdisCompleteHsSig tcInstSig emptyPragEnv lookupPragEnv extendPragEnv mkPragEnvaddInlinePragArityaddInlinePrags tcSpecPrags tcSpecWrapper tcImpPragstcPatSynBuilderBind tcPatSynDecl LetBndrSpec LetLclBndr LetGblBndrtcLetPattcPats tcInferPat tcCheckPat tcCheckPat_O newLetBndraddDataConStupidTheta$fOutputableLetBndrSpec tcTopBinds tcHsBootSigs tcLocalBinds tcValBinds tcPolyCheckchooseInferredQuantifiers$fOutputableGeneralisationPlan RolesInfocheckSynCyclescheckClassCycles inferRolesaddTyConsToGblEnvmkDefaultMethodType tcRecSelBinds mkRecSelBindsmkOneRecordSelector$fMonadSynCycleM$fApplicativeSynCycleM $fMonadRoleM$fApplicativeRoleM$fFunctorRoleM$fFunctorSynCycleMpatSynBuilderOccAppCtxt VAExpansionVACallEValArgValArgQLva_exprva_funva_argsva_ty HsExprArgETypeArgEPragEWrapeva_ctxteva_arg eva_arg_tyeva_at eva_hs_tyeva_tyTcPassTcpRnTcpInstTcpTc appCtxtLocinsideExpansion addArgWrap splitHsApps rebuildHsApps isHsValArgcountLeadingValArgs isVisibleArgcountVisAndInvisValArgscountHsWrapperInvisArgspprHsExprArgTctcInferAppHeadtcInferAppHead_maybe addHeadCtxt obviousSigtyConOf tyConOfET lookupParentsfieldNotInType notSelector tcCheckId tcInferIdnonBidirectionalErr addFunResCtxt addExprCtxt$fOutputableAppCtxt$fOutputableEWrap$fOutputableEValArg$fOutputableHsExprArg TcStmtCheckerTcCmdStmtCheckerTcExprStmtChecker TcMatchCtxtMCmc_whatmc_body tcMatchesCase tcMatchLambdatcGRHS tcDoStmtstcBodytcStmtstcStmtsAndThen tcGuardStmttcDoStmtcheckArgCounts tcInferSigmatcApp tcExprPragtcProcthNameToGhcNamethNameToGhcNameIO$fMonadThingsCoreMgetCastsunarise$fOutputableUnariseValStgToDoStgCSE StgLiftLamsStgStats StgUnarise StgBcPrep StgDoNothing StgCgInfosStgPipelineOptsstgPipeline_phasesstgPipeline_lintstgPipeline_pprOpts stgPlatformstgPipeline_forBytecodestg2stg$fMonadUniqueStgM $fShowStgToDo $fReadStgToDo $fEqStgToDo $fOrdStgToDo $fFunctorStgM$fApplicativeStgM $fMonadStgM $fMonadIOStgMmkPartialIface mkFullIface mkIfaceTcmkIfaceExportstyThingToIfaceDeclcoAxiomToIfaceDecl pprTyThingLoc pprTyThingHdrpprTyThingInContextpprTyThingInContextLoc pprTyThing mkHieFilemkHieFileWithSourcegetCompressedAsts enrichHie$fModifyStateVar$fModifyStateName$fHasLocHsDataDefn $fHasLocHsArg$fHasLocDataDefnCons $fHasLocList$fHasLocGenLocated$fHasLocGenLocated0$fHasLocGenLocated1$fHasLocPScoped$fToHieGenLocated$fToHieGenLocated0$fToHieIEContext$fToHieIEContext0$fToHieIEContext1$fToHieGenLocated1$fToHieRScoped$fToHieGenLocated2$fToHieGenLocated3$fToHieAnnProvenance$fToHieGenLocated4$fToHieGenLocated5$fToHieGenLocated6$fToHieForeignExport$fToHieForeignImport$fToHieGenLocated7$fToHieGenLocated8$fToHieGenLocated9$fToHieGenLocated10$fToHieGenLocated11$fToHieGenLocated12$fToHieGenLocated13$fToHieGenLocated14$fToHieGenLocated15$fToHieGenLocated16$fToHieGenLocated17$fToHiePendingTcSplice$fToHiePendingRnSplice$fToHieHsQuote$fToHieGenLocated18$fToHieArithSeqInfo$fToHieGenLocated19$fToHieGenLocated20$fToHieTScoped$fToHieTVScoped $fToHieHsArg$fToHieGenLocated21$fToHieTVScoped0$fToHieTScoped0$fToHieStandaloneKindSig$fToHieGenLocated22$fToHieTScoped1$fToHieTScoped2$fToHieGenLocated23$fToHieGenLocated24$fToHieHsScaled$fToHieGenLocated25$fToHieRScoped0$fToHieGenLocated26$fToHieGenLocated27$fToHieGenLocated28$fToHieHsDataDefn$fToHieGenLocated29 $fToHieFamEqn$fToHieTScoped3$fToHieTScoped4$fToHieGenLocated30$fToHieRScoped1$fToHieFamilyInfo$fToHieGenLocated31$fToHieGenLocated32$fToHieTyClGroup$fToHieHsConDeclGADTDetails$fToHieHsConDetails$fToHieRContext$fToHieTScoped5$fToHieContext$fToHieGenLocated33$fToHieEvBindContext$fToHieContext0$fToHieContext1$fToHieContext2$fToHieContext3$fToHieIEContext2 $fToHieMaybe $fToHieBag$fToHieDataDefnCons$fToHieNonEmpty $fToHieList $fToHieVoid$fToHiePatSynFieldContext$fToHieContext4$fToHieGenLocated34$fToHieSigContext$fToHieGenLocated35$fToHieGenLocated36$fToHieRScoped2$fToHieRFContext$fToHieRFContext0$fToHieRContext0$fToHieRScoped3$fToHieRScoped4$fToHieRScoped5$fToHieRScoped6$fToHieHsTupArg$fToHieGenLocated37$fToHiePScoped$fToHieHsStmtContext$fToHieHsMatchContext$fToHieHsPatSynDir$fToHieGenLocated38$fToHieBindContext$fHiePassTypechecked$fHiePassRenamed$fHasTypeGenLocated$fHasTypeGenLocated0$fHasTypeGenLocated1$fHasLocFamEqn$fToHieRScoped7$fToHieGenLocated39 $fToHieGRHSs$fToHieGenLocated40$fToHieMatchGroup $fDataPScopedinitStgPipelineOpts rnExportsfindExtraSigImportsimplicitRequirementsimplicitRequirementsShallow checkUnit tcRnCheckUnittcRnMergeSignaturesmergeSignaturestcRnInstantiateSignatureinstantiateSignatureHsSigFun tcClassSigs tcClassDecl2tcClassMinimalDefinstantiateMethod mkHsSigFunfindMethodBind instDeclCtxt1 instDeclCtxt2 instDeclCtxt3 tcATDefault substATBndrs DerivInstTys dit_cls_tysdit_tc dit_tc_args dit_rep_tcdit_rep_tc_argsdit_dc_inst_arg_env AuxBindSpec DerivTag2Con DerivMaxTagDerivDataDataTypeDerivDataConstr gen_Eq_binds gen_Ord_bindsgen_Enum_bindsgen_Bounded_binds gen_Ix_bindsgen_Read_bindsgen_Show_bindsgen_Data_bindsgen_Lift_bindsgen_Newtype_bindsgen_Newtype_fam_instsmkCoerceClassMethEqn genAuxBinds mkRdrFunBindmkRdrFunBindECmkRdrFunBindSEordOpTbl boxConTbl litConTbl error_ExprgetPossibleDataConsderivDataConInstArgTysbuildDataConInstArgEnvsubstDerivInstTyszonkDerivInstTys$fOutputableDerivInstTys FFoldTypeFTft_trivft_var ft_co_varft_funft_tup ft_ty_app ft_bad_app ft_forallgen_Functor_bindsfunctorLikeTraversedeepSubtypesContainingfoldDataConArgsgen_Foldable_bindsgen_Traversable_binds GenericKindGen0Gen1gen_Generic_bindsget_gen1_constrained_tys canDoGenericscanDoGenerics1gen_Generic_fam_inst ThetaSpecPredSpecSimplePredSpecSubTypePredSpecsps_pred sps_originsps_type_or_kindstps_ty_actualstps_ty_expected stps_origin StockGenFnsstock_gen_bindsstock_gen_fam_instsOriginativeDerivStatusCanDeriveStockStockClassErrorCanDeriveAnyClassNonDerivableClass DerivContext InferContext SupplyContextDerivSpecMechanismDerivSpecStockDerivSpecNewtypeDerivSpecAnyClass DerivSpecVia dsm_stock_ditdsm_stock_gen_fnsdsm_newtype_ditdsm_newtype_rep_tydsm_via_cls_tysdsm_via_inst_ty dsm_via_ty DerivSpecDSds_locds_nameds_tvsds_thetads_clsds_tys ds_skol_info ds_user_ctxt ds_overlapds_standalone_wildcard ds_mechanismDerivEnvdenv_overlap_modedenv_tvsdenv_cls denv_inst_tys denv_ctxtdenv_skol_info denv_stratDerivMisStandaloneDerivisStandaloneWildcardDerivaskDerivUserTypeCtxt mkDerivOrigin pprDerivSpecsetDerivSpecTheta zonkDerivSpecderivSpecMechanismToStrategyisDerivSpecStockisDerivSpecNewtypeisDerivSpecAnyClassisDerivSpecViazonkDerivSpecMechanismmkDirectThetaSpec substPredSpeccaptureThetaSpecConstraintshasStockDerivingcheckOriginativeSideConditionsstd_class_via_coerciblenon_coercible_classnewDerivClsInstextendLocalInstEnv$fOutputableDerivContext$fOutputableDerivEnv$fOutputableDerivSpecMechanism$fOutputableDerivSpec$fOutputablePredSpecsimplifyInstanceContexts DerivInfo di_rep_tc di_scoped_tvs di_clausesdi_ctxt tcDeriving$fOutputableEarlyDerivSpec tcInstDecls1 DataDeclInfo DDataType DDataInstancetcTyAndClassDecls kcConDeclstcTyFamInstEqncheckFamTelescopeunravelFamInstPatsaddConsistencyConstraintsdataDeclChecks tcConDeclscheckValidTyContcAddTyFamInstCtxttcMkDataFamInstCtxttcAddDataFamInstCtxtwrongKindOfFamilytcInstDeclsDeriv tcInstDecls2tcRulesisForeignImportisForeignExportnormaliseFfiTypetcForeignImportstcForeignImports' tcFImport tcCheckFIType checkCTargettcForeignExportstcForeignExports' tcFExport tcCheckFETypecheckForeignArgscheckForeignResnonIOokmustBeIO checkSafe noCheckSafe tcDefaults RenamedStuff TcRnExprModeTM_Inst TM_Default tcRnModuletcRnModuleTcRnMcheckHiBootIface' checkBootDecl rnTopSrcDecls tcTopSrcDeclsrunTcInteractivetcRnStmt isGHCiMonadtcRnExprtcRnImportDeclstcRnType tcRnDeclsigetModuleInterfacetcRnLookupRdrNametcRnLookupName tcRnGetInfoloadUnqualIfaces withTcPluginswithHoleFitPluginsgetRenamedStuffTidyOptsopt_name_cacheopt_collect_ccsopt_unfolding_optsopt_expose_unfoldings opt_trim_idsopt_expose_rulesopt_static_ptr_optsUnfoldingExposure ExposeNone ExposeSome ExposeAllmkBootModDetailsTc tidyProgram $fMonadDFFV$fApplicativeDFFV $fFunctorDFFV$fShowUnfoldingExposure$fEqUnfoldingExposure$fOrdUnfoldingExposure dsCFExport dsCImportdsCFExportDynamic dsForeignsdeSugar deSugarExpr initTidyOptsinitStaticPtrOptsCorePrepConfigcp_catchNonexhaustiveCasescp_convertNumLitCorePrepPgmConfigcpPgm_endPassConfigcpPgm_generateDebugInfo corePrepPgm corePrepExprmkConvertNumLiteral$fOutputableFloatingBind$fOutputableOkToSpec$fOutputableFloatsinitCorePrepConfiginitCorePrepPgmConfigCgInteractiveGutsMessager newHscEnvnewHscEnvWithHUG initHscEnv ioMsgMaybehscTcRnLookupRdrNamehscTcRcLookupNamehscTcRnGetInfohscIsGHCiMonadhscGetModuleInterfacehscRnImportDeclshscParse hscParse'hscTypecheckRenamehscTypecheckAndGetWarnings tcRnModule' hscDesugar hscDesugar'makeSimpleDetailshscRecompStatusinitModDetailsinitWholeCoreBindingshscDesugarAndSimplifyhscMaybeWriteIface oneShotMsgbatchMsg batchMultiMsg hscCheckSafe hscGetSafe hscSimplify hscSimplify'hscSimpleIface'hscGenHardCodemkCgInteractiveGutshscInteractivegenerateByteCodegenerateFreshByteCodehscCompileCmmFile doCodeGenhscStmthscStmtWithLocation hscParsedStmthscDeclshscParseModuleWithLocationhscParseDeclsWithLocationhscDeclsWithLocationhscParsedDeclshscAddSptEntries hscImport hscTcExpr hscKcType hscParseExprhscParseStmtWithLocation hscParseTypehscParseIdentifierhscTidyhscCompileCoreExprhscCompileCoreExpr'dumpIfaceStatsshowModuleIndexwriteInterfaceOnlyModedefaultRunMetarunMeta' $fQuasiIOEnv!$fReifyFlagSpecificitySpecificity$fReifyFlag()() HookedUse runHookedUse runPipelinerunPhaserunLlvmManglePhaserunMergeForeignrunLlvmLlcPhaserunLlvmOptPhase runAsPhase runJsPhaserunForeignJsPhaseapplyAssemblerInfoGetterapplyAssemblerProg runCcPhaserunHscBackendPhase runUnlitPhase getFileArgs runCppPhase runHscPhasemkOneShotModLocation runHscTcPhaserunHscPostTcPhase runHsPpPhasephaseOutputFilenameNewgetOutputFilename llvmOptionshscPostBackendPhase compileStubjoinObjectFilesgetHCFilePackageslinkDynLibChecktouchObjectFile$fMonadUseTPhaseHookedUse$fFunctorHookedUse$fApplicativeHookedUse$fMonadHookedUse$fMonadIOHookedUse$fMonadThrowHookedUse$fMonadCatchHookedUse preprocess compileOne compileOne'link linkingNeededoneShot compileFile mkPipeEnvpreprocessPipeline fullPipeline hscPipelinehscBackendPipelinehscGenBackendPipeline asPipeline viaCPipeline llvmPipelinellvmLlcPipelinellvmManglePipelinecmmCppPipeline jsPipelinehscPostBackendPipeline pipelineStartTermFoldfTermfPrim fSuspension fNewtypeWrapfRefWrapTermPrim Suspension NewtypeWrapRefWraptydcvalsubTermsvalRawctypebound_to wrapped_termtermTypeisFullyEvaluatedTermconstrClosToNamefoldTerm mapTermType termTyCoVarscPprTerm cPprTermBase cvObtainTermcvReconstructTypeimproveRTTIType$fOutputableTerm tcPluginIO tcPluginTracegetTargetPlatformisTouchableTcPluginMnewGivenGetDocsFailureNameHasNoModule NoDocsInIfaceInteractiveNamegetResumeContextgetHistoryModulegetHistorySpan execOptionsexecStmt execStmt'runDeclsrunDeclsWithLocationrunParsedDeclsparseImportDecl resumeExecsetupBreakpointbackforwardabandon abandonAll setContextmoduleIsInterpretedgetInfogetNamesInScopegetRdrNamesInScope parseNamegetDocsgetInstancesForTypeparseInstanceHead parseExpr compileExprcompileExprRemotecompileParsedExprRemotecompileParsedExprdynCompileExpr showModulemoduleIsBootOrNotObjectLinkableobtainTermFromValobtainTermFromIdreconstructType$fOutputableGetDocsFailureSummariseResultFoundInstantiationFoundHomeWithError FoundHomeNotThere ModNodeMap unModNodeMap ModIfaceCacheiface_clearCacheiface_addToCache LoadHowMuchLoadAllTargetsLoadUpToLoadDependenciesOfdepanaldepanalEdepanalPartialinstantiationNodes noIfaceCache newIfaceCacheload loadWithCacheload'emptyModNodeMapmodNodeMapInsertmodNodeMapElemsmodNodeMapLookupmodNodeMapSingletonmodNodeMapUnionWith downsweepcheckHomeUnitsClosed summariseFilesummariseModule noModErrorcyclicModuleErr$fOutputableCachedIface'$fOutputableModuleGraphNodeWithBootFile$fOutputableBuildPlan$fOutputableCodeGenEnable$fEqCodeGenEnable$fShowCodeGenEnable$fOrdCodeGenEnable$fFunctorModNodeMap$fTraversableModNodeMap$fFoldableModNodeMap$fShowResultOrigin$fShowResultLoopOrigin$fFunctorResultVar GhcApiError ModuleInfo CoreModule cm_modulecm_typescm_bindscm_safeTypecheckedSource RenamedSource ParsedSourceDesugaredModuledm_typechecked_moduledm_core_moduleTypecheckedModuletm_parsed_moduletm_renamed_sourcetm_typechecked_sourcetm_checked_module_info tm_internals_ ParsedModulepm_mod_summarypm_parsed_sourcepm_extra_src_files coreModuleTypecheckedMod renamedSourcetypecheckedSource moduleInfo ParsedMod parsedSourcedefaultErrorHandlerdefaultCleanupHandlerrunGhcTwithCleanupSessionsetSessionDynFlagssetUnitDynFlagssetTopSessionDynFlagssetProgramDynFlagsgetProgramDynFlagssetInteractiveDynFlagsgetInteractiveDynFlagsparseDynamicFlagsparseTargetFiles setTargets getTargets addTarget removeTarget guessTargetworkingDirectoryChanged getModSummarytypecheckModule desugarModulecompileToCoreModulecompileToCoreSimplifiedgetModuleGraphisLoadedisLoadedModule getBindingsgetInsts getModuleInfomodInfoTyThingsmodInfoTopLevelScopemodInfoExportsmodInfoExportsWithSelectorsmodInfoInstancesmodInfoIsExportedNamemkNamePprCtxForModulemodInfoLookupName modInfoIface modInfoRdrEnv modInfoSafemodInfoModBreaks isDictonaryIdlookupGlobalNamefindGlobalAnnsgetGREgetNameToInstancesIndexpprParenSymNamegetTokenStreamgetRichTokenStreamaddSourceToTokensshowRichTokenStream findModulefindQualifiedModulerenamePkgQualMrenameRawPkgQualM lookupModulelookupQualifiedModuleisModuleTrustedmoduleTrustReqs setGHCiMonadparserinterpretPackageEnv$fParsedModParsedModule$fOutputableCoreModule$fParsedModTypecheckedModule$fParsedModDesugaredModule$fTypecheckedModDesugaredModule!$fTypecheckedModTypecheckedModule$fDesugaredModDesugaredModule$fExceptionGhcApiError$fShowGhcApiErrorpprintClosureCommandshowTermpprTypeAndContents doMkDependHS doBackpack$fGhcMonadIOEnv$fEqSessionType GHC.VersioncProjectGitCommitIdcProjectVersioncProjectVersionIntcProjectPatchLevelcProjectPatchLevel1cProjectPatchLevel2 short_usage$restrictedDamerauLevenshteinDistance hashInt32bytestring-0.11.5.2Data.ByteString.Internal.Type ByteStringData.ByteString.Short.InternalShortByteString mkZFastStringGHC.IO.Handle.TypesHandleRDoc reduceDocfirst hasAsciiSpacesignalHandlersRefCount forceStateandMfilterMokIdOccokIdChar reservedIds reservedOpsisDashesstderrSupportsAnsiColors' getPaddedIntgetGNUArchEntries putArchEntryfileInfoskipBOMisJust isNothingfromJust maybeToList listToMaybe catMaybesmapMaybe.=renum!:foldBlockNodesF3is_ctypeisOneLineRealSpanisPointRealSpanVMaybeviewConsviewSnoc uniqueMaskgenSymmkUniqSM TaggedValSharedEntryseekBinNoExpandputPrimhashInstantiationsunitModuleStringZhddhdcompareFractionalLitunlines'shouldMangleSelectorNames appendJStathexDocToSat expr2statdataFieldCache dataCacheclsCache dotNodeEdges checkNode colorScan assignColors selectColor plusWithInf mulWithInflibraryDirsForWayminClosureSizerewrites rewriteLinerewriteSymType rewriteAVX rewriteCall replaceOnce splitLinemk_derivn_sortn_occn_uniqn_loc NotExportedIdScope realUniquefvVarAccCBPGCGpruneDelis_nullCafCC IndexedCCExprCCDeclCCHpcCCLateCCCallerCC flavourIndexpprFlavourCoreppCostCentreLblppFlavourLblComponent pickBothGREData.Typeable.InternalTypeablefindAnnPayloads widenRealSpanD:R:NoGhcTcGhcPass powersetL powersetLSAlgTyCon FamilyTyCon SynonymTyCon PrimTyConPromotedDataCon tyConCTypealgTcGadtSyntaxalgTcStupidThetaalgTcRhs algTcFlavoursynTcRhs famTcResVar famTcFlav famTcParentfamTcInj primRepNamedataCon promDcInfotctc_scoped_tvs tctc_is_poly tctc_flavourokParenttyConFieldLabelEnvfieldsOfAlgTcRhs kindTyConKeysisConcreteTyConFlavourtcFlavourMustBeSaturated pcPrimTyCon pcPrimTyCon0pcPrimTyCon_LevPolyLastArgcloseOverKindsFVsubstForAllCoBndrUncheckedsubstVarBndrUncheckedsubstTyVarBndrUsingsubstCoVarBndrUsing coreFullViewcore_full_viewexpandSynTyConApp_maybe expand_synisTyConKeyApp_maybeisNullaryTyConKeyAppisBoxedRuntimeRep_maybe mk_cast_tyfun_kind_arg_flagsgetRuntimeRep_maybegetLevity_maybe TickishPassD:R:XBreakpointTickishPassStg TypeOrderingTLTTEQTEQXTGTtcEqTypeNoSyns tc_eq_type narrowLit' singlePred forceMatch updateNodesingletonGraph consumeBy isMultiple anySplittableBody'isIfaceConstraintKinddefaultIfaceTyVarsOfKind liftedRep_ty lifted_ty ppr_itv_bndrs ppr_equalityppr_iface_tc_apppprSumpprTupleif_print_coercionspsArgsrm_empty normaliseRMRMEmptymkForAllCo_NoReflmkHomoForAllCos_NoRefldowngradeRole_maybe instCoercion instCoercionsextendLiftingContextEx ty_co_substliftCoSubstTyVarBndrUsingliftCoSubstCoVarBndrUsingshowMsgEnvelopelog_hook dump_hook trace_hookgenerated_dumps trace_flush DumpCachedefaultTraceFlushdumpSDocWithStylechooseDumpFile withTiming'tmp_dirs_to_cleantmp_next_suffixtmp_files_to_cleantmp_subdirs_to_cleanmergePathsToCleangetTemporaryDirectory entryNameentryBS SectionTablesectionTableOffsetsectionEntrySizesectionEntryCountsectionNameIndex ElfHeadergw16gw32gwNwordSize readElfHeaderreadElfSectionTablereadElfSectionByIndexfindSectionFromName readElfNoteBS runGetOrThrowplatformJSSupportedFlatSwitchPlanmaxJumpTableHoleminJumpTableSizeminJumpTableOffsetwriteLogQueueInternalparseIntdropEq TypeEqualityTNEQTypeMapX trieMapView tc_match_tystc_match_tys_x tc_unify_tys don'tBeSoSure ty_co_matchdcTagdataConKindEqSpecfitsIn kindPrimRepviewCall isCardNonOnce isCardNonAbs seqSubDmd botSubDmd strictifyCardglbCard viewDmdPair polyFieldDmdunboxDeeplySubDmdplusDivergencemultDivergence exnDmdTypeetaExpandDmdType defaultArgDmddecreaseArityDmdTypetransferBoxityConCpr_ FlatConCprcollectValBindersBitFieldbitfieldvanillaCafInfozapFragileUnfoldingsizeAnn pprTopBindsCoreMapXCoreMapGunboxedTupleSumKind cTupleArr mkSumTyConOccmkSumDataConOcc unboxedSumArrmk_sumzeroBitRepTyConspecialBoxingDataCon_maybeextractPromotedListpcDataConWithFixity&&&.<<|.ppr_hs_args_prefix_appppr_single_hs_argsplitLHsQualTy_KPexprsFVsexprSomeFreeVarsDSetexprsSomeFreeVarsDSet exprOrphNamesruleFVsrulesFVsNormMD:R:XRhsClosureCodeGenIndex putObjUnit getObjUnitmagic checkMagic getCheckMagictoI32fromI32ctxTop ctxLneFrameBs assignCoercefindDefaultStg lf_platformcheckNoCurrentCCSLocalFVslocalsTopFVsCseEnv ce_conAppMapce_subst ce_bndrMap ce_in_scopemkStgLet exprIsHNFlikediffExpr diffIdInfo diffUnfoldlocBindControl.Monad.Trans.RWS.StrictRWST removeRhsCCCSlocalcomputeCbvInfo substIdBndrExitifyM exitifyReccse_bindCSEnvnoCSE extendCSEnv addBinderATidStateHackOneShotInfo safeArityType trimArityType andArityTypefindRhsArityEnvpedanticBottoms myExprIsCheap myIsCheapAppmkEtaWWEtaInfocantEtaReduceFun ATLamInfocombineWithDemandOneShotsdecideJoinPointHoodmkCoreAppTypedmkCoreBoxedTuplewrapBoxboxTymkSmallTupleSelectormkSmallTupleSelector1mkSmallTupleCase mkExceptionIddivergingIdInfoaBSENT_ERROR_IDnoFloatIntoRhsExprSize _es_size_is_es_args _es_discountlitSizecallSizejumpSize traceInlineGHC.LanguageExtensions.Type Extension setLanguagesetSafeHaskellcombineSafeFlagsupdOptLevelChanged safeFlagCheck allFlagsDepsunrecognisedWarningflagSpec flagSpec'warnSpec warnSpec' depFlagSpecOp depFlagSpec depWarnSpec subWarnSpecdepFlagSpecOp' depFlagSpec'depFlagSpecCond flagGhciSpec flagGhciSpec'flagHiddenSpecflagHiddenSpec'hideFlagnegatableFlagsDeps dFlagsDeps fHoleFlagslanguageFlagsDepssafeHaskellFlagsDepsvalidHoleFitDefaults enableDLintmkFlagUnitPrecedenceMapRevIndexModuleNameProvidersMap UnitConfigunitConfigPlatformArchOSunitConfigWaysunitConfigAllowVirtualunitConfigProgramNameunitConfigGlobalDBunitConfigGHCDirunitConfigDBNameunitConfigAutoLinkunitConfigDistrustAllunitConfigHideAllunitConfigHideAllPluginsunitConfigDBCacheunitConfigFlagsDBunitConfigFlagsExposedunitConfigFlagsIgnoredunitConfigFlagsTrustedunitConfigFlagsPluginsUnitVisibility uv_renamingsuv_package_nameuv_requirements uv_explicit VisibilityMapfromExposedModulesfromReexportedModulesfromFlag originVisible originEmpty mkUnitInfoMap findPackagesselectPackagesrenameUnitInfosortByPreferencecompareByPreference reverseDeps removeUnitsdepsNotAvailabledepsAbiMismatchmergeDatabasesvalidateDatabasemkModuleNameProvidersMap mkUnusableModuleNameProvidersMap addListTomkModMapadd_unit improveUnit' mkHomeUnit anyTy_maybe checkAnyTytcTyFamInstsAndVisXtcTyConAppTyFamInstsAndVisXD:R:XFunBindGhcPassGhcPassD:R:XFunBindGhcPassGhcPass0noOp cloneArray boundsCheckedalwaysSinkable onceSinkablecollectUsedOncecollectArgsTop topSortDeclssinkPgm' setStackDepth getStackDepthmodifyStackDepth modifySlots loadSkipI ddcModuleddcId setObjInfoL setObjInfo genStaticArgparseFFIPatternparseFFIPatternAparseFFIPattern' ApplySpecspecConvspecArgsspecVars ApplyConvRegsConv StackConv jumpToFastgenericApplyNamegenericApplyExpr specApplyName specApplyExprspecApplyExprMaybe mkApplySpec selectApply applySpecspecTag specTagExpr mkApplyArrpushContgenericStackApplygenericFastApply specApply stackApply fastApply numSpecPap specPapIdents getIdFields storeIdFieldsmkPapgenBind genEntryLnegenEntry resultSizeverifyRuntimeReps popLneFrame genUpdFrame bhSingleEntry optimizeFreeallocClsgenCasegenAltsnormalizeBranchesverifyMatchRep loadUbxTupmkIfElsemkEqmkPrimIfBranch loadParams branchResult pushRetArgs allocDynAll genPrimOp mkAlgBranch InstMatches instMatches instGuardspruneOverlappedMatches overridesinsert_overlappingReprFlagSymFlagopt_co1opt_co2opt_co3 opt_co4_wrapopt_co4 opt_phantomwrapRole chooseRolejsexeExtensioncommonCppDefs_vanillacommonCppDefs_profiledgenCommonCppDefs pprPatBndrconPatNeedsParensisIrrefutableHsPat'pprImportSuggestionpprSimilarName collect_bindshsDataDefnBinders home_imps ModIfaceCoreScDepth lGRHSCtOriginpprCtO tyCoFVsOfCt tyCoFVsOfCtEv tyCoFVsOfCtstyCoFVsOfCtEvs tyCoFVsOfWCtyCoFVsOfImplicminuslogExactdivide rootExactgenRootgenLoglookupCycleBreakerVar initNabla initTmState decEqualityeqPmLit eqConLikepprLygSequence PmExprList pmExprAsListpprRefutableShapesprettifyRefuts getCleanNamepprPmVar NilTerminatedWcVarTerminated GHC.GenericsGenerictte_countEntries TickDensityTickForCoverageTickForBreakPointsTickAllFunctionsTickTopFunctionsTickExportedFunctions TickCallSitesshouldTickBindaddTickLHsExprLetBodytickSameFileOnlyPRTypeQextQext1Qext2Qext1ext2HasTypeQGDiagnosticCodeGhcDiagnosticCode ConRecursInto commafyWithmissingSignatureWarningFlagpprSolverReportWithCtxtpprTcSolverReportMsgpprPotentialInstancespotentialInstancesErrMsgpotentials_msg_with_options%overlapping_but_not_more_specific_msgpprExpectedActualInfoexpandSynonymsToMatchformat_frr_errcannotMakeDerivedInstanceHerald ExtsBitmapGenSemicnested_comment_logictyConToDataCon checkTyVarscheckUnboxedLitPatcheckNotPromotedDataConensureValidOpExpcvtOpApp cvtOpAppPcvtSigTypeKind cvtTypeKindmk_apps cvtOpAppTcvtMaybeKindToFamilyResultSigcvtFamilyResultSigcvtInjectivityAnnotation mkHsForAllTy mkHsQualTytemplate-haskellCxtmkHsContextMaybe cvtConstr getIdentifier ColumnBoundHdkWarnHdkStflattenBindsAndSigsmjmzmu toUnicodeAnnmomc commentsPAHappyStksuggestInstantiatedWithsafeTrysoe_optssoe_inl soe_subst soe_rec_idsdataConSrcToImplBang dataConArgRep mkUbxSumAltTyCprWwResultOneWwUsenop_fn mkAppsBetaaddVoidWorkerArgwwUseForUnliftingcanUnboxResult mkWWcpr_entry mk_res_bndr mkWWcpr_oneunbox_one_resultmove_transit_varscprCaseBndrMultSigEnvse_topsse_sigsae_sigs ae_virgin ae_fam_envs ae_rec_dccprAnalcprAnal'cprTransformBespokecprTransformDataConWork mAX_CPR_SIZE cprAnalBindcprDataStructureUnfolding_maybeextendSigEnvListextendSigEnvFromIdsextendSigEnvAllSameextendSigEnvForArg argCprType cprAnalAlt cprTransform splitThunklc_optslc_lvl lc_lvl_env lc_rec_env lc_scrutsae_optsWeakDmdsisInterestingTopLevelFn dmdAnalBindAnalEnvsetBindIdDemandInfosetIdDmdAndBoxSigdmdAnalBindLetUpuseLetUpdmdAnalBindLetDown dmdAnalRhsSig anticipateANFexprMayThrowPreciseExceptionforcesRealWorldresultType_maybe unariseArity enterDFunextendAnalEnvs dmdTransformfinaliseLetBoxity AsmTempLabelAsmTempDerivedLabelIdLabelLocalBlockLabel CmmLabelInfoCmmInfo CmmRetInfoCmmRetCmmCode CmmClosure CmmPrimCallRtsSelectorInfoTableRtsApInfoTable RtsApFast InfoTableLocalInfoTable LocalEntry IdTickyInfoConEntry ConInfoTable ClosureTableBytesBlockInfoTableTickyRednCountsTickyInferedTagRtsLabel ForeignLabel ModuleLabelDynamicLinkerLabel PicBaseLabelDeadStripPreventer HpcTicksLabelSRTLabelLargeBitmapLabel labelTypequickSourcePoswithSpan myCollectArgs scopeToPaths scopeUniquesSymSetSymMapppLlvmFunctionHeader ppLlvmBlocks ppLlvmBlockppLlvmBlockLabelppLlvmStatementppLlvmExpressionppCallnewLine exclamationrootNTargetNodeInfo liBackEdgesliLevelsliLoopsNoInfoHeapStackCheckupdateEdgeWeight optHsPatterns staticPredCfgstaticBranchPredictioncheckIsReverseDependentcomputeLiveness livenessBlocklivenessForward livenessBackmkRegM makeRAStatsCleanS sJumpValid sJumpValidAcc sReloadedBy sCleanedCountsCleanedSpillsAccCleanMSlot cleanSpincleanBlockForward cleanForward cleanReloadcleanTopBackwardcollateJoinPoints findRegOfSlot initCleanS accJumpValid isStoreReg emptyAssocaddAssocdelAssoc delAssoc1 elemAssoc closeAssocintersectAssoc cleanBackwardSpillSstateUS stateSpillSLSpillM regSpill_topregSpill_blockregSpill_instr spillRead spillWrite spillModify patchInstr initSpillSmakeSpillStats buildAllocsinkReg takeVirtualsspillCost_length nodeDegree maxSpinCount regAlloc_spin buildGraphgraphAddConflictSetgraphAddCoalescepatchRegsFromGraphpprAlignForSectionpprSectionAlign pprSizeDeclthunkEntryLabelwithClosureLclswithLclmkSeqs InferExtEq inferTagRhs envVersion envConfig envLogger envOutputenvMask envFreshMeta envUniqMeta envFunMap envAliases envUsedVars envVarMap envStackRegs llvmGhcCC modifyEnv saveAliasisBuiltinLlvmVar LlvmAccumEOption exprToVarExprDatabasicBlocksCodeGenbasicBlockCodeGen stmtsToInstrs stmtToInstrs getInstrinct2 getInstrinctbarrier barrierUnlessgenCallgenCallWithOverflowgenCallExtract getFunPtrW getFunPtr arg_varsWarg_vars castVarsWcastVarscastVarcmmPrimOpFunctionsgenJump genAssigngenStore genStore_fast genStore_slow genBranch genCondBranch genExpectLit genSwitchi1Option wordOption genMachOpgenMachOp_fastgenMachOp_slowgenLoad genLoad_fast genLoad_slow getCmmReg getCmmRegValallocReg funPrologue funEpilogue getHsFuncdoExpr expandCmmReg blockIdToLlvm getTBAAMetagetTBAARegMetasingletonPanic structStrlinkagegenGlobalLabelArrayllvmSectionType llvmSectioncmmDataLlvmGens cmmLlvmGencmmMetaLlvmPreludecmmUsedLlvmGensmachOpNeedsCaststaticLitsToWords pprHexVal pprCtorArray inlineSRT wordAlignedmkLivenessBitspprProcEndLabel BlockContext blockContexts interestingneeds_probe_call pprProcLabelpprBlockEndLabelmakeRegMovementGraph expandNodehandleComponentmakeMovejoinToTargets'OutputableRegConstraintlinearRegAlloc processBlock initBlocklinearRAraInsn clobberRegsfindPrefRealReg newLocationloadTemplinearRegAlloc'ncgLabelDynamic picRelativeAmodeRegisterCondCodeaddSpUnwindingsgetRegisterRegis32BitIntegerjumpTableEntry getSomeReggetAmodegetSimpleAmodeaddAlignmentCheckgenCondBranch'evalArgs genPrimCCall genLibCCall genRTSCCallgenCCallgenCtz genCtz64_32 genCtzGeneric genMemCpy genMemSet genSimplePrim genCCall32 genCCall64 BlockChain FrontierMapneighbourOverlapp breakChainAtcombineNeighbourhood sequenceChain dropJumps DwarfAbbrev DwAbbrNull pprAbbrevpprLabelStringpprDwarfInfoOpenpprDwarfInfoClose pprFrameProc pprFrameBlockdwarfGlobalRegNo pprSetUnwind pprLEBRegNo pprUnwindExprpprUndefUnwindpprData4 pprString' escapeChar mkDwarfARangecompileUnitHeadercompileUnitFooterdebugSplitProcs procToDwarf blockToDwarf debugFrame procToFrameswizzleRegisterRep opRegWidthisAArch64Bitmask signExtendReg truncateReg RewriteFun' TransferFun' sortBlocks mkDepBlocks updateFactBlockEntryLivenessLBlockEntryLivenessCmmLive noLiveOnEntrynoLiveOnEntryL conflicts lintShiftOpmayNotMentionCallerSavedRegsContainingSyntax IfThenElse ControlFlow smartExtend<$~>SomeWasmPostCCallSomeWasmPreCCall WasmPushessomeWasmTypeFromCmmTypewasmMemoryNarrowingsymNameFromCLabelsymVisibilityFromCLabelsymKindFromCLabeldataSectionKindFromCmmSectionalignmentFromCmmSectionlower_CmmStatic truncSubword extendSubwordlower_MO_Un_Homolower_MO_Bin_Homolower_MO_Bin_Homo_Trunclower_MO_Bin_Homo_Ext_Trunclower_MO_Bin_Rel_Extlower_MO_Bin_Rel shiftRHSCast lower_MO_Shllower_MO_U_Shrlower_MO_S_Shrlower_MO_MulMayOflolower_MO_Un_Convlower_MO_SS_Convlower_MO_UU_Convlower_MO_FF_Convlower_CmmMachOp lower_CmmLitlower_CmmRegOfflower_CmmLoad_Typed lower_CmmLoad lower_CmmExprlower_CmmExpr_Typedlower_CmmExpr_Ptrlower_CMO_Un_Homolower_CMO_Bin_Homolower_MO_UF_Convlower_MO_Cmpxchglower_CallishMachOplower_CmmUnsafeForeignCall_Droplower_CmmUnsafeForeignCalllower_CmmStorelower_CmmActionlower_CmmActionslower_CmmGraphonTopSym onFuncSymonAnySym onCmmLocalRegonCmmLocalReg_TypedonFini onCmmInitFini onCmmData onCmmProc onCmmDeclWasmAsmM doTailCall asmWithTab asmTellLine asmTellLFasmTellTabLine NativeGenAcc ngs_natives ngs_unwinds cmmNativeGens checkLayoutcomputeUnwindingmakeImportsDocCmmSuper nodeSplitinflate cgraphOfCmm definedLabels changeLabelschangeBlockLabelsrelabel dont_care copyTicksfcs_upframeoffset fcs_sequel fcs_selfloop fcs_ticky fcs_tickscopeDecls addVarDecladdLabel addDynTagLitBoundmk_discrete_switch needsArgTagcollectExprLoads annotatePrimmemoryOrderToTsanMemoryOrder tsanTarget tsanAtomicCas TickyThunkTickyLNE tickyArgArityregisterTickyCtrTickyFun emitTickyDataemitCallWithExtraStackslowArgsbinderInfoOccursAsArgtagSkeletonExprrhsCard closureSizeidClosureFootprinttagSkeletonLettagSkeletonBindingliftRhs ruleCantMatchmatchN st_max_ticksst_read_ruleenvgenUnits modulePrefix mkPrimOpId primOpIdsNumOpsnumAddnumSubnumMulnumAndnumOrnumNeg numLitTypeOpValBinOpAppshiftRightLogicalNative boundsCmp int8Result int16Result int32Result intCResult word8Result word16Result word32Result wordResult wordCResultsemiInversePrimOpextendNarrowPassthroughnarrowSubsumesAndsameArgIdempotentCommutisBignumLiteralisNumberLiteralisLitNumConAppleftIdentityCPlatformrightIdentityCPlatformidentityCPlatform mkNumLiteralhandleSeqHValueStatus spawnIServ ForeignRef RemoteReficExtendGblRdrEnvCompactedModuleCode cmc_exports ModuleCode mc_exportsbytesPerModulepackedMetaDataSize renderLinkerrenderLinkerStats combineFiles writeHtml writeRunMaingetDeps collectDepsdiffDepsrtsDeps mkBaseFuns mkPrimFunsmkExportedFuns loadObjDepsloadArchiveDepsgetJsArchiveEntryisJsFilegetJsBSreadDepsFromObj linkModules nubStaticInfostaticInitStatstaticDeclStat writeRunnerhptModulesBelow orIfNotFoundhomeSearchCachefindInstalledHomeModulefindPackageModulefindPackageModule_ mkDynObjPath mkDynHiPath mkHiePathemitInitializerDeclsldvWord generic_gc mkGcLabel DataCAFEnv CAFfyLabelgetLabelledBlocks depAnalSRTsgetCAFs getStaticFuns resolveCAFSRTEntrydoSCConeSRT buildSRTChain updInfoSRTs closeNursery openNurseryPrimopCmmEmit_ExternalPrimopCmmEmit_Internal asUnsigned emitPrimOpgenericWordAddCOpgenericWordSubCOpdoPrefetchByteArrayOpdoPrefetchMutableByteArrayOpdoPrefetchAddrOpdoPrefetchValueOpmkBasicPrefetchdoNewByteArrayOpdoCopyByteArrayOpdoCopyMutableByteArrayOpdoCopyByteArrayToAddrOpdoCopyMutableByteArrayToAddrOpdoCopyAddrToByteArrayOpdoSetByteArrayOp doNewArrayOp doCopyArrayOpdoCopyMutableArrayOpemitCloneArrayemitCloneSmallArray emitSetCardsdoAtomicByteArrayRMWdoAtomicReadByteArraydoAtomicReadAddrdoAtomicWriteByteArraydoAtomicWriteAddremitMemcpyCallemitCheckedMemcpyCallemitMemmoveCallemitMemsetCallemitCopyUpdRemSetPushalignmentFromTypes emitCopyArrayemitCopySmallArraydoAtomicAddrRMWdoCasByteArrayemitBoundsCheckemitRangeBoundsCheckdoPtrArrayBoundsCheckdoSmallPtrArrayBoundsCheckdoByteArrayBoundsChecksm_spsm_args sm_ret_offsm_regs fixupStackallocate manifestSpfalseStackCheckelimStackStorescpsTopBCEnvallocateTopStrings mkStackBitmappushConstrAtomisSupportedCConvmkStackOffsets mkProtoBCOlabelsToSourcesWithTNTClabelsToSourcesSansTNTC liftIOEnv emptyWriterDictBindFDB fdb_bindsSpecArgSpecTypeSpecDict UnspecType UnspecArg spec_importstryWarnMissingSpecs specHeaderbindAuxiliaryDictmkDBbind_fvsrecWithDumpedDictsSpecConstrOpts sc_max_argssc_debug sc_uf_opts sc_modulesc_sizesc_count sc_recursivesc_keenspecialisableArgOcc wildCardPatcloneCaseBndrs le_platform le_diagOptslintRhs lintCoreExpr lintJoinLams lintCastExprcheckCanEtaExpandcheckCaseLinearity lintValApp withoutAnnotsinitL mk_cast_errcontEvalContext simplTick makeTriviallabelledTraceOptTcRn wrapDocLocadd_diagnostic candidateVars defaultTyVarszonkTcTypeMapperfieldSelectorSuggestionsimportSuggestions ShNameSubst ns_module substNamesubstNameAvailInfosetNameFieldSelector mergeAvails uAvailInfos uAvailInfouName uHoleNameShIfEnvShIfM initRnIface rnIfaceGlobalrnIfaceNeverExportedrnIfaceClsInst checkFRR_with unifyConcreteensureConcreteknownKeyNamesOkay knownKeysMapcgTickwithSourceNotedoStore getTables putWithTablesinitBinMemSizeloadInterfaceWithExceptionis_external_sigcomputeInterfaceload_dynamic_too_maybeextendIdZonkEnvRec mkHEqBoxTy mkEqBoxTyhasFixedRuntimeRepResfillInferResult tcSubTypeNCtcDeeplySkolemiseKindRepM KindRepEnvplatformtrTyConDataCon trNameLit TypeRepTodoExportedKindRepsTodo mod_rep_exprpkg_fingerprintmod_fingerprint todo_tycons TypeableTyConmkTypeRepTodoBindsmkPrimTypeableTodosghcPrimTypeableTyConsghcTypesTypeableTyCons collect_stuff mkTrNameLitmkTyConRepBindskindIsTypeablebuiltInKindRepsmkExportedKindReps runKindRepM getKindRep mkKindRepRhsmkTyConRepTyConRHStraceTR instSchemewarnRedundantRecordWildcardwarnUnusedRecordWildcard reportableGHC.Serialized Serialized toSerializedfromSerializedserializeWithDatadeserializeWithDatacollectCostCentres cpe_configcpe_env FloatTick cpeBodyNFCpeBodycpeBodyFloatsokCpeArg wrapTickscheckForConflictscheckInjectiveEquation isTFHeadedbareTvInRHSViolatedunusedInjTvsInRHSreportUnusedInjectiveVarsErrreportTfHeadedErrreportBareVariableInRHSErrreport_unsolved importantdeferringAnyBindingsignoreConstraint mkErrorItemunsuppressErrorItemzonkTidyTcLclEnvspprSolverReportSupplementarypprValidHoleFitspprConstraintsInclude mkHoleErrorzonkAndGroupSkolTvsmaybeAddDeferredBindingsmkFRRErrfixedRuntimeRepOrigin_maybemkCoercibleExplanationshouldPprWithExplicitKinds validHoleFitslookupFixityRn'FieldsOrSelectors WantNormalWantBoth WantFieldFoundExactOrOrigExactOrOrigErrorNotExactOrOriglookupExactOcc_eitherlookupGlobalOccRn_overloadedlookupOneQualifiedNameGHCilookupQualifiedNameGHCiSafeOverlapping matchTypeabledoFunTy doTyConApponlyNamedBndrsAppliedmkTcScheckWellStagedInstanceWhatuseVarsnewWantedEvVarrestoreTyVarCyclesrunTcSWithEvBinds'RewriteTvResultRTRNotFollowed RTRFollowedRewriteM mkRewriteMsetEqRelrewrite_args_fastrewrite_args_slow rewrite_corewrite_reduction split_pi_tys'ty_con_binders_ty_binders' zonk_eq_typescan_eq_newtype_nc canEqCast canEqFailurecanEqHardFailurecanEqReflexiverewriteEvidenceInstDFunTcPluginProgresspluginInputCtspluginSolvedCts pluginBadCts pluginNewCts SolvedCtsSplitCtsrunTcPluginsGivenrunTcPluginsWantedrunTcPluginSolvers!tryLastResortProhibitedSuperclassnaturallyCoherentClassdominatingMatch impliedBySCsdefaultCallStackspickQuantifiablePredsdefaultTyVarTcS TelescopeAcc ValidityEnv ExpandModeExpandNoExpandBothTypeOrKindCtxt OnlyTypeCtxt OnlyKindCtxtBothTypeAndKindCtxtcheckUserTypeErrortypeOrKindCtxttypeLevelUserTypeCtxtallConstraintsAllowedlinearityAllowed vdqAllowedinitialExpandModecheckHasFieldInstsplitInstTyForValiditycheckValidTypePatscheck_arg_typewarnUnqualifiedImport gresFromIEwarnMissingSignatureswarnMissingKindSignaturescheckPatSynParentOpNameNormalOpNegateOp UnboundOpRecFldOppartition_nwcsrnImplicitTvBndrswildCardsAllowedcheckPolyKindslookupFixityOp filterInScopefilterFreeVarsToBind checkWildCard mkExpandedPatgeneralizeOverLitValInstDeclFreeVarsMap KindSigEnvKindSig_FV_EnvClosedTyFamInfo ClosedTyFamNotClosedTyFamAssocTyFamInfoNonAssocTyFamEqnAssocTyFamDefltAssocTyFamInstpatchForeignImportcheckCanonicalInstances rnRoleAnnotsmkInstDeclFreeVarsMaprnInjectivityAnnextendPatSynEnvrnFamEqncheck_namespace runRnSpliceStmtTree MonadNames postProcessStmtsForApplicativeDonoPostProcessStmtsrebindableContextrearrangeForApplicativeDomkStmtTreeHeuristicmkStmtTreeOptimalstmtTreeToStmtssegments splitSegmentmkApplicativeStmtneedJoin isReturnApprnStmtsegmentRecStmtsmergeStaticObjects loadObjects dynLoadObjsmakeForeignNamedHValueRefs linkSomeBCOs getGCCPathsgccSearchDirCachegetSystemDirectories addEnvPathsloadDependenciesisAbstractIfaceDeclmergeIfaceDeclmergeIfaceDeclstc_iface_binding tc_iface_decltcUnfoldingRhs SkolemModeTcTyMode mode_tykitc_infer_lhs_typetc_infer_hs_type_ektc_infer_hs_type tcInferTyAppstcInferTyApps_nosatcheckExpectedKindnewNamedWildTyVarkcInferDeclHeaderkcCheckDeclHeader_sigkindGeneralizeSomekindGeneralizeNone finish_tuplekcCheckDeclHeaderkcCheckDeclHeader_cuskmatchExpectedPatTy checkGADTtc_pat tcPatSynPatmatchExpectedConTy localSigWarnrecursivePatSynErr SynCycleMcheckTyConIsAcycliccheckHsigIface check_instifaceDeclNeverExportedRefsaddTransitiveDepInfocheckImplementstc_patsyn_finishmkPatSynRecSelBindsauxBindSpecRdrNamemk_showString_appmk_showsPrec_app mk_shows_appgenAuxBindSpecOriginalgenAuxBindSpecDupgenAuxBindSpecSig mkFunBindSE mkFunBindEC postfixModTbl assoc_ty_idassoc_ty_id_maybenewAuxBinderRdrNameArgTyAlg argTyFoldfoldBal cond_stdOK cond_args ConditioninferConstraintsStockinferConstraintsAnyclass simplifyDerivrebuild_hs_appstcRemainingValArgs tcMatchescmd_arr tcCmdMatchestcCmdMatchLambdatcCmdTop quickLookArgdesugarRecordUpdmake_lines_msg tcTupArgs tcSynArgE tcSynArgA deriveClause derivePred genInstBinds genFamInstsderivingThingFailWithgetInitialKind tcInjectivity getArgExpKind rejigConReswrongNumberOfParmsErrget_fam_decl_initial_kind getFamFlavtcDefaultAssocDecl mkGADTVarsmkDsEnvsFromTcGblTopNormaliseTypeResultpmTopNormaliseTypeNormalisedByConstraints HadRedexes addPhiCtsupdRcmvanillaCompleteMatchTCaddCompleteMatchesaddConLikeMatchesaddTyConMatchestntrGutspmIsClosedTypenormaliseSourceTypeWHNFisSourceTypeInWHNFinitFueladdTyCtstyOraclenameTyCt addPhiTmCtaddBotCtaddConCt addNotBotCt addNotConCtaddVarCt addCoreCtmodifyT Control.Monad.Trans.State.StrictrepresentCoreExprmakeDictsCoherentinhabitationTestvarNeedsTesting instantiateinstBotsplitReprTyConApp_maybeinstCompleteSetsinstCompleteSetinstConisDataConTriviallyInhabitedtriviallyInhabitedTyConKeysmatchConLikeResTy leftToRight topToBottomthrottledsFCalldsFractionalLitToRationalwarnAboutOverflowedLiteralsgetLHsIntegralLitgetIntegralLitgetSimpleIntegralLit getLHsCharLitgetNormalisedTyconName getTyconName mkPmLetVar vanillaConGrd mkListGrds mkPmLitGrds desugarPat desugarPatV desugarLPatV desugarLPatdesugarListPatdesugarConPatOut desugarLGRHS desugarGuarddesugarLocalBinds desugarBinddesugarBoolGuardFormatReportWarningsModeformatReportWarningsCIRB collectInModecirb_cov cirb_inacccirb_red cirb_bangs noCheckDsaddRedundantBangs testRedSetsreportWarningslocallyExtendPmNablasdsHsBind makeCorePairds_ev_typeablegetRepmkMetaWrappersrepFamilyResultSigrepFamilyResultSigToMaybeKindrepInjectivityAnnnullOuterImplicitnullOuterExplicit repTyVarBndr repMaybeLTy coreNothing coreNothing'coreJust coreJust'repData TcViewPat dsMcBindStmtmaxBuildLength dsConLike checkVersions checkPlugins checkHsigcheckHie checkFlagHashcheckOptimHash checkHpcHash checkModUsagegetOrphanHashesmkIfaceAnnCache mkObjectUsage UnariseEnv extendRhounariseSumAltsmkUbxSumubxSumRubbishArg unariseFunArg unariseConArg PlanResultrun_th_modfinalizers andThenCheck checkUnless checkListBycheck checkSuccesstcPreludeClashWarn getMainOccrunPlans tcUserStmt tcGhciStmts getGhciStepIOrnDumptcMissingParentClassWarnHasTypeToHieTVScopedPScopedRScoped SigContextPatSynFieldContext IEContext RFContext listScopes patScopestaScopestvScopesPS getStgToDocheckBrokenTablesNextToCodelogWarningsReportErrorshandleWarningsThrowErrors ioMsgMaybe'extract_renamed_stuff hsc_typecheck checkObjects checkByteCode genModDetailshscCheckSafeImportscheckSafeImports hscCheckSafe' checkPkgTrustmarkUnsafeInferhscGetSafeModehscSimpleIface mkMetaTyVaremitQuoteWantedbrackTytcPendingSplice seqSerialized lookupDeclDoc lookupArgDocgetExternalModIfacelookupThInstNameaddModFinalizerRef runRemoteTH readQResult getTHStategetThSpliceOrigin annotThTypetyConArgsPolyKindedreifyInstances'findEnclosingDeclsupdateFixityEnv phaseIfAfterlink'MakeNewModSummarymakeNewModSummaryMakeEnv AbstractSem ResultVar BuildPlan SingleModule ResolvedCycleUnresolvedCycleModuleGraphNodeWithBootFile loadFinishguessOutputFile pruneCache waitResultinterpretBuildPlan upsweep_mod addSptEntrieswarnUnnecessarySourceImportsenableCodeGenForTHenableCodeGenWhen mkRootMap wrapAction wait_deps_hug wait_depsrunParPipelinesrunAllPipelinesrunLoopupsweepgetPreprocessedImports rehydratepartition_args normalise_hypcheckNewDynFlagsunitIdOrHomeUnitbindSuspensionsBkpEnv bkp_session bkp_filename bkp_table bkp_levelBkpM SessionType ExeSession TcSession CompSessionwithBkpSession hsunitDepsaddUnit getBkpEnv getBkpLevel innerBkpM updateEpsGhc_ getEpsGhcinitBkpMbackpackProgressMsg mkBackpackMsg backpackStyle msgTopPackage msgUnitId msgIncludehsunitModuleGraphhsModuleToModSummary newUnitId