!"#$%&'()*+ , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCD E F G H I J K L M N OPQRSTUVW!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t"u"v"w"x#y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&''''''''((((())))))) ) ) ) ) *********++++++++++ ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{-|-}-~---------------...............................///////////////////////////////////////////////////////////////////////////////////////////// / / / / //////0000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0000000000000000000000001111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222333333333333333333 3 3 3 3 3333333333333333333 3!3"4#5$5%5&5'5(5)5*5+5,5-5.5/606162636465666768696:6;6<6=6>6?6@6A6B6C6D6E6F6G6H6I6J6K7L7M7N7O7P7Q7R7S8T8U8V8W8X8Y8Z8[8\8]^_`abcdefghijklmnopqrst9u9v9w9x9y9z9{9|9}:~:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; ; ; ;;;;;;;;;;;;;;;;;;; ;!;";#;$;%;&;';(;);*;+;,;-<.</<0<1<2<3<4<5<6<7<8<9<:<;<<<=<><?<@<A<B<C<D<E<F<G<H<I<J<K<L<M<N<O<P=Q=R=S=T=U=V=W=X=Y=Z=[>\>]>^>_>`>a>b>c>d>e>f>g>h>i>j>k>l>m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}?~??@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCDDDD D D D D DDDDDDDDDDDDDDDDDDD D!D"D#D$D%E&E'E(E)E*E+E,E-E.E/E0E1E2E3E4E5E6E7E8E9E:E;E<E=E>E?E@EAEBECEDEEEFEGEHFIFJFKFLFMFNFOFPFQFRFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaFbFcFdFeFfFgFhFiFjFkFlFmFnFoFpFqFrFsFtFuFvFwFxGyGzG{G|G}G~GGGGGGGGGGGGHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLMMMMMNNNNNNNNNNNNNNNNNNNNN N N N N NNNNNNNNNNNNNNNNNNN N!N"N#N$N%N&N'N(N)N*N+N,N-N.N/N0N1N2N3N4N5N6N7O8O9O:O;O<O=O>O?O@OAOBOCODOEOFOGOHOIOJOKOLOMONOOOPOQOROSOTOUOVOWOXOYOZO[O\O]O^O_O`OaObOcOdOeOfOgPhPiPjPkPlPmPnPoQpQqQrQsQtQuQvQwQxQyQzQ{Q|Q}Q~QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRSSSSSSSSSSSSSSSSTTTTTUUVVVVVVVVVVVVVVSSRRWWWWWWWWWWWWW W W W W WWXXXXXXXXXXXXXXXXX X!X"X#X$X%X&X'X(X)X*X+X,X-X.X/X0X1X2X3X4X5X6X7X8X9X:X;X<X=X>X?X@XAXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRXSXTXUXVXWXXXYXZX[X\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXkXlXmXnXoXpXqXrXsXtXuXvXwXxXyXzX{X|X}X~XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z !Z "Z #Z $Z %Z &Z 'Z (Z )Z *Z +Z ,Z -Z .Z /Z 0Z 1Z 2Z 3Z 4Z 5Z 6Z 7Z 8Z 9Z :[ ;[ <[ =[ >[ ?[ @[ A[ B[ C[ D[ E[ F[ G[ H[ I[ J[ K[ L[ M[ N[ O[ P[ Q[ R[ S[ T[ U[ V[ W[ X[ Y[ Z[ [[ \[ ][ ^[ _[ `[ a[ b[ c[ d[ e[ f[ g[ h\ i\ j\ k] l] m] n] o] p] q] r] s] t] u] v] w] x] y] z] {] |] }] ~] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ _ _ _ _ _ !_ "_ #_ $_ %_ &_ '_ (_ )_ *_ +_ ,_ -_ ._ /_ 0_ 1_ 2_ 3_ 4_ 5_ 6_ 7_ 8_ 9_ :_ ;_ <_ =_ >_ ?_ @_ A_ B_ C_ D_ E_ F_ G_ H_ I_ J_ K_ L_ M_ N_ O_ P_ Q_ R_ S_ T_ U_ V_ W_ X_ Y_ Z_ [_ \_ ]_ ^_ __ `_ a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ {_ |_ }_ ~_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` a a a a a a a a a a a a a a a a a a a a a a a a a a a a a b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b !b "c #c $c %c &c 'c (c )c *c +c ,c -c .c /c 0c 1c 2c 3c 4c 5d 6d 7d 8d 9d :d ;d <d =d >d ?d @d Ad Be Ce De Ee Fe Ge He Ie Je Ke Le Mf Nf Of Pf Qf Rg Sg Tg Ug Vg Wg Xg Yg Zg [g \g ]g ^g _g `g ag bg cg dg eg fg gg hg ig jg kg lg mg ng og ph qh rh sh ti ui vi wi xi yi zi {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 k k k k l l l l l l l l m m                                                              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnonpoqprpsptpupvpwpxpypzp{p|p}q~qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss s s s s sssssssssssssssssss s!s"s#s$s%s&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLtMuNuOuPuQuRuSuTuUuVuWuXuYuZu[u\u]u^u_u`uaubucudueufuguhuiujukulumunuoupuqurusutuuuvuwuxuyuzu{u|u}u~uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu u u u u uuuuuuuuuuuvvvvvvvv v!w"w#w$w%w&x'x(x)x*x+x,x-x.x/x0x1x2x3x4x5x6x7x8x9x:x;x<x=x>x?x@xAxBxCxDxExFxGxHxIxJxKxLxMxNxOxPxQxRxSxTxUxVxWxXxYxZx[y\y]y^y_y`yaybycydzezfzgzhzizjzkzlzmznzozp{q{r{s{t{u{v{w{x{y{z{{{|{}{~{{{{{{{{{{{{{{{{{{{{{{vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ooooooo      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ww w!w"w#w$w%w&w'w(w)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRpSpTpUpVpWpXpYpZp[p\p]p^p_p`papbpcpdpepfpgphpipjpkplpmpnpopppqprpsptpupvpwpxpypzp{p|p}p~pppppppppppttttttttttttt      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~nnnnnnnnnnnnnnnnnnnnn      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred Analogous to  in  Data.Maybe.  Analogous to  in  Data.Maybe.  Analogous to  in  Data.Maybe.  Analogous to  in  Data.Maybe.  unionWith for collections of size <= 1. Unzipping a list of length <= 1. Filtering a singleton list. filterMaybe p a =  ( p [a])  Version of # with different argument ordering.  Version of # with different argument ordering.  Often, we want to case on a , do something interesting  in the ( case, but only a default action in the  ) case. Then, the argument ordering of  caseMaybe is preferable. (caseMaybe m err f = flip (maybe err) m fMonadic version of . Monadic version of . Monadic version of  .  That is, % with a different argument ordering.  with flipped branches. A more telling name for  for the  collection type.  Or:   without the  case.  without the  case.      Safe-Inferred Safe-InferredNoneCharacteristic identifiers. Given a function f :: a -> (C,[C])# which returns a non-empty list of  characteristics C of a, partition a list of as into groups , that share at least one characteristics. Partition a list of a"s paired with a non-empty list of 9 characteristics $C$ into groups that share at least one  characteristics. None Finite bijective map from a to b. There, and back again. Lookup. O(log n). Inverse lookup. O(log n). !Empty bimap. O(1). "Singleton bimap. O(1). #/Insert. Overwrites existing value if present. $!Left-biased Union. O(Map.union). % Construct from a list of pairs. ADoes not check for actual bijectivity of constructed finite map. &3Turn into list, sorted ascendingly by first value.  !"#$%&'( !"#$%&'( !"#$%&'( !"#$%&'( Safe-Inferred)Pointed class. >We could have used Data.Pointed by Edward Kmett, but it has a  lot of package dependencies. )*)*)*)*  Safe-Inferred56 +,-./0123456 5,+034.2-1/656  Safe-Inferred789789789789  Safe-Inferred;>Converts many character sequences which may be interpreted as # line or paragraph separators into '\n'. :;:;:;:; NoneAIf f a contains many copies of a& they will all be the same pointer in L the result. If the function is well-behaved (i.e. preserves the implicit  equivalence, this shouldn' t matter). <=>?@A     <=>?@A<=>@?A<=>?@A      Safe-InferredBJCut off structural order comparison at some depth in termination checker? Dc >= 0( means: record decrease up to including c+1. BCDBCDBDCBDC Safe-InferredEFGHEFGHEFGHEFGH Safe-InferredIBReturns a close function for the file together with the contents. IIIINoneMBifunctoriality for pairs. N mapFst f = f -*- idO mapSnd g = id -*- gPLifted pairing. Q*Swap. (Only in Data.Tuple from base-4.3) WMonadic version of M. XMonadic N. YMonadic O. JKLMNOPQRSTUVWXYJKLMNOPQRSTUVWXYMNOPQRSTUVWXYJKLJKLMNOPQRSTUVWXYNone ZLike  Bifunctor, but preserving sharing. ^Like , but preserving sharing. bThe Change monad. The ChangeT monad transformer. dThe class of change monads. gRun a b1 computation, returning result plus change flag. hBlindly run an updater. iMark a computation as dirty. kGReplace result of updating with original input if nothing has changed. Eval an updater (using k). A mock change monad. Z[\]^_` = sharing . updater1abcde.Mark computation as having changed something. fghijkZ[\]^_`abcdefghijkbdefgckhij^_`aZ[\]Z[\]^_`abcdefghijk Safe-InferredlIs the operator associative? mIs the operator commutative? nIs the operator idempotent? o(Is the element a zero for the operator? p(Is the element a unit for the operator? q<Does the first operator distribute (from the left) over the  second one? r=Does the first operator distribute (from the right) over the  second one? s8Does the first operator distribute over the second one? tGenerates natural numbers. uGenerates positive numbers. v7Generates a list of elements picked from a given list. wAIf the given list is non-empty, then an element from the list is = generated, and otherwise an arbitrary element is generated. xGenerates values of $ type, using the given generator to  generate the contents of the   constructor. y Coarbitrary " generator" for . zGenerates two elements. {Generates three elements. |Runs the tests, and returns ! if all tests were successful. lmnopqrstuvwxyz{| A label for the tests. Used for  informational purposes. lmnopqrstuvwxyz{|lmnopqrstuxyvwz{|lmnopqrstuvwxyz{| Safe-Inferred}~"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~}~}~ Safe-Inferred  Semirings.  Addition. Multiplication. Zero. 0 The one is never used in matrix multiplication . , one :: a -- ^ One. HasZero= is needed for sparse matrices, to tell which is the element $ that does not have to be stored.  It is a cut-down version of SemiRing which is definable  without the implicit ?cutoff. ESemiRing type class. Additive monoid with multiplication operation. (Inherit addition and zero from Monoid. Semiring invariant. The standard semiring on s. The standard semiring on s. The standard semiring on s. None5=We test our properties on integer sets ordered by inclusion. Inclusion comparison wrapper. Pointwise comparison wrapper. Decidable partial orderings. 7The result of comparing two things (of the same type). No information (incomparable). Greater than. Greater or equal. Equal Less or equal than.  Less than. 5Comparing the information content of two elements of  (. More precise information is smaller. Includes equality: x  x == True.  Opposites. related a po b iff related b (oppPO po) a. ECombining two pieces of information (picking the least information). . Used for the dominance ordering on tuples. orPO. is associative, commutative, and idempotent.  orPO has dominant element POAny, but no neutral element. Chains (transitivity)  x R y S z. seqPO. is associative, commutative, and idempotent.  seqPO has dominant element POAny and neutral element (unit) POEQ. Embed . %Represent a non-empty disjunction of s as . A ! information is a disjunction of  informations. Any  is a . ,Are two elements related in a specific way?  related a o b holds iff comparable a b is contained in o. Any two elements are  in the way  computes. -flip comparable a b == oppPO (comparable a b)AAuxiliary function: lists to sets = sorted duplicate-free lists.  is inclusion of the associated  sets. ( amounts to the union of the associated  sets.  Except that 'orPO POLT POGT == POAny' which should also include .  is associative.  is commutative.  is idempotent. The dominant element wrt.  is .  Soundness of . 6As QuickCheck test, this property is inefficient, see . -A more efficient way of stating soundness of .  The unit of  is .  The zero of  is .  is associative.  is also commutative.  is idempotent.  distributes over . The result of & is a sorted list without duplicates. From  to  and back is the identity. From  to  Orderings and back is the identity. From  Orderings to  and back is the identity.  Except for [LT,GT], which is a non-canonical representative of . 3Pairs are related iff both components are related.  Comparing -s amounts to compare their representation as   sets. Less is `` less general'' (i.e., more precise). )Sets are partially ordered by inclusion. Sublist for ordered lists. 5The pointwise ordering for lists of the same length. -There are other partial orderings for lists, E e.g., prefix, sublist, subset, lexicographic, simultaneous order. 'Pointwise partial ordering for tuples. related (x1,x2) o (y1,y2) iff related x1 o x2 and related y1 o y2. $Partial ordering for disjoint sums: Left _ and Right _ are unrelated.  and   _ are unrelated. Partial ordering for Maybe a is the same as for  Either () a. ?Partial ordering forms a semiring under supremum (disjunction) . and composition (transitivity, sequencing) 2Partial ordering forms a monoid under sequencing. All tests as collected by #. Using #* is convenient and superior to the manual ; enumeration of tests, since the name of the property is  added automatically. B445None!HRun a parser on a list of tokens. Returns the list of complete matches. )Consumes and returns the next character. $ Fails if there is no input left. @Look-ahead: returns the part of the input that is left, without  consuming it. Always fails. Symmetric choice. 5Local, exclusive, left-biased choice: If left parser < locally produces any result at all, then right parser is  not used. 5Transforms a parser into one that does the same, but 2 in addition returns the exact characters read.  IMPORTANT NOTE: - gives a runtime error if its first argument 1 is built using any occurrences of readS_to_P. =Consumes and returns the next character, if it satisfies the  specified predicate. ,Parses and returns the specified character. )Parses and returns the specified string. CParses the first zero or more characters satisfying the predicate. BParses the first one or more characters satisfying the predicate. ,Combines all parsers in the specified list. Skips all whitespace.  count n p parses n occurrences of p in sequence. A list of  results is returned. between open close p parses open, followed by p and finally  close. Only the value of p is returned.  option x p will either parse p or return x without consuming  any input.  optional p optionally parses p and always returns (). 5Parses zero or more occurrences of the given parser. 4Parses one or more occurrences of the given parser. Like , but discards the result. Like , but discards the result.  sepBy p sep$ parses zero or more occurrences of p, separated by sep. ( Returns a list of values returned by p.  sepBy1 p sep# parses one or more occurrences of p, separated by sep. ( Returns a list of values returned by p.  endBy p sep$ parses zero or more occurrences of p, separated and ended  by sep.  endBy p sep# parses one or more occurrences of p, separated and ended  by sep.  chainr p op x$ parses zero or more occurrences of p, separated by op. ! Returns a value produced by a right associative application of all  functions returned by op!. If there are no occurrences of p, x is  returned.  chainl p op x$ parses zero or more occurrences of p, separated by op. ! Returns a value produced by a left associative application of all  functions returned by op!. If there are no occurrences of p, x is  returned. Like (, but parses one or more occurrences of p. Like (, but parses one or more occurrences of p. manyTill p end$ parses zero or more occurrences of p, until end 2 succeeds. Returns a list of values returned by p. 7Converts a parser into a Haskell ReadS-style function. ) This is the main way in which you can "run" a  parser:  the expanded type is  / readP_to_S :: ReadP a -> String -> [(a,String)]  7Converts a Haskell ReadS-style function into a parser. @ Warning: This introduces local backtracking in the resulting 2 parser, and therefore a possible inefficiency. 8!!2 Safe-Inferred=Reads a UTF8-encoded text file and converts all Unicode line  endings into '\n'. ?Writes UTF8-encoded text to the handle, which should be opened > for writing and in text mode. The native convention for line  endings is used.  The handle'4s text encoding is not necessarily preserved, it is  changed to UTF8. @Writes a UTF8-encoded text file. The native convention for line  endings is used.  Safe-Inferred &A version of the trampoline function. The usual function iterates f :: a -> Maybe a as long  as Just{}, is returned, and returns the last value of a  upon Nothing. !usualTrampoline f = trampoline $  "a -> maybe (False,a) (True,) (f a). Monadic version of . Iteration to fixed-point. iterateUntil r f a0 iterates endofunction f, starting with a0,  until r( relates its result to its input, i.e., f a r a. :This is the generic pattern behind saturation algorithms. If f is monotone with regard to r,  meaning a r b implies f a r f b,  and f-chains starting with a0 are finite . then iteration is guaranteed to terminate. *A typical instance will work on sets, and r could be set inclusion,  and a0 the empty set, and f. the step function of a saturation algorithm. Monadic version of .  n f x applies f to x n times and returns the  result. *The applications are calculated strictly. applyWhen b f a applies f to a when b. applyUnless b f a applies f to a unless b. Monadic version of  applyWhen Monadic version of  applyUnless NoneSemiring with idempotent  == dioid E.g. + neutral element of compose , e.g. zero None5The flexibe variables contained in a pice of syntax. 3The rigid variables contained in a pice of syntax. *Make offsets non-negative by rounding up. Offsets + n must be non-negative Executing a substitution. APartial substitution from flexible variables to size expression.  +Type of solution wanted for each flexible.  -Assigning a polarity to a flexible variable.  *What type of solution are we looking for? 4Constraint: an inequation between size expressions,  e.g. X < " or  i + 3 "d j. /Comparison operator, e.g. for size expression. "d. <. +Size expressions appearing in constraints. Meta variable X + n.  Infinity ". Variable plus offset i + n. Constant number n. !Size meta variables X to solve for. $Fixed size variables i. 'Constant finite sizes n >= 0. *Default polarity is . ,Returns ( if we have a contradictory constraint. - acts as !,  as . . Interpret  as relation on '. Add offset to size expression. Comparison operator is ordered  < . J      !"#$%&'()*+,-.2      !"#$%&'()*+,-.4'$%&!"#        ()*+,-.1         !"#$%&'()*+,-. Safe-Inferred             None5 Timestamps. 6The current time. 7/Measure the time of a computation. Returns the 567567567567 Safe-Inferred! !"#$%&'()*+,-./01234 Safe-Inferred;<5678;<;<;<5678 Safe-InferredCalign max rows lays out the elements of rows in two columns, A with the second components aligned. The alignment column of the  second components is at most max characters to the right of the  left-most column. Precondition: max > 0. =>?@ABC9:B;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu=>?@ABC=>?@ABC=>?@ABC9:  Safe-Inferred D unionWith for collections of size <= 1. EUnzipping a list of length <= 1. FFiltering a singleton list. filterMaybe p a = v ( p [a])G Version of w# with different argument ordering. H Version of x# with different argument ordering.  Often, we want to case on a , do something interesting  in the  ( case, but only a default action in the  ) case. Then, the argument ordering of  caseMaybe is preferable. (caseMaybe m err f = flip (maybe err) m fIMonadic version of x. JMonadic version of y. KMonadic version of H.  That is, I% with a different argument ordering. LK with flipped branches. MA more telling name for  for the  collection type.  Or: H without the  case. NK without the  case. DEFGHIJKLMN xzy{wv|}~DEFGHIJKLMN DEFGHIJKLMN DEFGHIJKLMN Safe-Inferred O@A decoration is a functor that is traversable into any functor. The 0 superclass is given because of the limitations  of the Haskell class system.   traverseF! actually implies functoriality. Minimal complete definition:  traverseF or  distributeF. P traverseF is the defining property. Q&Decorations commute into any functor. S@Composition: pure function after functorial (monadic) function. TThe true pure for loop.   is a misnomer, it should be forA. U#Any decoration is traversable with traverse = traverseF.  Just like any  Traversable is a functor, so is ! any decoration, given by just  traverseF , a functor. VAny decoration is a lens. set is a special case of fmap. 1A typical decoration is pairing with some stuff. 4Decorations compose. (Thus, they form a category.) &The identity functor is a decoration. OPQRSTUV OPQRSTUV RSTOPQUV OPQRSTUV!None Used to test n and m.  Used to test n and m. W Graph n e# is a directed graph with nodes in n and edges in e. %Only one edge between any two nodes. Represented as adjacency list, or rather, adjacency map. 7 This allows to get all outgoing edges for a node in O(log n) time  where n& is the number of nodes of the graph. * Incoming edges can only be computed in O(n + e) time where  e is the number of edges. Z'A structural invariant for the graphs.  The set of nodes is obtained by Map.keys . unGraph = meaning that each node, be it only the target of an edge, @ must be assigned an adjacency map, albeit it could be empty. See a. [$Turn a graph into a list of edges. O(n + e) \*All edges originating in the given nodes. 3 (I.e., all outgoing edges for the given nodes.) 0Roughly linear in the length of the result list  O(result). ]%Returns all the nodes in the graph. O(n). ^@Constructs a completely disconnected graph containing the given  nodes. O(n). _/Constructs a graph from a list of edges. O(e) `"Empty graph (no nodes, no edges). a5A graph with two nodes and a single connecting edge. bInsert an edge into the graph. c>Removes the given node, and all corresponding edges, from the  graph. dremoveEdge n1 n2 g removes the edge going from n1 to n2, if  any. j The graph'8s strongly connected components, in reverse topological  order. k The graph'8s strongly connected components, in reverse topological  order. lReturns True iff the graph is acyclic. m.Computes the transitive closure of the graph. =Note that this algorithm is not guaranteed to be correct (or % terminate) for arbitrary semirings. 4This function operates on the entire graph at once. n.Computes the transitive closure of the graph. =Note that this algorithm is not guaranteed to be correct (or % terminate) for arbitrary semirings. @This function operates on one strongly connected component at a  time. pallPaths classify a b g5 returns a list of pathes (accumulated edge weights)  from node a to node b in g. ? Alternative intermediate pathes are only considered if they  are distinguished by the classify function. q>Generates a node from the graph. (Unless the graph is empty.) r@Generates an edge from the graph. (Unless the graph contains no  edges.) s All tests. %WXYZ[\]^_`abcdefghijklmnopqrsWXYZ[\]^_`abcdefghijklmnopqrsWXYZ[\]e^_`abcdfghijklmnopqrs!WXYZ[\]^_`abcdefghijklmnopqrs" Safe-Inferredt" Impossible"/ errors, annotated with a file name and a line @ number corresponding to the source code location of the error. vAbort by throwing an " impossible" error. You should not use 2 this function directly. Instead use the macro in  undefined.h. w Catch an " impossible" error, if possible. tuvwtuvwtuvwtuvw# Safe-Inferredxxxx$None#y Result of . zThe lists are incomparable. {The lists are equal. | First list is suffix of second. } First list is prefix of second. Head function (safe). Opposite of cons (:), safe. Maybe cons. "mcons ma as = maybeToList ma ++ as  and  in one go, safe. "Lookup function (partially safe). downFrom n = [n-1,..1,0] 0Update the last element of a list, if it exists A generalized version of  partition.  (Cf. mapMaybe vs. filter). A generalized version of  takeWhile.  (Cf. mapMaybe vs. filter). A generalized version of span. Partition a list into s and  s.  w f = snd . partitionMaybe f. Sublist relation. ;Check if a list has a given prefix. If so, return the list  minus the prefix. 4Compare lists with respect to prefix partial order. CSplit a list into sublists. Generalisation of the prelude function  words.  words xs == wordsBy isSpace xs ,Chop up a list in chunks of a given length. .All ways of removing one element from a list.  Check whether a list is sorted. Assumes that the & instance implements a partial order. <Check whether all elements in a list are distinct from each  other. Assumes that the $ instance stands for an equivalence  relation. An optimised version of . Precondition: The list's length must fit in an . ?Checks if all the elements in the list are equal. Assumes that  the . instance stands for an equivalence relation.  A variant of , which applies the predicate to consecutive  pairs.  f =  (() `on` f)   ( `on` f). #splitExactlyAt n xs = Just (ys, zs) iff  xs = ys ++ zs  and genericLength ys = n.  n xs gives the n-th element in xs D (counting from 0), plus the remaining elements (preserving order). A generalised variant of . -Requires both lists to have the same length. HEfficient version of nub that sorts the list first. The tag function is ! assumed to be cheap. If it isn'+t pair up the elements with their tags and  call uniqBy fst (or snd). (Compute the common suffix of two lists. (Compute the common prefix of two lists. 0yz{|}~0yz{|}~0~y}|{z,y}|{z~%None1Sample edge type used to test  and . Sample node type used to test  and . Sample graph type used to test  and . For homogeneous graphs, (s = t) we can compute a set  of all nodes.  Structure Nodes% is for computing all nodes but also 7 remembering which were incoming and which outgoing. A This is mostly for efficiency reasons, to avoid recomputation # when all three sets are needed. Outgoing node. Incoming node. Edge label (weight).  Graph s t e is a directed graph with  source nodes in s  target nodes in t  and edges in e. /Admits at most one edge between any two nodes. ? Several edges can be modeled by using a collection type for e. Represented as adjacency list, or rather, adjacency map. 4 This allows to get all outgoing edges for a node  in O(log n) time where n& is the number of nodes of the graph. Forward edges. Reverse an edge. $Turn a graph into a list of edges. O(n + e) *All edges originating in the given nodes. 3 (I.e., all outgoing edges for the given nodes.) 0Roughly linear in the length of the result list  O(result). %All edges ending in the given nodes. 3 (I.e., all incoming edges for the given nodes.)  Expensive: O(n * |ts| * log n). Get all self-loops. Lookup label of an edge. *Get a list of outgoing edges with target. ,Returns all the nodes with outgoing edges. O(n). 7Returns all the nodes with incoming edges. Expensive! O(e). .The set of all nodes (outgoing and incoming). @Constructs a completely disconnected graph containing the given  nodes. O(n). 5Constructs a graph from a list of edges. O(e log n) %Later edges overwrite earlier edges. 5Constructs a graph from a list of edges. O(e log n) ILater edges are combined with earlier edges using the supplied function. +Convert a graph into a list of edges. O(e) "Empty graph (no nodes, no edges). 5A graph with two nodes and a single connecting edge. Insert an edge into the graph. #Insert an edge, possibly combining old edge weight with new weight by  given function f into  f new old. Left-biased union. .The opposite graph (with all edges reversed). *Auxiliary function to turn empty map into Nothing. LRemoves the given source node, and all corresponding edges, from the graph.  O(log n). LRemoves the given target node, and all corresponding edges, from the graph.  Expensive!  O(n log n). 0Removes the given node, be it source or target, 0 and all corresponding edges, from the graph.  Expensive!  O(n log n). removeEdge s t g removes the edge going from s to t , if any.  O((log n)^2). 1Keep only the edges that satisfy the predicate. O(e). 5Unzipping a graph (naive implementation using fmap).  The graph'8s strongly connected components, in reverse topological  order.  The graph'8s strongly connected components, in reverse topological  order. Returns True iff the graph is acyclic. composeWith times plus g g' finds all edges  s --c_i--> t_i --d_i--> u and constructs the  result graph from !edge(s,u) = sum_i (c_i times d_i). Complexity: for each edge s --> t in g we lookup up  all edges starting in with t in g'. .Computes the transitive closure of the graph. =Note that this algorithm is not guaranteed to be correct (or % terminate) for arbitrary semirings. 4This function operates on the entire graph at once. .Computes the transitive closure of the graph. =Note that this algorithm is not guaranteed to be correct (or % terminate) for arbitrary semirings. 4This function operates on the entire graph at once. .Computes the transitive closure of the graph. =Note that this algorithm is not guaranteed to be correct (or % terminate) for arbitrary semirings. AThis function operates on one strongly connected component (SCC)  at a time. 6For each SCC, it uses a saturation algorithm on state (g, es)  where initially es$ is the set of edges of the SCC and g the graph.  The algorithm finishes if es" has not changed in an iteration.  At each step, all es are composed with g, the resulting  new graphs are unioned with g . The new es is then computed $ as the edges of the SCC in the new g. =Correctness of the optimized algorithm that proceeds by SCC. 1Find a path from a source node to a target node. *The path must satisfy the given predicate good :: e -> Bool. allPaths classify a b g5 returns a list of pathes (accumulated edge weights)  from node a to node b in g. ? Alternative intermediate pathes are only considered if they  are distinguished by the classify function. >Generates a node from the graph. (Unless the graph is empty.) @Generates an edge from the graph. (Unless the graph contains no  edges.)  All tests. I55=&None&Things that support delayed dropping. *Delayed dropping which allows undropping. 'Non-negative number of things to drop. Where to drop from.  Partial permutations. Examples: permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] (proper permutation).  permute [1,0] [x0,x1,x2] = [x1,x0] (partial permuation). permute [1,0,1,2] [x0,x1,x2] = [x1,x0,x1,x2]. (not a permutation because not invertible). Agda typing would be:  9Perm : {m : Nat}(n : Nat) -> Vec (Fin n) m -> Permutation  m is the < of the permutation. permute [1,2,0] [x0,x1,x2] = [x1,x2,x0]  More precisely, permute indices list = sublist , generates sublist  from list1 by picking the elements of list as indicated by indices.  permute [1,3,0] [x0,x1,x2,x3] = [x1,x3,x0]  Agda typing:  ,permute (Perm {m} n is) : Vec A m -> Vec A n Identity permutation. "Restrict a permutation to work on n elements, discarding picks >=n. :Pick the elements that are not picked by the permutation. liftP k takes a  Perm {m} n to a Perm {m+k} (n+k).  Analogous to , > but Permutations operate on de Bruijn LEVELS, not indices.  2permute (compose p1 p2) == permute p1 . permute p2JTurn a possible non-surjective permutation into a surjective permutation.  permute (reverseP p) xs == $ reverse $ permute p $ reverse xs Example:   ( permute (reverseP (Perm 4 [1,3,0])) [x0,x1,x2,x3] ) == permute (Perm 4 $ map (3-) [0,3,1]) [x0,x1,x2,x3]  == permute (Perm 4 [3,0,2]) [x0,x1,x2,x3]  == [x3,x0,x2]  == reverse [x2,x0,x3] ( == reverse $ permute (Perm 4 [1,3,0]) [x3,x2,x1,x0] ( == reverse $ permute (Perm 4 [1,3,0]) $ reverse [x0,x1,x2,x3]   DStable topologic sort. The first argument decides whether its first ; argument is an immediate parent to its second argument. Perform the dropping.  Drop more. Pick up dropped stuff. ' Safe-Inferred&Paths which are known to be absolute. Note that the  and % instances do not check if different / paths point to the same files or directories. Andreas, 2014-03-30: " For efficiency of serialization,  is implemented  as ) which short-cuts equality testing using = pointer equality. This saves 20% of the serialization time  of the standard library!  Extract the  to be used as . =The paths have to be absolute, valid and normalised, without  trailing path separators.  Constructs s. 3Precondition: The path must be absolute and valid. maps blablabla foo.bar.xxx to foo.bar. Makes the path absolute. This function may raise an __ IMPOSSIBLE__ error if  # does not return an absolute path. @Tries to establish if the two file paths point to the same file  (or directory). *Case-sensitive doesFileExist for Windows. O This is case-sensitive only on the file name part, not on the directory part. H (Ideally, path components coming from module name components should be K checked case-sensitively and the other path components should be checked  case insenstively.)  (None.Hashing a module name for unique identifiers. ) Safe-Inferred                 * Safe-Inferred !Loop while we have an exception. Monadic version of % with a different argument ordering.  is a bifunctor. ' Either _ b' is a functor. 'Either a' is a functor. Returns ! iff the argument is  x for some x. Returns ! iff the argument is  x for some x. Returns   inputwith tags stripped if all elements are  to the right, and otherwise .   allRight xs ==  if all isRight xs then  Just (map ((Right x) -> x) xs)  else  Nothing         +None,Not very efficient (goes via a list), but it'll do. Big conjunction over a map.  Filter a map based on the keys.  Unzip a map.   ,None <Result of comparing a candidate with the current favorites. !/Sorry, but you are dominated by that favorite. #?Great, you are dominating a possibly (empty list of favorites) 3 but there is also a rest that is not dominated.  If null dominated, then  notDominated is necessarily the  complete list of favorites. &"A list of incomparable favorites. )No favories yet? *No favorites yet. Poor me! +"You are my one and only, darling! ,Gosh, got some pretty a* here, compare with my current favorites! ? Discard it if there is already one that is better or equal. ; (Skewed conservatively: faithful to the old favorites.) , If there is no match for it, add it, and & dispose of all that are worse than a. GWe require a partial ordering. Less is better! (Maybe paradoxically.) -9Compare a new set of favorites to an old one and discard 8 the new favorites that are dominated by the old ones  and vice verse. ; (Skewed conservatively: faithful to the old favorites.) compareFavorites new old = (new', old')/*After comparing, do the actual insertion. 0"Compare, then insert accordingly.  :insert a l = insertCompared a l (compareWithFavorites a l) 1>Insert all the favorites from the first list into the second. 26Construct favorites from elements of a partial order. 5 The result depends on the order of the list if it 8 contains equal elements, since earlier seen elements ' are favored over later seen equals. 0 The first element of the list is seen first. 7A second way to compute the 1 is to use -. & forms a  under * and 'union. =Equality checking is a bit expensive, since we need to sort!  Maybe use a " of favorites in the first place? 8All tests as collected by #. Using #* is convenient and superior to the manual ; enumeration of tests, since the name of the property is  added automatically.  !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./012345678&'()*+ #!$%",-./012345678 #!$%"&'()*+,-./012345678-None">-Lower or upper bound for a flexible variable FA graph forest. L Going from Lt to Le is pred , going from Le to Lt is succ. X --(R,n)--> Y  means  X (R) Y + n. ! [ ... if n positive  and X + (-n) (R) Y if n negative. ] MNodes not connected. Q5Test for negativity, used to detect negative cycles. a2Compute list of edges that start in a given node. b0Compute list of edges that target a given node. :Note: expensive for unidirectional graph representations. c Set.foldl* does not exist in legacy versions of the  containers package. dFloyd-Warshall algorithm. e5Convert a label to a weight, decrementing in case of . kSplit a list of graphs gs into those that mention node n and those that do not.  If n& is zero or infinity, we regard it as  not mentioned. lAdd an edge to a graph forest. 6 Graphs that share a node with the edge are joined. mReflexive closure. Add edges 0 -> n -> n -> oo for all nodes n. nh n g if any edge in g between rigids and constants ) is implied by a corresponding edge in h, which means that  the edge in g/ carries at most the information of the one in h. @Application: Constraint implication: Constraints are compatible  with hypotheses. q3Build a graph from list of simplified constraints. r3Build a graph from list of simplified constraints. z3Compute a lower bound for a flexible from an edge. {4Compute an upper bound for a flexible from an edge. |7Compute the lower bounds for all flexibles in a graph. }7Compute the upper bounds for all flexibles in a graph. ~1Compute the bounds for all flexibles in a graph. FCompute the relative minima in a set of nodes (those that do not have  a predecessor in the set). FCompute the relative maxima in a set of nodes (those that do not have  a successor in the set). ?Given source nodes n1,n2,... find all target nodes m1,m2, such D that for all j, there are edges n_i --l_ij--> m_j for all i. G Return these edges as a map from target notes to a list of edges. 2 We assume the graph is reflexive-transitive. ?Given target nodes m1,m2,... find all source nodes n1,n2, such D that for all j, there are edges n_i --l_ij--> m_j for all i. G Return these edges as a map from target notes to a list of edges. 2 We assume the graph is reflexive-transitive. CCompute the sup of two different rigids or a rigid and a constant. CCompute the inf of two different rigids or a rigid and a constant. %Compute the least upper bound (sup). DCompute the greatest lower bound (inf) of size expressions relative  to a hypotheses graph. DSolve a forest of constraint graphs relative to a hypotheses graph. % Concatenate individual solutions. /Check that after substitution of the solution, * constraints are implied by hypotheses.  A graph is R1 if it contains a negative loop (diagonal edge). % Makes sense on transitive graphs. %An edge is negative if its label is. Partial implementation of Num. u9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~T9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~TZYXWV[\]^_`abcdSUTQRLNMOPeGKJIHfghiFjklmnopqrEDCstuBvAwx?@>y9:;<=z{|}~e9:;<=>?@ABCDEFGKJIHLNMOPQRSUTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.NoneProperties of  class. Weight instance. Label instance. Runs all tests starting with prop_ in this file. $#/ Safe-InferredAgsy's meta variables. aB the type of the metavariable (what it can be instantiated with).  blk> the search control information (e.g. the scope of the meta). =Maybe an instantiation (refinement). It is usually shallow, B i.e., just one construct(or) with arguments again being metas. ,Does this meta block a principal constraint ' (i.e., a type-checking constraint). ;List of observers, i.e., constraints blocked by this meta. 5Used for experiments with independence of subproofs. Experimental. Result of type-checking.  Obsolete. BForking proof on something that is not part of the term language. + E.g. whether a term will reduce or not. Experimental, related to .  First arg is sidecondition. %Parallel conjunction of constraints. Experimental. Definite failure.  Success. l     g     g     A     0 Safe-Inferred&#Entry of an explicit substitution. &An explicit substitution is a list of CActions. 6 This is isomorphic to the usual presentation where  Skip and Weak' would be constructors of exp. substs. 3Shifting substitution (going to a larger context). 'For going under a binder, often called Lift. Instantation of variable. An expression a in an explicit substitution  [CAction a]. CLazy concatenation of argument lists under explicit substitutions. "Head-normal form of . First entry is exposed. -Q: Why are there no projection eliminations? -)Constructor parameter (missing in Agda). & Agsy has monomorphic constructors. 7 Inserted to cover glitch of polymorphic constructor ! applications coming from Agda .!proj pre args, projfcn idx, tail /Application and tail. 0No more eliminations. 1Maybe expression-: Expression or reference to meta variable. 2Agsy's internal syntax. 3'Absurd lambda with hiding information. 5True5 if possibly dependent (var not known to not occur).  False if non-dependent. 6 Lambda with hiding information. 8Unique identifier of the head. 9(This application has been type-checked. :Head. ; Arguments. @#Head of application (elimination). E Dot pattern. IConstant definitions. NConstant signatures. PFor debug printing. Q Reference to the Agda constant. RType of constant. SConstant definition. T8Free vars of the module where the constant is defined.. UAbstraction with maybe a name. .Different from Agda, where there is also info ! whether function is constant. ZHiding in Agda. aThe concrete instance of the blk parameter in . 7 I.e., the information passed to the search control. m2Size of typing context in which meta was created. n"Head normal form of type of meta. o:True if iota steps performed when normalising target type 2 (used to put cost when traversing a definition $ by construction instantiation). rNat - deffreevars J (to make cost of using module parameters correspond to that of hints). <Unique identifiers for variable occurrences in unification. Substituting for a variable.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~z{|}~tyxwvuaplkjihgfedcbqrsmno`_^Z]\[WYXUVNOPQRSTIMLKJHDGFEC@BA<?>=27654389:;1,0/.-+&*)('"%$#! 0! "%$#&*)('+,0/.-12 7654389:;<?>=@BACDGFEHIMLKJNOPQRSTUVWYXZ]\[^_`aplkjihgfedcbqrsmnotyxwvuz{|}~1 Safe-Inferred=444 2 Safe-Inferred*Typechecker drives the solution of metas. ---$3 Safe-Inferred+      !+      !+      !$      !4 Safe-Inferred"The version of Agda. """"5None #Finite map from [k] to v. With the strict  type, # is also strict in v. $ Empty trie. %Singleton trie. &Left biased union. union = unionWith ( new old -> new). '0Pointwise union with merge function for values. (/Insert. Overwrites existing value if present. insert = insertWith ( new old -> new))7Insert with function merging new value with old value. */Delete value at key, but leave subtree intact. ++Adjust value at key, leave subtree intact. ,Convert to ascending list. -Convert to ascending list. .'Collect all values along a given path. #$%&'()*+,-. #$%&'()*+,-. #$%()&'+*,-.#$%&'()*+,-.6None/>Benchmark structure is a trie, mapping phases (and subphases) + to CPU time spent on their performance. 0,We measure CPU time spent on certain tasks. 1)Account we can bill computation time to. 2 Phases to allocate CPU time to. 3 Subphase for 4. 4 Subphase for H. 5 Subphase for  Serialize. 6 Subphase for G. 7 Subphase for C. 8 Subphase for C. 9 Subphase for C. : Subphase for C. ; Subphase for C. < Subphase for C. =Writing interface files. >Generating highlighting info. ?1Coverage checking and compilation to case trees. @"Checking for projection likeness. AInjectivity checking. B.Positivity checking and polarity computation. CTermination checking. D2Type checking and translation to internal syntax. E3Scope checking and translation to abstract syntax. FReading interface files. GImport chasing. H$Happy parsing and operator parsing. I%Initial benchmark structure (empty). J#Add to specified CPU time account. /0123456789:;<=>?@ABCDEFGHIJ/0123456789:;<=>?@ABCDEFGHIJ2HGFEDCBA@?>=<;:987654310/IJ/012HGFEDCBA@?>=<;:9876543IJ7NoneNN8 adds double quotes around the string, replaces newline  characters with n,, and escapes double quotes and backslashes < within the string. This is different from the behaviour of :    >  $  "\x2200"  "\8704"  >  $ N "\x2200"  """ C(The code examples above have been tested using version 4.2.0.0 of  the base library.) O2Shows a non-negative integer using the characters P2Adds a final newline if there is not already one. Q.Indents every line the given number of steps. R7Show a number using comma to separate powers of 1,000. KLMNOPQRKLMNOPQRNOPQKLMRKLMNOPQR8None SSimple Emacs Lisp expressions. UList. WAtom. XFormats a response command.  Replaces '\n'. with spaces to ensure that each command is a  single line. Y.Writes a response command to standard output. Z display_info' append header content displays content (with  header header) in some suitable way. If append is True, then E the content is appended to previous content (if any), otherwise any  previous content is deleted. %The name of the running info buffer. [Clear the running info buffer. \BDisplay running information about what the type-checker is up to. STUVWXYZ[\  STUVWXYZ[\ SWVUTXYZ[\ SWVUTXYZ[\  None^when_ is just Control.Monad.when with a more general type. _unless_ is just Control.Monad.unless with a more general type. bMonadic if-then-else. c ifNotM mc = ifM (not  $ mc)dLazy monadic conjunction. fLazy monadic disjunction. hLazy monadic disjunction with Either truth values. iGeneralized version of %mapM_ :: Monad m => (a -> m ()) -> [a] -> m () A Executes effects and collects results in left-to-right order. - Works best with left-associative monoids. "Note that there is an alternative  mapM' f t = foldr mappend mempty  $ mapM f t-that collects results in right-to-left order " (effects still left-to-right). 9 It might be preferable for right associative monoids. jGeneralized version of forM_ :: Monad m => [a] -> (a -> m ()) -> m () k. for the continuation monad. Terribly useful. l.Requires both lists to have the same lengths. mA monadic version of w :: (a -> Maybe b) -> [a] -> [b]. nA monadic version of   :: (a -> Bool) -> [a] -> [a]. oFinally for the  ( class. Errors in the finally part take  precedence over prior errors. pBracket for the   class. q<Bracket without failure. Typically used to preserve state. r!Restore state after computation.   To simulate MaybeT by . ]^_`abcdefghijklmnopAcquires resource. Run first. Releases resource. Run last. !Computes result. Run in-between. qAcquires resource. Run first. Releases resource. Run last. !Computes result. Run in-between. rs A !"#$%&'()*+,-./01234]^_`abcdefghijklmnopqrs^_`abcdefghij]klmnopqrs]^_`abcdefghijklmnopqrs 9Nonev Satisfying null empty == True. tuvwxyz{|56789 tuvwxyz{| tuvwxyz{| tuvwxyz{|56789:None$~=Killing the range of an object sets all range information to . <If it is also possible to set the range, this is the class. Instances should satisfy  ( r x) == r. 6Things that have a range are instances of this class. 8A range is a list of intervals. The intervals should be  consecutive and separated. 1Note the invariant which ranges have to satisfy: . An interval. The iEnd+ position is not included in the interval. 4Note the invariant which intervals have to satisfy: . !Represents a point in the input. If two positions have the same  and  components, E then the final two components should be the same as well, but since E this can be hard to enforce the program should not rely too much on A the last two components; they are mainly there to improve error  messages for the user. 4Note the invariant which positions have to satisfy: . File. Position, counting from 1. Line number, counting from 1.  Column number, counting from 1. :;The length of an interval, assuming that the start and end ! positions are in the same file. &Conflate a range to its right margin. <The first position in a file: position 1, line 1, column 1. %Ranges between two unknown positions 'Advance the position by one character.  A newline character ('\n'") moves the position to the first = character in the next line. Any other character moves the  position to the next column. "Advance the position by a string. " movePosByString = foldl' movePos &Backup the position by one character. (Precondition: The character must not be '\n'. BExtracts the interval corresponding to the given string, assuming @ that the string starts at the beginning of the given interval. @Precondition: The string must not be too long for the interval. @Removes the interval corresponding to the given string from the E given interval, assuming that the string starts at the beginning of  the interval. @Precondition: The string must not be too long for the interval. #Converts two positions to a range. .Converts a range to an interval, if possible. @Returns the shortest continuous range containing the given one. 1Removes gaps between intervals on the same line. +The initial position in the range, if any. <The position after the final position in the range, if any. ;5Finds the least interval which covers the arguments. fuseRanges r r' unions the ranges r and r'. !Meaning it finds the least range r0 that covers r and r'.  beginningOf r. is an empty range (a single, empty interval)  positioned at the beginning of r. If r does not have a  beginning, then  is returned. beginningOfFile r. is an empty range (a single, empty interval)  at the beginning of r's starting position's file. If there is no 1 such position, then an empty range is returned. x ` withRangeOf` y sets the range of x to the range of y. <-The positions corresponding to the interval,  including the D end-point. This function assumes that the two end points belong to  the same file. Note that the  instance for s & uses a single, hard-wired file name. =8The positions corresponding to the range, including the @ end-points. All ranges are assumed to belong to a single file. >AConstructs the least interval containing all the elements in the  set. ? Sets the  components of the interval. @<Generates an interval located in the same file as the given  interval.  Test suite. v}~AB:;<=>CDEFGHIJKL?@MNOPQRSTUVWXYZ[\]^_`abcdefghijklmno@}~@~}j}~AB:;<=>CDEFGHIJKL?@MNOPQRSTUVWXYZ[\]^_`abcdefghijklmno;None%%Termination check? (Default = True). 3Skip termination checking but use measure instead. Treat as non-terminating. $Skip termination checking (unsafe). Run the termination checker. IThe unique identifier of a name. Second argument is the top-level module  identifier. 1Is this definition eligible for instance search? Abstract or concrete Access modifier. ?Visible from outside, but not exported when opening the module $ Used for qualified constructors. =Functions can be defined in both infix and prefix style. See  X. String with range info. A RawName is some sort of string. Thing with range info. Only  arguments can have names. Standard naming. 'Something potentially carrying a name.  Similar to , but we need to distinguish 2 an irrelevance annotation in a function domain * (the domain itself is not irrelevant!)  from an irrelevant argument. Dom is used in Pi of internal syntax, in Context and  Telescope.   is used for actual arguments (Var, Con, Def etc.)  and in Abstract syntax and other situations. %A function argument can be hidden and/or irrelevant. A lens to access the  attribute in data structures.  Minimal implementation:  getRelevance and one of  setRelevance or  mapRelevance. 3A function argument can be relevant or irrelevant.  See . 7The polarity checker has determined that this argument : is unused in the definition. It can be skipped during 7 equality checking but should be mined for solutions $ of meta-variables with relevance  5The argument can be skipped during equality checking 8 because its value is already determined by the type. 4The argument is irrelevant at compile- and runtime. 6The argument may never flow into evaluation position. , Therefore, it is irrelevant at run-time. 6 It is treated relevantly during equality checking. 5The argument is (possibly) relevant at compile-time. A lens to access the  attribute in data structures.  Minimal implementation:  getHiding and one of  setHiding or  mapHiding.  5Used to specify whether something should be delayed.  isHidden does not apply to  , only to .   Visible () arguments are  notHidden. (DEPRECATED, use .)  arguments are visible.  and  arguments are  notVisible. Information ordering.   Relevant ` moreRelevant`  UnusedArg ` moreRelevant`  Forced ` moreRelevant`  NonStrict ` moreRelevant`  Irrelevant xs ` withArgsFrom` args translates xs into a list of s,  using the elements in args to fill in the non- fields. 6Precondition: The two lists should have equal length. 'Get the content of a . )The functor instance for  would be ambiguous, $ so we give it another name here. *Thing with no range info.       !"#$%&'()*+,pqrstuvwxyz{|}~p      !"#$%&'()*+,p      !"#$%&'()*+,n      !"#$%&'()*+,pqrstuvwxyz{|}~<None,-./0123456789:;<=>?@ABCDEFGHIJKLMNO#-./0123456789:;<=>?@ABCDEFGHIJKLMNO#?ONMLKJIHGFEDCBA@=>;<9:56781234/0-.-./0123456789:;<=>?ONMLKJIHGFEDCBA@=NonePQRSTUVWXYZ PQRSTUVWXYZ TUVRSPQWXYZPQRSTUVWXYZ>None[\]^_`abcdefghijkl[\]^_`abcdefghijkl[\]^_`abcdefghijkl[\]^_`abcdefghijkl?Nonemnopqrstuvwxyz{|}~mnopqrstuvwxyz{|}~rstuoqpmnvwxyz{|}~mnoqprstuvwxyz{|}~@None""""ANone Part of a Notation +Argument is where the expression should go TArgument is the position of the hole (with binding) where the binding should occur. *A name is a non-empty list of alternating Ids and Holes. A normal name P is represented by a singleton list, and operators are represented by a list  with Hole/s where the arguments should go. For instance:  [Hole,Id +,Hole]  is infix addition. Equality and ordering on Name,s are defined to ignore range so same names & in different locations are equal. 8Data type constructed in the Happy parser; converted to  " before it leaves the Happy code. simple named hole with hiding (x9 -> y) ; 1st argument is the bound name (unused for now) Target of a hole 3Get a flat list of identifier parts of a notation. ATarget argument position of a part (Nothing if it is not a hole) Is the part a hole? 3From notation with names to notation with indices. No notation by default  BNonea number or infinity  e.g. x + 5 ?A solution assigns to each flexible variable a size expression # which is either a constant or a v + n for a rigid variable v. "A matrix with row descriptions in b and column descriptions in c. 7The Graph Monad, for constructing a graph iteratively. Scope for each flexible var. Node labels to node numbers. Node numbers to node labels. Number of nodes n. The edges (restrict to [0..n[). &A constraint is an edge in the graph. For  Arc v1 k v2 at least one of v1 or v2 is a MetaV (Flex), " the other a MetaV or a Var (Rigid).  If k <= 0 this means  suc^(-k) v1 <= v2  otherwise v1 < = suc^k v3. 4Which rigid variables a flex may be instatiated to. Nodes of the graph are either 3 - flexible variables (with identifiers drawn from Int), ' - rigid variables (also identified by Ints), or 6 - constants (like 0, infinity, or anything between). /Edge weight in the graph, forming a semi ring. Warshall'9s algorithm on a graph represented as an adjacency list.  isBelow r w r'  checks, if r and r' are connected by w (meaning w not infinite),  whether r + w <= r'. . Precondition: not the same rigid variable. FThe empty graph: no nodes, edges are all undefined (infinity weight). Add a size meta node. Lookup identifier of a node. & If not present, it is added first. addEdge n1 k n2  improves the weight of egde n1->n2 to be at most k. ' Also adds nodes if not yet present.  sizeRigid r n. returns the size expression corresponding to r + n 8Check that no edges get longer when completing a graph. +Check that all transitive edges are added. 2Check that no edges are added between components. KCC6CNone /Zero or more consecutive and separated ranges. BCharacter ranges. The first character in the file has position 1.  Note that the - position is considered to be outside of the  range.  Invariant:   . The  invariant. The  invariant. ! iff the ranges overlap. *The ranges are assumed to be well-formed. ! iff the range is empty. )Converts a range to a list of positions. 0Converts several ranges to a list of positions.  Converts a  to a .  minus xs ys! computes the difference between xs and ys: the 6 result contains those positions which are present in xs but not  in ys. +Linear in the lengths of the input ranges. All the properties. DNone'Check whether a name is the empty name _. BTop-level module names. Used in connection with the file system. 'Invariant: The list must not be empty.  QName7 is a list of namespaces and the name of the constant. . For the moment assumes namespaces are just Name s and not ! explicitly applied modules. @ Also assumes namespaces are generative by just using derived > equality. We will have to define an equality instance to ? non-generative namespaces (as well as having some sort of ( lookup table for namespace names).  x.  A.rest.  4Mixfix identifiers are composed of words and holes,  e.g. _+_ or  if_then_else_ or [_/_]. Identifier part. _ part. *A name is a non-empty list of alternating s and s. A normal name P is represented by a singleton list, and operators are represented by a list  with /s where the arguments should go. For instance:  [Hole,Id +,Hole]  is infix addition. Equality and ordering on Name,s are defined to ignore range so same names & in different locations are equal. _. A (mixfix) identifier. ,Parse a string to parts of a concrete name. Is the name an operator?  qualify A.B x == A.B.x unqualify A.B.x == xThe range is preserved.  qnameParts A.B.x = [A, B, x] Turns a qualified name into a . The qualified 7 name is assumed to represent a top-level module name. !>Turns a top-level module name into a file name with the given  suffix. "Finds the current project's "root" directory, given a project 3 file and the corresponding top-level module name. Example: If the module "A.B.C" is located in the file  "fooABC.agda", then the root is "foo". 3Precondition: The module name must be well-formed. #  noName_ = $ $  noName r =  r []Define equality on Name, to ignore range so same names in different  locations are equal. (Is there a reason not to do this? -Jeff ENo. But there are tons of reasons to do it. For instance, when using ' names as keys in maps you really don' t want to have to get the range ) right to be able to do a lookup. -Ulf 7      !"#$       !"#$       !"#$.      !"#$ENone %)Precedence is associated with a context. 0Fixity of operators. 40All the notation information related to a name. 7AThe notation is handled as the fixity in the renamer. Hence they $ are grouped together in this type. ;CIf an operator has no specific notation, recover it from its name. @,The default fixity. Currently defined to be 1 20. A<The precedence corresponding to a possibly hidden argument. BBDo we need to bracket an operator application of the given fixity + in a context with the given precedence. D+Does a function application need brackets? E'Does a with application need brackets? F%Does a function space need brackets? '%&'()*+,-./0123456789:;<=>?@ABCDEFG#%&'()*+,-./0123456789:;<=>?@ABCDEFG#789:564;<=>0321?@%/.-,+*)('&ABCDEFG% /.-,+*)('&0321456789:;<=>?@ABCDEFGFNone"H!The result of parsing something. KWhat you get if parsing fails. Mwhere the error occured Nthe remaining input Othe previous token Phopefully an explanation  of what happened Q There aren'"t any parser flags at the moment. S0Should comment tokens be returned by the lexer? T?We need to keep track of the context to do layout. The context = specifies the indentation (if any) of a layout block. See  Agda.Syntax.Parser.Layout for more informaton. Ulayout at specified column V no layout W<To do context sensitive lexing alex provides what is called  start codes N in the Alex documentation. It is really an integer representing the state  of the lexer, so we call it LexState instead. XJThe parser state. Contains everything the parser and the lexer could ever  need. Z#position at current input location [position of last token \the current input ]the character before the input ^the previous token _the stack of layout contexts `the state of the lexer - (states can be nested so we need a stack) acurrently there are no flags bThe parse monad. Equivalent to StateT X (Either K)  except for the definition of fail, which builds a suitable K  object. c@Constructs the initial state of the parser. The string argument > is the input string, the file path is only there because it's part  of a position. dThe default flags. e.The most general way of parsing a string. The Agda.Syntax.Parser will define . more specialised functions that supply the Q and the  W. f/The even more general way of parsing a string. g,The most general way of parsing a file. The Agda.Syntax.Parser will define . more specialised functions that supply the Q and the  W. ;Note that Agda source files always use the UTF-8 character  encoding. kJThe parse interval is between the last position and the current position. p parseError = failqGFake a parse error at the specified position. Used, for instance, when J lexing nested comments, which when failing will always fail at the end L of the file. A more informative position is the beginning of the failing  comment. rUse q or p as appropriate. sIFor lexical errors we want to report the current position as the site of H the error, whereas for parse errors the previous position is the one  we'Gre interested in (since this will be the position of the token we just  lexed). This function does q the current position. t#Return the current layout context. wFShould only be used at the beginning of a file. When we start parsing K we should be in layout mode. Instead of forcing zero indentation we use ' the indentation of the first token. ?HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw0HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw0bHJIXYZ[\]^_`aKLMNOPWTVUQRScdefghikjolmntuvwpqrs)HJIKLMNOPQRSTVUWX YZ[\]^_`abcdefghijklmnopqrstuvwGNone x"Sometimes regular expressions aren'$t enough. Alex provides a way to do K arbitrary computations to see if the input matches. This is done with a  lex predicate. yEIn the lexer, regular expressions are associated with lex actions who's ' task it is to construct the tokens. }$This is what the lexer manipulates. current position current input previously read character ,Get the previously lexed character. Same as . Alex needs this  to be defined to handle "patterns with a left-context". Lex a character. No surprises. !This function is used by Alex 2.  A variant of . !This function is used by Alex 3. Conjunction of xs. Disjunction of xs.  Negation of xs. xyz{|}~xyz{|}~}~yx|{zxyz{|}~HNone EThe LookAhead monad is basically a state monad keeping with an extra  }, wrapped around the b monad. %Get the current look-ahead position. Set the look-ahead position. Lift a computation in the b monad to the  monad. CLook at the next character. Fails if there are no more characters. BConsume all the characters up to the current look-ahead position. -Undo look-ahead. Restores the input from the X. !Consume the next character. Does  followed by . LDo a case on the current input string. If any of the given strings match we P move past it and execute the corresponding action. If no string matches, we O execute a default action, advancing the input one character. This function * only affects the look-ahead position. Same as 9 but takes the initial character from the first argument M instead of reading it from the input. Consequently, in the default case  the input is not advanced. Run a 8 computation. The first argument is the error function.    INone7$This matrix type is used for tests. Transposable things.  m extracts the diagonal of m. 7For non-square matrices, the length of the diagonal is 0 the minimum of the dimensions of the matrix. 7Type of matrices, parameterised on the type of values. @Sparse matrices are implemented as an ordered association list, " mapping coordinates to values. Dimensions of the matrix. "Association of indices to values. &Type of matrix indices (row, column).  Row index, 1 <= row <= rows.  Column index 1 <= col <= cols. Size of a matrix. Number of rows, >= 0. Number of columns, >= 0.  Convert a * to a set of bounds suitable for use with  the matrices in this module. ! iff the matrix is square. Returns ! iff the matrix is empty. 6Compute the matrix size of the union of two matrices. =Compute the matrix size of the intersection of two matrices. #Constructs a matrix from a list of (index, value)-pairs.  O(n) where n is size of the list. "Precondition: indices are unique.  sz rs- constructs a matrix from a list of lists of  values (a list of rows).  O(size) where size = rows cols. Precondition:   rs   sz and   (( sz ) . ) rs. 3Converts a sparse matrix to a sparse list of rows.  O(n) where n2 is the number of non-zero entries of the matrix. #Only non-empty rows are generated. 5Alternative implementation, serves as specification. @Turn a sparse vector into a vector by inserting a fixed element  at the missing positions.  O(size) where size! is the dimension of the vector. *Converts a matrix to a list of row lists.  O(size) where size = rows cols. Returns 'Just b', iff it is a 1x1 matrix with just one entry b.  O(1). >General pointwise combination function for association lists.   O(n1 + n2) where ni- is the number of non-zero element in matrix i. In zipAssocWith fs gs f g h l l', fs' is possibly more efficient version of  w ( (i, a) -> (i,)  $ f a), and same for gs and g.  Instance of ! which keeps longer assoc lists.   O(n1 + n2). <General pointwise combination function for sparse matrices.   O(n1 + n2).  (+) m1 m2 adds m1 and m2, using (+) to add values.   O(n1 + n2). Returns a matrix of size  m1 m2.  f m1 m2! build the pointwise conjunction m1 and m2.  Uses f to combine non-zero values.   O(n1 + n2). Returns a matrix of size  infSize m1 m2. Association list intersection.   O(n1 + n2).  interAssocWith f l l') = { (i, f a b) | (i,a) " l and (i,b) " l' }BUsed to combine sparse matrices, it might introduce zero elements  if f) can return zero for non-zero arguments.  x m adds a new column to m, after the columns D already existing in the matrix. All elements in the new column get  set to x.  x m adds a new row to m, after the rows already @ existing in the matrix. All elements in the new row get set to x. -Size invariant: dimensions are non-negative. Indices must be positive, >= 1. @Matrix indices are lexicographically sorted with no duplicates. & All indices must be within bounds. 1Check whether an association list is ordered and * deterministic, a partial function from i to b. @Generates a matrix of the given size, using the given generator  to generate the rows. &Generates a matrix of the given size. - is identity on well-formed sparse matrices. AConverting a matrix to a list of lists and back is the identity. Any 1x1 matrix is a singleton. ;The length of the diagonal is the minimum of the number of # rows and columns of the matrix. #Transposing twice is the identity.  Old implementation of .  Verify  against older implementation  >Matrix addition is well-defined, associative and commutative.  1Verify addition against an older implementation. :The older implementation did not fully preserve sparsity, A i.e., introduced zeros. Thus, we need to convert to lists to  obtain equal results.  Specification of . Efficient implementation of  matches its specification. 7Matrix multiplication is well-defined and associative. %Generate a matrix of arbitrary size. Matrix transposition.  O(n log n) where n3 is the number of non-zero elements in the matrix. Transposing coordinates. Size of transposed matrix. Diagonal of sparse matrix. O(n) where n3 is the number of non-zero elements in the matrix. QOnly left map remaining. Only right map remaining. "Element only present in left map. #Element only present in right map. Element present in both maps. "Element only present in left map. #Element only present in right map. Element present in both maps. %Element only present in left matrix. &Element only present in right matrix. "Element present in both matrices. Result counts as zero? 7The generator is parameterised on the size of the row.  ! %Element only present in left matrix. &Element only present in right matrix. "Element present in both matrices. Result counts as zero?     "#$%&'( F !     "#$%&'(JNone=A partial order, aimed at deciding whether a call graph gets  worse during the completion. 9In the paper referred to above, there is an order R with  )  Le  Lt. This is generalized to )  'Decr k' where  Decr 1 replaces Lt and Decr 0 replaces Le. < A negative decrease means an increase. The generalization A allows the termination checker to record an increase by 1 which B can be compensated by a following decrease by 2 which results in  an overall decrease. HHowever, the termination checker of the paper itself terminates because D there are only finitely many different call-matrices. To maintain ( termination of the terminator we set a cutoff point which determines C how high the termination checker can count. This value should be & set by a global or file-wise option. See Call for more information. :TODO: document orders which are call-matrices themselves. 'Matrix-shaped order, currently UNUSED. )FNo relation, infinite increase, or increase beyond termination depth. *3Decrease of callee argument wrt. caller parameter. %Raw increase which does not cut off. %Raw decrease which does not cut off. Smart constructor for Decr k :: Order which cuts off too big values. Possible values for k:  - ?cutoff  k  ?cutoff + 1. SSmart constructor for matrix shaped orders, avoiding empty and singleton matrices. le, lt,  decreasing, unknown5: for backwards compatibility, and for external use. IMatrix-shaped order is decreasing if any diagonal element is decreasing. Multiplication of s. (Corresponds to sequential  composition.) +The supremum of a (possibly empty) list of s. 5 More information (i.e., more decrease) is bigger.  )$ is no information, thus, smallest. +(, +, ) forms a semiring, with ) as  zero and Le as one. %The infimum of a (non empty) list of s.  )' is the least element, thus, dominant. ,0We assume the matrices have the same dimension. -It does not get worse then ` increase'. B If we are still decreasing, it can get worse: less decreasing. .Pointwise comparison. 9 Only matrices with the same dimension are comparable. /Information order: ) is least information. 7 The more we decrease, the more information we have. >When having comparable call-matrices, we keep the lesser one. = Call graph completion works toward losing the good calls, 4 tending towards Unknown (the least information). &)*01234+56789,-./:;"*)01234+56789,-./:;KNone-Call matrix augmented with path information. #The matrix of the (composed call). Meta info, like call path. 1Call matrix multiplication and call combination. Call matrices. A call matrix for a call f --> g has dimensions  ar(g) ar(f). 9Each column corresponds to one formal argument of caller f. 7 Each row corresponds to one argument in the call to g. @In the presence of dot patterns, a call argument can be related  to several different formal arguments of f.  See e.g. testsucceedDotPatternTermination.agda:    data D : Nat -> Set where  cz : D zero ) c1 : forall n -> D n -> D (suc n) # c2 : forall n -> D n -> D n  f : forall n -> D n -> Nat ! f .zero cz = zero ) f .(suc n) (c1 n d) = f n (c2 n d) " f n (c2 .n d) = f n d (Call matrices (without guardedness) are    -1 -1 n < suc n and n < c1 n d * ? = c2 n d < = c1 n d   = -1 n <= n and n < c2 n d % ? -1 d < c2 n d ?Here is a part of the original documentation for call matrices " (kept for historical reasons): ;This datatype encodes information about a single recursive B function application. The columns of the call matrix stand for  sourceA function arguments (patterns). The rows of the matrix stand for  target function arguments. Element (i, j) in the matrix should  be computed as follows:   (less than) if the j-th argument to the target : function is structurally strictly smaller than the i-th  pattern.   (less than or equal) if the j-th argument to the  target+ function is structurally smaller than the i-th  pattern.   otherwise. 1Call matrix indices = function argument indices. Machine integer 5 is sufficient, since we cannot index more arguments * than we have addresses on our machine. Non-augmented call matrix. An empty call matrix set. Call matrix is empty? A singleton call matrix set. Insert into a call matrix set. Union two call matrix sets. 0Convert into a list of augmented call matrices. +Generates a call matrix of the given size. <2Call matrix set product is the Cartesian product. =&Augmented call matrix multiplication. >Call matrix multiplication. f --(m1)--> g --(m2)--> h is combined to f --(m2  m1)--> h +Note the reversed order of multiplication:  The matrix c1 of the second call g-->h in the sequence   f-->g-->h is multiplied with the matrix c2 of the first call. Preconditions:  m1 has dimensions  ar(g) ar(f).  m2 has dimensions  ar(h) ar(g). Postcondition:  m1 >*< m2 has dimensions  ar(h) ar(f). $?@ABCD<=EFG>H?@ABCD<=EFG>HLNone9A call graph is a set of calls. Every call also has some . associated meta information, which should be al so that the E meta information for different calls can be combined when the calls  are combined. #Calls are edges in the call graph. : It can be labelled with several call matrices if there 4 are several pathes from one function to another. Call graph nodes. Machine integer 0 is sufficient, since we cannot index more than % we have addresses on our machine. "Make a call with a single matrix. Make a call with empty cinfo. >Converts a call graph to a list of calls with associated meta  information. ?Converts a list of calls with associated meta information to a  call graph. Creates an empty call graph. 9Check whether the call graph is completely disconnected. $Takes the union of two call graphs. "Inserts a call into a call graph. ICall graph combination. Application of  to all pairs (c1,c2)  for which  c1 =  c2.) Call graph comparison.  A graph cs' is `worse' than cs if it has a new edge (call) = or a call got worse, which means that one of its elements  that was better or equal to Le moved a step towards Un. FA call graph is complete if combining it with itself does not make it L any worse. This is sound because of monotonicity: By combining a graph J with itself, it can only get worse, but if it does not get worse after + one such step, it gets never any worse.  cs completes the call graph cs. A call graph is 0 complete if it contains all indirect calls; if f -> g and g ->  h are present in the graph, then f -> h should also be present. JGenerates a call graph. K@Displays the recursion behaviour corresponding to a call graph. L is a monoid under . M combination. f --(c1)--> g --(c2)--> h is combined to  f --(c1 >* c2)-- h Precondition: source c1 == target c2 NOPIJKQRLMNOPIJKQRLMMNone S9The call graph instantiation used by the examples below. 3TODO: This comment seems to be partly out of date.  cs( checks if the functions represented by cs  terminate. The call graph cs should have one entry () per ! recursive function application.  perms; is returned if the functions are size-change terminating. ,If termination can not be established, then  problems is  returned instead. Here problems contains an : indication of why termination cannot be established. See lexOrder  for further details. ANote that this function assumes that all data types are strictly  positive. 5The termination criterion is taken from Jones et al. : In the completed call graph, each idempotent call-matrix < from a function to itself must have a decreasing argument. , Idempotency is wrt. matrix multiplication. =This criterion is strictly more liberal than searching for a G lexicographic order (and easier to implement, but harder to justify). A call c! is idempotent if it is an endo ( == )  of order 1. A (Endo-calls of higher orders are e.g. argument permutations). 0 We can test idempotency by self-composition.  Self-composition c >*< c1 should not make any parameter-argument relation  worse. T(Constructs a call graph. No meta info. UThe example from the JFP' 02 paper. V<An example which is now handled by this algorithm: argument  swapping addition.  S x + y = S (y + x)  Z + y = yWFA related example which is anyway handled: argument swapping addition " using two alternating functions.  S x + y = S (y +' x)  Z + y = y S x +' y = S (y + x) Z +' y = yXA contrived example.  f (S x) y = f (S x) y + g x y  f Z y = y  g x y = f x yITODO: This example checks that the meta information is reported properly  when an error is encountered. YThis should terminate.  )f (S x) (S y) = g x (S y) + f (S (S x)) y )g (S x) (S y) = f (S x) (S y) + g x (S y)Z#Another example which should fail.  f (S x) = f x + f (S x)  f x = f xITODO: This example checks that the meta information is reported properly  when an error is encountered. S[\]TU^V_W`XaYbZcdeS[\]TU^V_W`XaYbZcdeNNonef :: Flag opts6 is an action on the option record that results from  parsing an option. f opts( produces either an error message or an  updated options record The options from an OPTIONS pragma. >In the future it might be nice to switch to a more structured A representation. Note that, currently, there is not a one-to-one 3 correspondence between list elements and options. &Options which can be set in a pragma. JCut off structural order comparison at some depth in termination checker? ,irrelevant levels, irrelevant data matching  )Allow definitions by copattern matching?  1Is pattern matching allowed in the current file? 3In the absence of a path the project root is used. )(This should probably go somewhere else. *FMap a function over the long options. Also removes the short options. > Will be used to add the plugin name to the plugin options. .The default termination depth. f(The default output directory for LaTeX. g'The default output directory for HTML. /.Checks that the given options are consistent. 1Used for printing usage info. hDon' t export 2Parse the standard options. 3&Parse options from an options pragma. 4Parse options for a plugin. 5CThe usage info message. The argument is the program name (probably  agda). z      !"#$%&', is used temporarily, before the paths have  been made absolute. An empty  list is  interpreted as [.] (see  v). ()*+,-i.fgj/0klmnopqrstuvwxyz{|}~1h23Pragma options. .Command-line options which should be updated. 456C      !"#$%&'()*+,-./0123456C    !"#$%&  ('/234-,+.10)*56K      !"#$%&'()*+,-i.fgj/0klmnopqrstuvwxyz{|}~1h23456ONone7Create a fresh name from a. 9Make a J from some kind of string. :The  sets the definition site of the name, not the use site. <=Ambiguous qualified names. Used for overloaded constructors. BInvariant: All the names in the list must have the same concrete,  unqualified name. ?(A module name is just a qualified name. The 6 instance for module names sets all individual ranges  to the given one. B)Something preceeded by a qualified name. FJQualified names are non-empty lists of names. Equality on qualified names D are just equality on the last name, i.e. the module part is just  for show. The 2 instance for qualified names sets all individual A ranges (including those of the module prefix) to the given one. JHA name is a unique identifier and a suggestion for a concrete name. The H concrete name contains the source location (if any) of the name. The 9 source location of the binding site is also recorded. PGA module is anonymous if the qualification path ends in an underscore. Q>Sets the ranges of the individual names in the module name to B match those of the corresponding concrete names. If the concrete E names are fewer than the number of module name name parts, then the " initial name parts get the range . C.D.E ` withRangesOf` [A, B] returns C.D.E but with ranges set  as follows:  C: .  D: the range of A.  E: the range of B. @Precondition: The number of module name name parts has to be at + least as large as the length of the list. RLike Q-, but uses the name parts (qualifier + name) 6 of the qualified name as the list of concrete names. ZJTurn a qualified name into a concrete name. This should only be used as a H fallback when looking up the right concrete name in the scope fails. \ Computes the TopLevelModuleName corresponding to the given E module name, which is assumed to represent a top-level module name. 3Precondition: The module name must be well-formed. `Is the name an operator? 9An abstract name is empty if its concrete name is empty. K789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef2789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef2JKLMNOFGHIBCDE?@A<=>PQRST9:;UVWXYZ[\]^_`abcde78f9789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefPNoneghijklmnghijklmnglkjihmn glkjihmnQNone|A misplaced end-comment -}. bopqrstuvwxyz{|}~aopqrstuvwxyz{|}~aozyxwvutsrqp{~}|o zyxwvutsrqp{~}|:TNone!Should comment tokens be output? !Should comment tokens be output? ,Manually lexing a block comment. Assumes an  open comment has been lexed. + In the end the comment is discarded and  is called to lex a real  token.  Lex a hole ( {! ... !}). Holes can be nested.  Returns v . KSkip a block of text enclosed by the given open and close strings. Assumes L the first open string has been consumed. Open-close pairs may be nested. UNone BLex a string literal. Assumes that a double quote has been lexed. HLex a character literal. Assumes that a single quote has been lexed. A L character literal is lexed in exactly the same way as a string literal. L Only before returning the token do we check that the lexed string is of O length 1. This is maybe not the most efficient way of doing things, but on L the other hand it will only be inefficient if there is a lexical error. Custom error function. EThe general function to lex a string or character literal token. The ( character argument is the delimiter (" for strings and ' for  characters). GThis is where the work happens. The string argument is an accumulating ) parameter for the string being lexed. EA string gap consists of whitespace (possibly including line breaks) I enclosed in backslashes. The gap is not part of the resulting string. Lex a single character. @Lex an escaped character. Assumes the backslash has been lexed. %Read a number in the specified base. Same as % but with an accumulating parameter. The escape codes.  VNone CThis is the initial state for parsing a literate file. Code blocks  should be enclosed in \ begin{code} \ end{code} pairs. DThis is the initial state for parsing a regular, non-literate file. 8The layout state. Entered when we see a layout keyword () and - exited either when seeing an open brace ( openBrace) or at the next token  (). Update: we don'!t use braces for layout anymore. The state inside a pragma. We enter this state from  when the token following a L layout keyword is to the left of (or at the same column as) the current  layout context. Example:   data Empty : Set where  foo : Empty -> Nat (Here the second line is not part of the where clause since it is has the  same indentation as the data- definition. What we have to do is insert an  empty layout block {} after the where!. The only thing that can happen  in this state is that % is executed, generating the closing 8 brace. The open brace is generated when entering by . <This state is entered at the beginning of each line. You can't lex J anything in this state, and to exit you have to check the layout rule.  Done with . IThis state can only be entered by the parser. In this state you can only  lex the keywords using, hiding, renaming and to. Moreover they are K only keywords in this particular state. The lexer will never enter this 7 state by itself, that has to be done in the parser. IReturn the next token. This is the function used by Happy in the parser.  lexer k =  >>= k&Do not use this function; it sets the Q to  . 4This is the main lexing function generated by Alex.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPSNone=True if the given state appears somewhere on the state stack 'True if we are at the end of the file. ITrue when the given character is the next character of the input string. Parse a literal. 7Parse an identifier. Identifiers can be qualified (see Name).  Example:  Foo.Bar.f Parse a { token. Parse a  token, triggers layout for . 9Exit the current state throwing away the current lexeme. 4Enter a new state throwing away the current lexeme. 5Exit the current state and perform the given action. /Enter a new state without consuming any input. )Executed for layout keywords. Enters the  ( state and performs the given action. Like (, but applies a function to the string. Parse a token from an  and the lexed string. )The most general way of parsing a token. -Scan the input to find the next token. Calls #. This is the main lexing function )where all the work happens. The function , Aused by the parser is the continuation version of this function. Q%Called at the end of a file. Returns p. R1Set the current input and lex a new token (calls ). SCUse the input string from the previous input (with the appropriate G number of characters dropped) instead of the fake input string that 8 was given to Alex (with unicode characters removed). T Alex 2 can'.t handle unicode characters. To solve this we 4 translate all Unicode (non-ASCII) identifiers to z, all Unicode  operator characters to +(, and all whitespace characters (except  for t and n) to ' '!. It is important that there aren't any  keywords containing z, + or  . 4Return a token without looking at the lexed string. 3Exit the current state without consuming any input U!Parse a possibly qualified name. QRVSTUssQRVSTURNone&This action is only executed from the  . state. It will exit this state, enter the  state, M and return a virtual close brace (closing the empty layout block started  by ). FStart a new layout context. This is one of two ways to get out of the   state (the other is  ). There are  two possibilities: G The current token is to the right of the current layout context (or we're  in a no layout context). J The current token is to the left of or in the same column as the current  context. JIn the first case everything is fine and we enter a new layout context at P the column of the current token. In the second case we have an empty layout  block so we enter the  state. In both F cases we return a virtual open brace without consuming any input. @Entering a new state when we know we want to generate a virtual {} may O seem a bit roundabout. The thing is that we can only generate one token at O a time, so the way to generate two tokens is to generate the first one and J then enter a state in which the only thing you can do is generate the  second one. /Executed for the first token in each line (see ). M Checks the position of the token relative to the current layout context.  If the token is   to the left : H Exit the current context and a return virtual close brace (stay in the   state).   same column :  Exit the ! state and return a virtual semi  colon.   to the right :  Exit the  state and continue lexing. If the current block doesn'%t use layout (i.e. it was started by  %) all positions are considered to be  to the right. $Executed upon lexing an open brace ('{'). Enters the V  context. $Executed upon lexing a close brace ('}'). Exits the current layout M context. This might look a bit funny--the lexer will happily use a close L brace to close a context open by a virtual brace. This is not a problem J since the parser will make sure the braces are appropriately matched. W3Compute the relative position of a location to the  current layout context. WWWNone  for root of split tree ISplit tree branching. A finite map from constructor names to splittrees G A list representation seems appropriate, since we are expecting not @ so many constructors per data type, and there is no need for  random access. Abstract case tree shape. A split is necessary. Arg. no to split at. Sub split trees. 8No more splits coming. We are at a single, all-variable  clause.  ,The number of variables bound in the clause  Convert a split tree into a  (for printing).      XYZ[\               XYZ[\XNonejThe  is not an application. >Modules: Top-level pragmas plus other top-level declarations. .Invariant: The string must be a valid Haskell  module name. %  M {{...}}&  tel. M args'@The representation type of a declaration. The comments indicate ? which type in the intended family the constructor targets. 5 notation declaration for a name 78The optional name is a name for the record constructor. 8&lone record signature in mutual block :$lone data signature in mutual block <Record field, can be hidden and/or irrelevant. =EAxioms and functions can be irrelevant. (Hiding should be NotHidden) >9A data constructor declaration is just a type signature. ?)Just type signatures or instance blocks. @Just type signatures. CThe "as" name. DThe range of the "as" keyword. Retained  for highlighting purposes. GRename from this name. H To this one. IThe range of the "to" keyword. Retained  for highlighting purposes. J3An imported name can be a module or a defined name QFThe things you are allowed to say when you shuffle names between name  spaces (i.e. in import,  namespace, or open declarations). V Only for open4. Exports the opened names from the current module. X Named where: module M where. Y Ordinary where. ZNo where clauses. ^,No right hand side because of absurd match. `8Processed (scope-checked) intermediate form of the core f ps of k.  Corresponds to n. brecord projection identifier cside patterns d main branch eside patterns g fh psk<Left hand sides can be written in infix style. For example:   n + suc m = suc (n + m)  (f " g) x = f (g x) AWe use fixity information to see which name is actually defined. l:new with-patterns, rewrite equations and with-expressions mHoriginal pattern, with-patterns, rewrite equations and with-expressions n f pso| p (many) p rewrite e (many) qwith e (many) rJA telescope is a sequence of typed bindings. Bound variables are in scope  in later types. s%Color a TypeBinding. Used by Pretty. v Let binding (let Ds) or  (open M args). wBinding (x1 ... xn : A). xA typed binding. |5for implicit function types the label matters and can't be alpha-renamed . (xs : e) or {xs : e} KA sequence of typed bindings with hiding information. Appears in dependent 3 function spaces, typed lambdas, and telescopes. . (xs : e) or {xs : e} . x or {x} or .x or .{x} or {.x} 1A lambda binding is either domain free or typed. :Concrete patterns. No literals in patterns at the moment. 0, 1, etc.  .ex@p unused  () _ (p){{p}} or  {{x = p}} {p} or {x = p} eg: p => p' for operator _=>_ p1..pn before parsing operators p p' or p {x = p'}  quotec or x DConcrete expressions. Should represent exactly what the user wrote. ex: a = b , used internally in the parser to print irrelevant things ex: unquote&, should be applied to a term of type Term  'tactic solve | subgoal1 | .. | subgoalNex:  quoteTerm, should be applied to a term ex: quote, should be applied to a name ex: quoteContext ctx in e ex: quoteGoal x in e "only used for printing telescopes ex: .p, only in patterns ex: x@p, only in patterns ex: () or {}, only in patterns ex: (e) ex:  let Ds in e ex: record e {x = a; y = b} ex: record {x = a; y = b} ex: Set0, Set1, .. ex: Prop ex: Set ex:  (xs:e) -> e or  {xs:e} -> e ex: e -> e or .e -> e (NYI: {e} -> e) ex: \- { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en } ex: \ () ex: \ x {y} -> e or \(x:A){y:B} -> e ex: {{e}} or {{x=e}} ex: {e} or {x=e} ex: e | e1 | .. | en ex: e + e ex: e e, e {e}, or  e {x = e} before parsing operators ex: _ or _A_5 ex: ? or  {! ... !} ex: 1 or "foo" ex: x Zan abstraction inside a special syntax declaration (see Issue 358 why we introduce this). Default is directive is private& (use everything, but do not export). $Computes the top-level module name. Precondition: The  has to be well-formed. &Get the leftmost symbol in a pattern. =Get all the identifiers in a pattern in left-to-right order.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$56 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ź~xuwvstyz{|}r'=<;:9876543210/.-,+*)($&%@?>QRSTUVNPOJLKMMEFGHIABCD!#"jikmlnopq`faghbcde_\^][WZYX 56X !#"$&%'=<;:9876543210/.-,+*)(>?@ABCDEFGHIJLKMMNPOQRSTUVWZYX[\^]_`faghbcdeijkmlnopqrstuwvxyz{|}~ "]^_`abcdefghijklmnopqrstuvwxyz{|}~YNone8  7ZNone?.A decoration of abstract syntax module names. The resolved module name. 'Explanation where this name came from. A decoration of O. The resolved qualified name. 7The kind (definition, constructor, record field etc.). 'Explanation where this name came from. Where does a name come from? 6This information is solely for reporting to the user,  see . "Imported by a module application. Imported from another module. Defined in this module. 8For the sake of parsing left-hand sides, we distinguish : constructor and record field names from defined names. A name that can only quoted. Name of a pattern synonym. Ordinary defined name. Record field name. Constructor name. .Type class for some dependent-types trickery. #Set of types consisting of exactly  and . /A GADT just for some dependent-types trickery. A  NameSpace= contains the mappings from concrete names that the user can N write to the abstract fully qualified names that the type checker wants to  read. 1Maps concrete names to a list of abstract names. ?Maps concrete module names to a list of abstract module names. Local variables. GThe complete information about the scope at a particular program point N includes the scope stack, the local variables, and the context precedence. KA scope is a named collection of names partitioned into public and private  names. Get a  from  .  Lens for .  inNameSpace9 selects either the name map or the module name map from  a 1. What is selected is determined by result type ( (using the dependent-type trickery). "A list containing all name kinds. The empty name space. :Map functions over the names and modules in a name space. Zip together two name spaces. 'Map monadic function over a namespace. The empty scope. The empty scope info. 5Map functions over the names and modules in a scope. Same as  3 but applies the same function to all name spaces. =Map monadic functions over the names and modules in a scope. Same as  6 but applies the same function to both the public and  private name spaces. FZip together two scopes. The resulting scope has the same name as the  first scope. Same as  6 but applies the same function to both the public and  private name spaces. DFilter a scope keeping only concrete names matching the predicates. N The first predicate is applied to the names and the second to the modules. Return all names in a scope. Returns the scope's non-private names. ">Merge two scopes. The result has the name of the first scope. #GMerge a non-empty list of scopes. The result has the name of the first  scope in the list. $JMove all names in a scope to the given name space (except never move from  Imported to Public). &Add names to a scope. 'Add a name to a scope. (Remove a name from a scope. )Add a module to a scope. * Apply an Q to a scope. +&Rename the abstract names in a scope. ,+Restrict the private name space of a scope -DRemove names that can only be used qualified (when opening a scope) ./Add an explanation to why things are in scope. /6Get the public parts of the public modules of a scope 1CCompute a flattened scope. Only include unqualified names or names - qualified by modules in the first argument. 2Look up a name in the scope 4IFind the shortest concrete name that maps (uniquely) to a given abstract  name. 6Takes the first component of  4. 8Takes the second component of  4. 9,Add first string only if list is non-empty. w                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9h                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9h                               ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9Q                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9[None :Constructor pattern info. <FDoes this pattern come form the eta-expansion of an implicit pattern. [EFor a general expression we can either remember just the source code < position or the entire concrete expression it came from. \9Even if we store the original expression we have to know ( whether to put parenthesis around it. bThe MetaId , not the . fSame as  mkDefInfo but where we can also give the  IsInstance gEmpty range for patterns. H : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g. : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g. ^ _ ` a b c d [ ] \ T U V W X Y Z R S K L M N O P Q e f G H I J C D E F A B > @ ? g : ; < =( : ; < = > @ ? A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ ] \ ^ _ ` a b c d e f g\None h/Types which Geniplate should not descend into. iA localised instance of . The generated  - functions neither descend into the types in   h+, nor into the types in the list argument. jA localised instance of . The generated  - functions neither descend into the types in   h+, nor into the types in the list argument.  h i j h i j i j h h i j]NoneW k+Check whether we are a projection pattern. o-Parameterised over the type of dot patterns. q3Generated at type checking for implicit arguments. v$Underscore pattern entered by user. w%Defined pattern: function definition f ps or destructor pattern d p ps. z.Convert a focused lhs to spine view and back. ~The lhs minus with*-patterns in projection-application view.  Parameterised over the type e of dot patterns.  Projection Record projection identifier. Indices of the projection.  Currently none [](, since we do not have indexed records.  Main branch. Further applied to patterns. 'The head applied to ordinary patterns. Head f. Applied to patterns ps. KThe lhs of a clause in focused (projection-application) view (outside-in). ) Projection patters are represented as  s. Range.  Copatterns. with patterns (after |). 0The lhs of a clause in spine view (inside-out). ( Projection patterns are contained in  spLhsPats,  represented as DefP d []. Range. "Name of function we are defining.  Function parameters (patterns). with patterns (after |). The F1s are the names of the generated with functions.  One for each  .  The RHS shouldn't be another RewriteRHS The F# is the name of the with function. We could throw away where- clauses at this point and translate them to  let. It''s not obvious how to remember that the let was really a  where7 clause though, so for the time being we keep it here. JA typed binding. Appears in dependent function spaces, typed lambdas, and J telescopes. I might be tempting to simplify this to only bind a single L name at a time. This would mean that we would have to typecheck the type  several times ( (x y : A) vs. (x : A)(y : A)).  In most cases this wouldn't really be a problem, but it's good 6 principle to not do extra work unless you have to. J(Andreas, 2013-12-10: The more serious problem would that the translation  from  (x y : ?) to (x : ?) (y : ?) duplicates the hole ?. As in telescope  (x y z : A) or type (x y z : A) -> B. (Typed bindings with hiding information. . (xs : e) or {xs : e} 1A lambda binding is either domain free or typed. . (xs:e) or {xs:e} or (let Ds) . x or {x} or .x or .{x} Only  s. Bindings that are valid in a let. -only for highlighting and abstractToConcrete 4LetApply mi newM (oldM args) renaming moduleRenaming. Irrefutable pattern binding. LetBind info rel name type defn  M {{...}}  tel. M args : applies M to args and abstracts tel. scope annotation Only for highlighting purposes The  ' gives the constructor type telescope, (x1 : A1)..(xn : An) -> Prop, + and the optional name is the constructor's name. lone record signature the  s are  + and binds the parameters of the datatype. lone data signature  ^ the  s are  + and binds the parameters of the datatype. sequence of function clauses (only retained for highlighting purposes *a bunch of mutually recursive definitions primitive function  record field ?type signature (can be irrelevant and colored, but not hidden) Is a type signature a  postulate or a function signature? <Not a function signature, i.e., a postulate (in user input)  or another (e.g. data/%record) type signature (internally). A function signature. Record field assignment f = e. +for printing DontCare from Syntax.Internal $The splicing construct: unquote ... Quote a term. Quote an identifier F. binds Name to current context in Expr binds Name to current type in Expr scope annotation record update record construction #only used when printing telescopes Set, Set1, Set2, ... independent function space with application >Meta variable for hidden argument (must be inferred locally). Meta variable for interaction.  The  is usually identical with the   b of  ^. 8 However, if you want to print an interaction meta as  just ? instead of ?n, you should set the   b to  while keeping the .  Literals  Constructors ?Constants (i.e. axioms, functions, projections, and datatypes) Bound variables AAdd applicative patterns (non-projection patterns) to the right. 6Add projection and applicative patterns to the right. %Used for checking pattern linearity. Used in AbstractToConcrete. List instance (for clauses). Clause instance. LHS instance. Are we in an abstract block? *In that case some definition is abstract. /Extracts all the names which are declared in a  . C This does not include open public or let expressions, but it does @ include local modules, where clauses and the names of extended  lambdas. %The name defined by the given axiom. 3Precondition: The declaration has to be a (scoped)  . k l m n o p q r s t u v w x y z { | } ~                 789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef k l m n o p q r s t u v w x y z { | } ~             ~  } z { | o y x w v u t s r q p n m k l           k k l m n o y x w v u t s r q p z { | } ~                              ^None BApply an expression rewriting to every subexpression, inside-out.  See _ .Gather applications to expose head and spine. FNote: everything is an application, possibly of itself to 0 arguments Gather top-level  u&atterns to expose underlying pattern. .Check whether we are dealing with a universe.  Remove top   wrappers. Remove   wrappers everywhere. *TODO: currently does not go into clauses. +TODO: currently does not go into patterns. )TODO: currently does not go into colors.                                             _None; LPick the better name suggestion, i.e., the one that is not just underscore. The ConPatternInfo+ states whether the constructor belongs to  a record type (Just) or data type (Nothing).  In the former case, the Bool! says whether the record pattern 8 orginates from the expansion of an implicit pattern.  The Type* is the type of the whole record pattern. ; The scope used for the type is given by any outer scope  plus the clause' s telescope ( 0). !4Patterns are variables, constructors, or wildcards.  QName is used in ConP rather than Name since ; a constructor might come from a particular namespace. ; This also meshes well with the fact that values (i.e. - the arguments we are matching with) use QName. "2Projection copattern. Can only appear by itself. $The Pattern,s do not contain any projection copatterns. &The  PatVarName is a name suggestion. 'Pattern variables. *for absurd clauses. -:A clause is a list of patterns and the clause body should Bind. BThe telescope contains the types of the pattern variables and the B permutation is how to get from the order the variables occur in B the patterns to the order they occur in the telescope. The body @ binds the variables in the order they appear in the patterns.  6clauseTel ~ permute clausePerm (patternVars clausPats)9Terms in dot patterns are valid in the clause telescope. CFor the purpose of the permutation and the body dot patterns count # as variables. TODO: Change this! 0$The types of the pattern variables. 4The type of the rhs under  clauseTel.  Used, e.g., by  TermCheck.  Can be , if we encountered an irrelevant projection  pattern on the lhs. 55Something where a meta variable may block reduction. 85A meta variable identifier is just a natural number. <Introduced by  instantiate , removed by reduce. C(A level is a maximum expression of 0..n  @ expressions 7 each of which is a number or an atom plus a number. ?The empty maximum is the canonical representation for level 0. ESorts. F/if the free variable occurs in the second sort 3 the whole thing should reduce to Inf, otherwise  it's the normal Lub KISequence of types. An argument of the first type is bound in later types  and so on. L S is never  T. O(Types are terms with a sort annotation. SBinder.   S/: The bound variable might appear in the body.   T; is pseudo-binder, it does not introduce a fresh variable,  similar to the const of Haskell. U+The body has (at least) one free variable.  Danger:  W doesn't shift variables properly X Names in binders and arguments. [6Eliminations, subsuming applications and projections. \name of a record projection ^ Raw values. Def3 is used for both defined and undefined constants. ; Assume there is a type declaration and a definition for 8 every constant, even if the definition is an empty  list of clauses. _Explicit sharing `3Irrelevant stuff in relevant position, but created 5 in an irrelevant context. Basically, an internal $ version of the irrelevance axiom .irrAx : .A -> A. d*dependent or non-dependent function space e c vs ff es, possibly a delta/ iota-redex h?Only used by unquote --> reify. Should never appear elsewhere. i,Terms are beta normal. Relevance is ignored jx es neutral o9Store the names of the record fields in the constructor. ? This allows reduction of projection redexes outside of TCM. 6 For instance, during substitution and application. qThe name of the constructor. rThe name of the record fields. % Empty list for data constructors.   w is not needed here since it & is stored in the constructor args. tType of argument lists. 2Extract pattern variables in left-to-right order.  A  %+ is also treated as variable (see docu for  -). 2Does the pattern perform a match that could fail? 6Absurd lambdas are internally represented as identity  with variable name (). Introduce sharing. 1Typically m would be TCM and f would be Blocked. An unapplied variable. Add  ` is it is not already a DontCare. A dummy type.  Top sort (Setomega). Get the next higher sort. Removing a topmost  ` constructor. Doesn't do any reduction. GSuggest a name for the first argument of a function of the given type. ?Convert top-level postfix projections into prefix projections. #A view distinguishing the neutrals Var, Def, and MetaV which  can be projected. Drop  ] constructor. (Unsafe!) Drop  ] constructor. (Safe) Drop  ] constructors. (Safe) Split at first non- ] Discard Proj f entries.  Discards Proj f entries.     ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y$eliminations ordered left-to-right. Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF GHIJKLMNO<=>?@A789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef     ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  y x w v u t s o p q r k l m n ^ j i h g f e d c b a ` _ [ ] \ Z Y X z { | } S U T V W V W O P Q R N K M L J ~  E I H G F C D @ B A ; ? > = < 8 9 : 5 7 6 - . / 0 1 2 3 4 ) , + * ( ' ! & % $ # "         ! & % $ # " ' ( ) , + * - . / 0 1 2 3 4 5 7 6 8 9 : ; ? > = < @ B A C D E I H G F J K M L N O P Q R S U T V W V W X Y Z [ ] \ ^ j i h g f e d c b a ` _ k l m n o p q r s t u v w x y z { | } ~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF GHIJKLMNO`None  Ignore free variables in sorts. 6Where should we skip sorts in free variable analysis? Skip unconditionally.  Skip when annotation to a type.  Do not skip. IThe distinction between rigid and strongly rigid occurrences comes from: L Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP 2009 paper) JThe main idea is that x = t(x) is unsolvable if x occurs strongly rigidly O in t. It might have a solution if the occurrence is not strongly rigid, e.g. x = f -> suc (f (x ( y -> k))) has x = f -> suc (f (suc k)) #Jason C. Reed, PhD thesis, page 106 EFree variables of a term, (disjointly) partitioned into strongly and L and weakly rigid variables, flexible variables and irrelevant variables. (variables at top and under constructors 6ord. rigid variables, e.g., in arguments of variables wvariables occuring in arguments of metas. These are potentially free, depending how the meta variable is instantiated. .variables in irrelevant arguments and under a DontCare , i.e., in irrelevant positions  variables in uments  allVars fv includes irrelevant variables. "All but the irrelevant variables. PHMark variables as flexible. Useful when traversing arguments of metas. QVMark rigid variables as non-strongly. Useful when traversion arguments of variables. R'Mark all free variables as irrelevant. S?Mark all free variables as unused, except for irrelevant vars. TPointwise union. U delete x fv deletes variable x from variable set fv. VsubtractFV n fv* subtracts $n$ from each free variable in fv. W$A single (strongly) rigid variable. Doesn'<t go inside solved metas, but collects the variables from a  metavariable application X ts as  flexibleVars. 8Is the variable bound by the abstraction actually used? < PQRSTXYUVW Z[\]^_`abcdefghi" " *      PQRSTXYUVW Z[\]^_`abcdefghiaNone =Filter a list using a list of Bools specifying what to keep.  j      jbNone ASmart constructor for let expressions to avoid unneceessary lets 'Some things are pointless to make lazy MIf casing on the same expression in a sub-expression, we know what branch to  pick ?Smart constructor for applications to avoid empty applications  Substitution !(Get the free variables in an expression /                         Substitute this ... with this ...  in this.  !/                           !4                              !                              !cNone "Case tree with bodies. # Absurd case. $ Done xs b stands for the body b where the xs contains hiding H and name suggestions for the free variables. This is needed to build E lambdas on the right hand side for partial applications which can  still reduce. % Case n bs stands for a match on the n -th argument  (counting from zero) with bs as the case branches.  If the n+-th argument is a projection, we have only  (.  with arity 0. &Branches in a case tree. (mMap from constructor (or projection) names to their arity and the case subtree. (Projections have arity 0.) )"Map from literal to case subtree. *((Possibly additional) catch-all clause.  " # $ % & ' ( ) * + , - . / 0 1 2 3 4klmnopq " # $ % & ' ( ) * + , - . / 0 1 2 3 4 / + , - . & ' ( ) * " % $ # 0 1 2 3 4 " % $ # & ' ( ) * + , - . / 0 1 2 3 4klmnopqdNone 6 The type in   serves the same role as in  $. )TODO: If a hole is plugged this type may ! have to be updated in some way. 8A OneholePattern is a linear pattern context P such that for  any non-projection pattern p , inserting p into the single hole P[p], * yields again a non-projection pattern. :,Arity of a function, computed from clauses. <HTranslate the clause patterns to terms with free variables bound by the  clause telescope. &Precondition: no projection patterns. =6Translate the clause patterns to an elimination spine 6 with free variables bound by the clause telescope. @ allHoles ps# returns for each pattern variable x in ps a  context P such P[x] is one of the patterns of ps.  The Ps0 are returned in the left-to-right order of the  pattern variables in ps. r!Get the number of common initial  ] patterns in a list of clauses. sGet the number of initial  ] patterns in a clause. tGet the number of initial  ] patterns.  5 6 7 8 9 : ; < = > ? @ Aurst 5 6 7 8 9 : ; < = > ? @ A < = : ; > 8 9 5 7 6 ? @ A 5 7 6 8 9 : ; < = > ? @ AursteNone BGetting the used definitions. D+What it takes to get the used definitions. KInputs to and outputs of getDefs' are organized as a monad. LgetDefs' lookup emb a extracts all used definitions  (functions, data/record types) from a, embedded into a monoid via emb. 5 Instantiations of meta variables are obtained via lookup. "Typical monoid instances would be [QName] or  Set QName.  Note that emb. can also choose to discard a used definition ) by mapping to the unit of the monoid.  B C D E F G H I J K Lvwxyz{|}~ B C D E F G H I J K L L K G H I J D E F B C B C D E F G H I J K Lvwxyz{|}~fNone Q6Put it in a monad to make it possible to do strictly.  M N O P Q M N O P Q M N O P Q M N O P QgNone TVariable blocking a match. V0De Bruijn index of variable blocking the match. WNothing8 means there is an overlapping match for this variable. J This happens if one clause has a constructor pattern at this position, 0 and another a variable. It is also used for  just variable.  Just cons/ means that it is an non-overlapping match and  cons# are the encountered constructors. XIf matching is inconclusive (Block) we want to know which % variables are blocking the match. Y;Could match if split on possible projections is performed. Z4Could match if non-empty list of blocking variables  is instantiated properly. [Definitely does not match. \Matches unconditionally. ]2We use a special representation of the patterns we're trying to match L against a clause. In particular we want to keep track of which variables  are blocking a match. ^Projection copattern. _6For dot patterns that cannot be turned into patterns. b@De Bruijn index (usually, rightmost variable in patterns is 0). cGiven   the function clauses cs  2. the patterns ps and permutation perm of a split clause Jwe want to compute a variable index of the split clause to split on next. First, we find the set cs' of all the clauses that are instances (via substitutions rhos) of the split clause. QIn these substitutions, we look for a column that has only constructor patterns. &We try to split on this column first. 3Match the given patterns against a list of clauses h&Left dominant merge of blocking vars. i choice m m' combines the match results m of a function clause / with the (already combined) match results $m'$ of the later clauses. < It is for skipping clauses that definitely do not match ( [). & It is left-strict, to be used with foldr. * If one clause unconditionally matches ( \) we do not look further. l?Check if a clause could match given generously chosen literals mmatchClause mlit qs i c checks whether clause c number i ' covers a split clause with patterns qs. nmatchPats mlit ps qs0 checks whether a function clause with patterns  ps% covers a split clause with patterns qs. 7Issue 842: if in case of functions with varying arity, B the split clause has proper patterns left, we refuse to match, F because it would be troublesome to construct the split tree later. ; We would have to move bindings from the rhs to the lhs. " For example, this is rejected:    F : Bool -> Set1  F true = Set  F =   x -> Set   omatchPat mlit p q* checks whether a function clause pattern p ! covers a split clause pattern q. There are three results:  Yes () means it covers, because p is a variable  pattern or q is a wildcard.  No means it does not cover.  Block [x] means p is a proper instance of q and could become  a cover if q was split on variable x. =Combine results of checking whether function clause patterns ! covers split clause patterns.  [< is dominant: if one function clause pattern is disjoint to 0 the corresponding split clause pattern, then # the whole clauses are disjoint.  \6 is neutral: for a match, all patterns have to match.  Z+ accumulates variables of the split clause  that have to be instantiated @ to make the split clause an instance of the function clause.  Y yields to  Z, since blocking vars can also  block the result type.  R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o c ] b a ` _ ^ d X \ [ Z Y T U V W S e f g h i R j k l m n o R S T U V W X \ [ Z Y ] b a ` _ ^ c d e f g h i j k l m n ohNone p-Generic traversals for concrete expressions. !Note: does not go into patterns! qThis corresponds to . rThis corresponds to . sThis is a reduce.  p q r s p q r s p q r s p q r siNone% t A compressed  x/, in which consecutive positions with the same   y are stored together. w!Syntax highlighting information. xA  x7 is a mapping from file positions to meta information. -The first position in the file has number 1. y0Meta information which can be associated with a  character/character range. }9This note, if present, can be displayed as a tool-tip or A something like that. It should contain useful information about @ the range (like the module containing a certain identifier, or  the fixity of an operator). ~>The definition site of the annotated thing, if applicable and - known. File positions are counted from 1. ;Other aspects. (These can overlap with each other and with   s.) "Code which is being type-checked. <When this constructor is used it is probably a good idea to  include a  }+ explaining why the pattern is incomplete. 9Unsolved constraint not connected to meta-variable. This 0 could for instance be an emptyness constraint. "Named argument, like x in {x = v}  Record type.  Primitive.  Module name. Record field. &Inductive or coinductive constructor. Bound variable. BVarious more or less syntactic aspects of the code. (These cannot  overlap.) Is the name an operator part? Things like Set and Prop. !Symbols like forall, =, ->, etc.   rs m( is a file whose positions are those in rs, 0 and in which every position is associated with m. Like  , but with several  instead of only one. Merges meta information. Merges files. .Returns the smallest position, if any, in the  x.  Convert the  x0 to a map from file positions (counting from 1)  to meta information.  Invariant for compressed files. -Note that these files are not required to be  maximally = compressed, because ranges are allowed to be empty, and the   y.s in adjacent ranges are allowed to be equal. >Compresses a file by merging consecutive positions with equal & meta information into longer ranges.  Decompresses a compressed file. DClear any highlighting info for the given ranges. Used to make sure < unsolved meta highlighting overrides error highlighting.   rs m( is a file whose positions are those in rs, 0 and in which every position is associated with m. Like  singletonR, but with a list of  instead of a  single one. Merges compressed files.  splitAtC p f splits the compressed file f into (f1, f2),  where all the positions in f1 are < p, and all the positions  in f2 are >= p. .Returns the smallest position, if any, in the  t. All the properties. L t u v w x y z { | } ~        3 t u v w x y z { | } ~  3  y z { | } ~ x w t u v + t u v w x y z { | } ~         jNone4lone type signatures that wait for their definition AThe kind of the forward declaration, remembering the parameters. name of a function !name of a record with parameters name of a data with parameters -we are nicifying decls not in a mutual block  we are nicifying a mutual block The exception type. 6In a mutual block, all or none need a MEASURE pragma.  Range is of mutual block. 7in a mutual block, a clause could belong to any of the [Name] type signatures DOne clause in a function definition. There is no guarantee that the k  actually declares the $. We will have to check that later. Only  s. Only  s. 2Termination measure is, for now, a variable name. KThe nice declarations. No fixity declarations and function definitions are I contained in a single constructor instead of spread out between type  signatures and clauses. The private,  postulate, abstract and instance D modifiers have been distributed to the individual declarations. Cblock of function clauses (we have seen the type signature before) <a uncategorized function clause, could be a function clause G without type signature or a pattern lhs (e.g. for irrefutable let)x NAxioms and functions can be declared irrelevant. (Hiding should be NotHidden) ;Check that declarations in a mutual block are consistently 8 equipped with MEASURE pragmas, or whether there is a  NO_TERMINATION_CHECK pragma. 'Search for forward type signature that CEnsure that all forward declarations have been given a definition. HCompute visible parameters of a data or record signature or definition. HAdd more fixities. Throw an exception for multiple fixity declarations. .Get the fixities from the current block. Doesn' t go inside any blocks. N The reason for this is that fixity declarations have to appear at the same I level (or possibly outside an abstract or mutual block) as its target  declaration. U      / / %         kNone 2Parse the token stream. Used by the TeX compiler. 4Parse an expression. Could be used in interactions. Parse a module. Required by Happy. Grab leading OPTIONS pragmas. ,Insert a top-level module if there is none. Create a name from a string. /Create a qualified name from a list of strings Match a particular name. (Build a forall pi (forall x y z -> ...) !Build a telescoping let (let Ds) ,Converts lambda bindings to typed bindings. $Check that an import directive doesn't contain repeated names :Breaks up a string into substrings. Returns every maximal 6 subsequence of zero or more characters distinct from .  splitOnDots "" == [""] * splitOnDots "foo.bar" == ["foo", "bar"] . splitOnDots ".foo.bar" == ["", "foo", "bar"] . splitOnDots "foo.bar." == ["foo", "bar", ""] . splitOnDots "foo..bar" == ["foo", "", "bar"] Returns !0 iff the name is a valid Haskell (hierarchical)  module name. *Turn an expression into a left hand side. DTurn an expression into a pattern. Fails if the expression is not a  valid pattern. ATurn an expression into a name. Fails if the expression is not a  valid identifier.  Test suite.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  !!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""########## # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i #j#k#l#m#n#o#p#q#r#s#t#u #v#w#x#y#z#{#|#}#~###########        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  !!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""########## # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i #j#k#l#m#n#o#p#q#r#s#t#u #v#w#x#y#z#{#|#}#~###########lNone Wrapped Parser type. Parses a module. Parses an expression. 4Gives the parsed token stream (including comments). #:Keep comments in the token stream generated by the lexer. #ADo not keep comments in the token stream generated by the lexer.  ##### # # ##KLMNOP  KLMNOP ##### # # ##mNone  Note that   only catches Ks.     None !Environment of the reduce monad. !Read only access to environment. 1Read only access to state (signature, metas...). Type-checking errors. for pattern violations EDistinguish error message when parsing lhs or pattern synonym, resp. ?The expr was used in the right hand side of an implicit module  definition, but it wasn't of the form m Delta. 7Module name, file from which it was loaded, file which , the include path says contains the module.  Scope errors >;The arguments are the meta variable, the parameters it can < depend on and the paratemeter that it wants to depend on. @8We ended up with an equality constraint where the terms 1 have different types. This is not supported. C-The two function types have different color. D.The two function types have different hiding. E1The two function types have different relevance. K$This term is not a type expression. Q&The given type should have been a pi. R(The given type should have been a sort. Z8The term does not correspond to an inductive data type. [;The given color does not correspond to the expected color. \BThe given relevance does not correspond to the expected relevane. ]=The given hiding does not correspond to the expected hiding. ^=Expected a relevant function and found an irrelevant lambda. _CA function is applied to a hidden named argument it does not have. `LA function is applied to a hidden argument where a non-hidden was expected. a:Expected a non-hidden function and found a hidden lambda. bBThe left hand side of a function definition has a hidden argument # where a non-hidden was expected. c,Varying number of arguments for a function. dconstructor, type eDatatype, constructors. f-Indices (variables), index expressions (with 4 constructors applied to reconstructed parameters),  parameters. gVariables, indices. h Indices. iconstructor, datatype j?Expected a type to be an application of a particular datatype. kThe target of a constructor isn't its datatype applied to  something that isn',t the parameters. First term is the correct 3 target and the second term is the actual target. lThe target of a constructor isn't an application of its  datatype. The  N records what it does target. wcoinductive data type x&data type, but in irrelevant position yneither data type nor record z8Information about a mutual block which did not pass the  termination checker. |6The functions which failed to check. (May not include % automatically generated functions.) }The problematic call sites. ~Information about a call. %Target function name pretty-printed. Range of the target function. ,To be formatted representation of the call. "Do not append implicit arguments. AAdd implicit arguments in the end until type is no longer hidden  d. %All abstract things can be accessed. $No abstract things can be accessed. 7Abstract things in the current module can be accessed. The Context is a stack of  s. -The path to the file that is currently being  type-checked. 5anonymous modules and their number of free variables to detect import cycles "the current (if any) mutual block ?Are we currently in the process of solving active constraints?  Are we allowed to assign metas? 7When checking the typesignature of a public definition : or the body of a non-abstract definition this is true. 8 To prevent information about abstract things leaking  outside the module. *Are we checking an irrelevant argument? (= Irrelevant) 5 Then top-level irrelevant declarations are enabled.  Other value: Relevant', then only relevant decls. are avail. ,Sometimes we want to disable display forms. ;should we try to recover interaction points when reifying? 5 disabled when generating types for with functions it'5s safe to eta contract implicit lambdas as long as we're < not going to reify and retypecheck (like when doing with  abstraction) 0Interactive highlighting uses this range rather  than  . what we're doing at the moment Set to   when imported modules are  type-checked. ,This number indicates how far away from the / top-level module Agda has come when chasing / modules. The level of a given module is not 5 necessarily the same as the length, in the module 3 dependency graph, of the shortest path from the 2 top-level module; it depends on in which order ' Agda chooses to chase dependencies. 6When True, allows destructively shared updating terms ; during evaluation or unification. This is disabled when = doing speculative checking, like solve instance metas, or > when updating might break abstraction, as is the case when " checking abstract definitions. 0When type-checking an alias f=e, we do not want 0 to insert hidden arguments in the end, because # these will become unsolved metas. 1We are reducing an application of this function. - (For debugging of incomplete matches only.) 1Did we encounter a simplification (proper match) ) during the current reduction process? 1Can we compare blocked things during conversion?  No by default.  Yes for rewriting feature. >When True types will be omitted from printed pi types if they  can be inferred :Used by the scope checker to make sure that certain forms = of expressions are not used inside dot patterns: extended  lambdas and let-expressions. :The rules for translating internal to abstract syntax are ; slightly different when the internal term comes from an  unquote. 7How should highlighting be sent to the user interface? Both via files and via stdout.  Via stdout. <How much highlighting should be sent to the user interface? 4This includes both non-interactive highlighting and > interactive highlighting of the expression that is currently  being type-checked. Builtin of any kind.  Type can be checked (Just t) or inferred (Nothing). B The second argument is the hook for the verification function. 3When typechecking something of the following form:  instance  x : _  x = y it's not yet known where to add x, so we add it to a list of  unresolved instances and we'll deal with it later. The instance table is a Map associating to every name of  record data type postulate its list of instances used by setCurrentRange  Controlling reduce. 5Functions that have not passed termination checking. Reduce  C terms. 4Functions which are not projections may be reduced. ;(Projection and) projection-like functions may be reduced. OThree cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked. *Did we encounter a simplifying reduction? 4 In terms of CIC, that would be a iota-reduction. 6 In terms of Agda, this is a constructor or literal  pattern that matched. 9 Just beta-reduction (substitution) or delta-reduction = (unfolding of definitions) does not count as simplifying?  Primitive or builtin functions. # for primitive functions, not null for builtin functions.  for primitive functions,    something for builtin functions. Number of parameters. !QName of (original) constructor and fields. (This might be in a module instance.) "!Name of datatype or record type. $Inductive or coinductive? &Number of parameters. (Constructor name and fields. *The record constructor'&s type. (Includes record parameters.) ,:The record field telescope. (Includes record parameters.)  Note: TelV recTel _ == telView' recConType.  Thus, recTel is redundant. -Mutually recursive functions, datas and record"s. Does not include this record. .!Eta-expand at this record type. False: for unguarded recursive records and coinductive records. / or '? Matters only for recursive records.  ; means that the user did not specify it, which is an error  for recursive records. 0Recursive record. Implies recEtaEquality = False(. Projections are not size-preserving. 3Number of parameters. 4!Parameters that are maybe small. 5#Parameters that appear in indices. 6Number of indices. 7data or codata (legacy). 8)This might be in an instantiated module. 9Constructor names. ;Mutually recursive functions, datas and record%s. Does not include this data type. ?' while function is still type-checked.  Just cc& after type and coverage checking and  translation to case trees. AMutually recursive functions, datas and records. # Does not include this function. C,Are the clauses of this definition delayed? DIs it a record projection? @ If yes, then return the name of the record type and index of E the record argument. Start counting with 1, because 0 means that > it is already applied to the record. (Can happen in module ? instantiation.) This information is used in the termination  checker. E=Should calls to this function be normalised at compile-time? F+Has this function been created by a module  instantiation? G:Has this function been termination checked? Did it pass? H4Is this function generated from an extended lambda? S If yes, then return the number of hidden and non-hidden lambda-lifted arguments I4Is this a generated with-function? If yes, then what's the  name of the parent function. J Postulate. K&Additional information for projection  =s. MNothing if only projection-like, Just q if record projection,  where q! is the original projection name , (current name could be from module app). N%Type projected from. Record type if projProper = Just{}. OIndex of the record argument. / Start counting with 1, because 0 means that ( it is already applied to the record. ) (Can happen in module instantiation.) PTerm t9 to be be applied to record parameters and record value. # The parameters will be dropped. D In case of a proper projection, a postfix projection application  will be created: t =  pars r -> r .p C In case of a projection-like function, just the function symbol  is returned as  f: t =   pars -> f. Q-The info of the principal (record) argument. R-Subterm occurrences for positivity checking. G The constructors are listed in increasing information they provide:  Mixed < = JustPos < = StrictPos < = GuardPos <= Unused  Mixed < = JustNeg <= Unused. TWGuarded strictly positive occurrence (i.e., under "). For checking recursive records. UStrictly positive occurrence. V0Positive occurrence, but not strictly positive. WNegative occurrence. X.Arbitrary occurrence (positive and negative). _,Polarity for equality and subtype checking. ` constant a no information (mixed variance) b antitone c monotone oHiding should not be used. qType of the lifted definition. wARewrite rules for this symbol, (additional to function clauses). xJust q0 when this definition is an instance of class q z@Rewrite rules can be added independently from function clauses. A structured presentation of a  ^ for reification into   . v. .v. d vs. c vs. (f vs | ws) us.  The first   is the parent function f with its args vs.  The list of  s are the with expressions ws.  The  t are additional arguments us @ (possible in case the with-application is of function type). A  DisplayForm is in essence a rewrite rule    q ts --> dt   9 for a defined symbol (could be a constructor as well) q.  The right hand side is a   which is used to  reify to a more readable  .  The patterns ts are just terms, but var 0 is interpreted " as a hole. Each occurrence of var 0 is a new hole (pattern var).  For each *occurrence* of var0 the rhs dt has a free variable. A These are instantiated when matching a display form against a  term q vs succeeds. Number n of free variables in  . Left hand side patterns, where var 0 stands for a pattern  variable. There should be n occurrences of var0 in   . Right hand side, with n free variables. &This is the number of parameters when  we're inside the section and 0  outside. It's used to know how much of ) the context to apply function from the # section to when translating from  abstract to internal syntax. 0Data structure managing the interaction points. HInteraction points are created by the scope checker who sets the range. N The meta variable is created by the type checker and then hooked up to the  interaction point. 'The position of the interaction point. 1The meta variable, if any, holding the type etc. 9For printing, we couple a meta with its name suggestion. FName suggestion for meta variable. Empty string means no suggestion. MetaInfo5 is cloned from one meta to the next during pruning. 8Run the extended occurs check that goes in definitions? Used for printing.  Just x8 if meta-variable comes from omitted argument with name x. Meta variable priority: > When we have an equation between meta-variables, which one  should be instantiated? 7Higher value means higher priority to be instantiated. )solution blocked by unsolved constraints open, to be instantiated as implicit from scope  unsolved  solved by  Lam .. Sort s solved by term <Frozen meta variable cannot be instantiated by unification. D This serves to prevent the completion of a definition by its use ! outside of the current block.  (See issues 118, 288, 399). Do not instantiate. 5some metavariables are more eager to be instantiated a metavariable doesn'"t have to depend on all variables  in the context, this  permutation will throw away the  ones it does not depend on Cmeta variables scheduled for eta-expansion but blocked by this one Care we past the point where we can instantiate this meta variable? .A thing tagged with the context it came from. An extension of   to >=. +the range is the one of the absurd pattern -the two types are for the error message only Hash of the source code. #Imported modules and their hashes. Module name of this interface. &Scope after we loaded this interface.  Used in    and  . Haskell imports listed in % (transitively) imported modules are  not included here.  Pragma options set in the file. !7 if warnings were encountered when the module was type  checked. =Maps source file names to the corresponding top-level module  names. =Maps top-level module names to the corresponding source file  names.   Can be used for various things.  BA part of the state which is not reverted when an error is thrown  or the state is reset. 3Callback function to call when there is a response ( to give to the interactive frontend.  See the documentation of 8. DStructure to track how much CPU time was spent on which Agda phase. 4 Needs to be a strict field to avoid space leaks! Highlighting info. 7Highlighting info for tokens (but not those tokens for  which highlighting exists in ). 2Definitions to be considered during occurs check. = Initialized to the current mutual block before the check. < During occurs check, we remove definitions from this set ! as soon we have checked them. *Declared identifiers of the current file. < These will be serialized after successful type checking. Imported declared identifiers. ! Those most not be serialized! !7The current module is available after it has been type  checked. #3Pattern synonyms of the current file. Serialized. $4Imported pattern synonyms. Must not be serialized! &&Options applying to the current file. OPTIONS ! pragmas only affect this field. 'ACounters to collect various statistics about meta variables etc. +7Imports that should be generated by the compiler (this * includes imports from imported modules). ,5Options which apply to all files, unless overridden. -Empty persistent state. .Empty state of type checker. 0 Creates a   map based on . 1HCombines the source hash and the (full) hashes of the imported modules. 3Embed   into  . 4"Flip the direction of comparison. 5Turn a   function into a   function.  Property:  dirToCmp f (fromCmp cmp) = f cmp @%By default, we have no display form. C,Create a definition with sensible defaults. EA template for creating  =& definitions, with sensible defaults. K;Not quite all reductions (skip non-terminating reductions) P,Are the clauses of this definition delayed? Q3Has the definition failed the termination checker? RAIs the definition just a copy created by a module instantiation? T$ifTopLevelAndHighlightingLevelIs l m runs m when we're B type-checking the top-level module and the highlighting level is  at least l. [/Preserve the state of the failing computation. g5Running the type checking monad (most general form). hBRunning the type checking monad on toplevel (with initial state). jj runs a safe / action (a / action which cannot fail)  in the initial environment. k6Runs the given computation in a separate thread, with a copy of $ the current state and environment. <Note that Agda sometimes uses actual, mutable state. If the  computation given to forkTCM tries to modify this state, then E bad things can happen, because accesses are not mutually exclusive.  The forkTCM7 function has been added mainly to allow the thread to  read8 (a snapshot of) the current state in a convenient way. ANote also that exceptions which are raised in the thread are not @ propagated to the parent, so the thread should not do anything  important. l'Base name for extended lambda patterns m"Name of absurdLambda definitions. n;Check whether we have an definition from an absurd lambda. #We only  the name of the callee. /01234                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn##################################################/01234                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn3 !"#$%&'()*+,   -  ./ 0 1 2 345 6789:;<=> ? @AB z { | } ~  m n o p q r s t u v w x yC l k j i f h g d e _ c b a ` Y Z [ \ ] ^D R X W V U T S K L M N O P Q  J = 2 %   > ? @ A B C D E F G H I 3 4 5 6 7 8 9 : ; < & ' ( ) * + , - . / 0 1 ! " # $    EFGH            IJ      K LMNOPQRS T4 U ~  z { | } t y x w v u s r q p o n m l k j i h g f e d c b a ` _ ^ ] \ [ Z Y X W V U T S R Q P O N M L K J I H G F E D C B A @ ? > = < ; : 9 8 7 6 5 4 3 2 1 0 / . - , + * ) ( ' & % $ # " !                           VWX YZ012/ [\]^_`abcdefghijklmn/0123 !"#$%&'()*+,4      ~ s r q p o n m l k j i h g f e d c b a ` _ ^ ] \ [ Z Y X W V U T S R Q P O N M L K J I H G F E D C B A @ ? > = < ; : 9 8 7 6 5 4 3 2 1 0 / . - , + * ) ( ' & % $ # " !                           t y x w v u z { | } ~                                       1 J = 2 %   > ? @ A B C D E F G H I 3 4 5 6 7 8 9 : ; < & ' ( ) * + , - . / 0 1 ! " # $     K L M N O P Q R X W V U T S Y Z [ \ ] ^ _ c b a ` d e f h g i j k l m n o p q r s t u v w x y z { | } ~                            -./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn##################################################qNone}Methods to retrieve the  3. ~#Returns the properly raised clause  ,,  and  if  *. <Just grabs the body, without raising the de Bruijn indices. > This is useful if you want to consider the body in context  0. Performs void (noAbs) abstraction over telescope. Apply a substitution. Substitutions. (abstract args v)  args --> v[args]. )Apply something to a bunch of arguments. E Preserves blocking tags (application can never resolve blocking). If $v$ is a record value, canProject f v  returns its field f. Eliminate a constructed term. defApp f us vs applies Def f us to further arguments vs, ' eliminating top projection redexes.  If us8 is not empty, we cannot have a projection redex, since ) the record argument is the first one. JThe type must contain the right number of pis without have to perform any  reduction. Turn a typed binding (x1 .. xn : A) into a telescope.  %mkPi dom t = telePi (telFromList [dom]) t)Uses free variable analysis to introduce noAbs bindings. Everything will be a  S. >Dependent least upper bound, to assign a level to expressions  like forall i -> Set i. dLub s1 i.s2 = omega if i# appears in the rigid variables of s2. Instantiate an abstraction underAbs k a b applies k to a and the content of  abstraction b and puts the abstraction back.  a/ is raised if abstraction was proper such that  at point of application of k and the content of b  are at the same context.  Precondition: a and b' are at the same context at call time. underLambdas n k a b drops n initial  is from b,  performs operation k on a and the body of b,  and puts the  i s back. a is raised correctly , according to the number of abstractions. #(Syntactic equality, ignores stuff below DontCare. }~##########################################################$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$I}~I}~}~##########################################################$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$rNone subst u . abstractTerm u == idisPrefixOf u v = Just es if v == u  es. $ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0sNone,Maximum size of the generated element. When Nothing this value  is initialized from the    parameter. <When this is true no lambdas, literals, or constructors are  generated "HOnly generates default configurations. Names and free variables varies. %"Check that the generated terms don'#t have any out of scope variables.       !"#$%$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a[      !"#$%[      !"#$%U       !"#$%$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$aNone 82Callback fuction to call when there is a response ( to give to the interactive frontend. =Note that the response is given in pieces and incrementally, G so the user can have timely response even during long computations. Typical 8 functions:  Convert the response into a $b representation and " print it on standard output 2 (suitable for inter-process communication). 8 Put the response into a mutable variable stored in the  closure of the 8 function. 2 (suitable for intra-process communication). 9(Responses for any interactive interface =Note that the response is given in pieces and incrementally, G so the user can have timely response even during long computations. : The default 8 function prints certain ; things to stdout (other things generate internal errors). &Give action result #Comment derived from agda2-mode.el If & is ' Give_String s', then the goal is replaced by s, E and otherwise the text inside the goal is retained (parenthesised  if & is (). *Status information. ,"Are implicit arguments displayed? -/Has the module been successfully type checked? .5Info to display at the end of an interactive command 88, denotes either an error or a success (when G is present) 0 TODO: split these into separate constructors 99' denotes two different types of errors 0 TODO: split these into separate constructors :>When an error message is displayed this constructor should be  used, if appropriate. >There are two kinds of " make case" commands. CThe integer is the message's debug level. )89:&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK)89:&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK)9KJIHGFEDCBA>@?.=<;:9876543210/*+,-&)('8:89 KJIHGFEDCBA:&)('*+,-.=<;:9876543210/>@?uNoneMThe coinductive primitives. \3Rewrite a literal to constructor form if possible. Tries to build a M. #Get the name of the equality type. MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     $cMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     RSTUVWXYZ[\]^w~}|{zyxvutsrqponmlkjihgfedcba`_     MNOPQMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     $cxNone&;Resets the non-persistent part of the type checking state. ''Resets all of the type checking state.  Keep only / information. (Restore 3" after performing subcomputation. In contrast to , the / * info from the subcomputation is saved. +Get the current scope. ,Set the current scope. -Modify the current scope. .$Run a computation in a local scope. /Same as .., but discard the scope from the computation. 03Discard any changes to the scope by a computation. 1 Scope error. 2Debug print the scope. 9KRun some computation in a different signature, restore original signature. BGSet the top-level module. This affects the global module id of freshly  generated names. CIUse a different top-level module for a computation. Used when generating  names for imported modules. D6Tell the compiler to import the given Haskell module. EGet the Haskell imports. K Lens for #. NLens getter for / from 3. O Lens map for /. PLens getter for / from /. QLens modify for /. R6Run a fresh instance of the TCM (with initial state).  / info is preserved. S?Look through the signature and reconstruct the instance table. T Lens for %. X5Remove all instances whose type is still unresolved. Y0Add an instance whose type is still unresolved. ZAdd instance to some `class'. 5&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZName of the instance. Name of the class. 5&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ5&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ5&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZyNone [)Check whether benchmarking is activated. \Report benchmarking results. ]Report benchmarking results. $dFBill a computation to a specific account (True) or reimburse (False). ^*Bill a computation to a specific account. _Bill a top account. `Bill a sub account. a/Bill a pure computation to a specific account. b4Reimburse a specific account for computation costs. cReimburse a top account. $e#Add CPU time to specified account. [\]$d^_`abc$e&/0123456789:;<=>?@ABCDEFGHIJP[\]^_`abc P[\]^_a`bc [\]$d^_`abc$ezNone d:Errors which can arise when trying to find a source file. #Invariant: All paths are absolute. e#Several matching files were found. 7Invariant: The list of matching files has at least two  elements. f<The file was not found. It should have had one of the given  file names. g?Converts an Agda file name to the corresponding interface file  name. h?Given the module name which the error applies to this function  converts a d to a  . i@Finds the source file corresponding to a given top-level module ( name. The returned paths are absolute. -Raises an error if the file cannot be found. jATries to find the source file corresponding to a given top-level 1 module name. The returned paths are absolute. SIDE EFFECT: Updates . k A variant of j which does not require /. l<Finds the interface file corresponding to a given top-level / module name. The returned paths are absolute. @Raises an error if the source file cannot be found, and returns  7 if the source file can be found but not the interface  file. m=Ensures that the module name matches the file name. The file B corresponding to the module name (according to the include path) , has to be the same as the given file name. nDComputes the module name of the top-level module in the given file. ;Warning! Parses the whole file to get the module name out.  Use wisely! o A variant of n( which raises an error if the file name ! does not match the module name. =The file name is interpreted relative to the current working $ directory (unless it is absolute). defghijkInclude paths. Cached invocations of k. An updated copy is returned. lmThe name of the module. #The file from which it was loaded. no defghijklmno gdfehijklmno dfeghijklmno{None4pqrstuvwxyz{|}~$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$pqrstuvwxyz{|}~$~}yz{|uvwxtpqrs"pqrstuvwxyz{|}~$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$uvNone:Returns the pragma options which are currently in effect. @Returns the command line options which are currently in effect. Conditionally render debug Q and print it. $Conditionally println debug string. =Run a computation if a certain verbosity level is activated. .Precondition: The level must be non-negative. 6Check whether a certain verbosity level is activated. .Precondition: The level must be non-negative.  Gets the include directories. Precondition:  must be  something. @Which directory should form the base of relative include paths? The current working directory. The root directory of the "project" containing the given A file. The file needs to be syntactically correct, with a module  name matching the file name. Sets the pragma options. BSets the command line options (both persistent and pragma options  are updated). CRelative include directories are made absolute with respect to the D current working directory. If the include directories have changed  (thus, they are  now, and were previously  something), < then the state is reset (completely, see setIncludeDirs) . /An empty list of relative include directories ( []) is  interpreted as [.]. Disable display forms. Disable display forms. $Check if display forms are enabled. Don't eta contract implicit Do eta contract implicit Don't reify interaction points @Makes the given directories absolute and stores them as include  directories. <If the include directories change (and they were previously   something/), then the state is reset (completely, except ! for the include directories and ).  An empty list is interpreted as [.]. Should only be run if . 9Switch on printing of implicit and irrelevant arguments. 5 E.g. for reification in with-function generation. &Retrieve the current verbosity level. ,Displays a debug message in a suitable way. "Conditionally print debug string. >Print brackets around debug messages issued by a computation. ( New include directories. *How should relative paths be interpreted?  The message's debug level.  Message. $v' ' $ $v|NoneBWe put the translation into TCM in order to print debug messages. $wFNames in abstract syntax are fully qualified, but the concrete syntax H requires non-qualified names in places. In theory (if all scopes are K correct), we should get a non-qualified name when translating back to a - concrete name, but I suspect the scope isn't always perfect. In these 2 cases we just throw away the qualified part. It's just for pretty printing  anyway... $xGeneral bracketing function. $yExpression bracketing $zPattern bracketing ${JIf a name is defined with a fixity that differs from the default, we have 3 to generate a fixity declaration for that name. :Translate something in a context of the given precedence. $|:Translate something in a context of the given precedence. O$}$~$$$$$$$$$$$$w$$$$$xthe bracketing function Should we bracket things  which have the given  precedence? $y$z${$$|$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$D$}$$$~$$$$$$$$$$w$$$$$x$y$z${$$|$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$}NoneArecord fields names need to be distinguished to parse copatterns ETo simplify interaction between scope checking and type checking (in < particular when chasing imports), we use the same monad. RCreate a new module with an empty scope (Bool is True if it is a datatype module) $Apply a function to the scope info. #Apply a function to the scope map. %Apply a function to the given scope. 'Apply a function to the current scope. +Apply a monadic function to the top scope. 6Apply a function to the public or private name space. 8Run a computation without changing the local variables. 3Create a fresh abstract name from a concrete name. 8This function is used when we translate a concrete name  in a binder. The  of the concrete name is  saved as the N of the abstract name.  4freshAbstractName_ = freshAbstractName defaultFixity(Create a fresh abstract qualified name. @Look up the abstract name referred to by a given concrete name. >Look up the abstract name corresponding to a concrete name of  a certain kind. D Sometimes we know already that we are dealing with a constructor < or pattern synonym (e.g. when we have parsed a pattern). < Then, we can ignore conflicting definitions of that name ) of a different kind. (See issue 822.) Look up a module in the scope. >Get the fixity of a name. The name is assumed to be in scope. GBind a variable. The abstract name is supplied as the second argument. /Bind a defined name. Must not shadow anything. Rebind a name. Use with care! D Ulf, 2014-06-29: Currently used to rebind the name defined by an  unquoteDecl, which is a  in the body, but a   later on. Bind a module name. IBind a qualified module name. Adds it to the imports field of the scope. !Clear the scope of any no names. BCreate a new scope with the given name from an old scope. Renames G public names in the old scope to match the new name and returns the  renamings. JApply an import directive and check that all the names mentioned actually  exist. Open a module. ///)~NoneNone$5Alpha-Equivalence of patterns, ignoring dot patterns $,currently we only support variable patterns $A sequence of decisions b leading to a head a. $the list of choices $@This is a n^2 grouping algorithm which uses only alpha-equality $Expects a sorted list. $ Similar to $. $4Literal equality of patterns, ignoring dot patterns 2$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$($$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$None *Parse a specific identifier as a NamePart  Parse the  operator part of the given syntax. ) holes at beginning and end are IGNORED.  BGiven a name with a syntax spec, and a list of parsed expressions % fitting it, rebuild the expression.  ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions.  ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions.  ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions.      $                $None$%Name sets for classifying a pattern. $name of defined symbol $valid constructor names $valid field names $Data structure filled in by  buildParsers.  The top-level parser pTop is of primary interest,  but pArgs' is used to convert module application % from concrete to abstract syntax. $LBuilds parser for operator applications from all the operators and function 4 symbols in scope. When parsing a pattern we use . CThe effect is that operator parts (that are not constructor parts) ? can be used as atomic names in the pattern (so they can be  rebound). See testsucceedOpBind.agda for an example. FTo avoid problems with operators of the same precedence but different M associativity we decide (completely arbitrary) to fix the precedences of J operators with the same given precedence in the following order (from  loosest to hardest):  non-associative  left associative  right associative  prefix  postfix KThis has the effect that if you mix operators with the same precedence but * different associativity the parser won'!t complain. One could argue that % this is a Bad Thing, but since it'(s not trivial to implement the check it @ will stay this way until people start complaining about it. CCompute all unqualified defined names in scope and their fixities. $HCompute all names (first component) and operators (second component) in  scope. For backwards compatibility.  Returns the pTop from  buildParsers. $lhsArgs' p splits a lhs f ps, given as a pattern p,  into (f, ps). View a pattern p as a list p0 .. pn where p0 is the identifier " (in most cases a constructor). 9Pattern needs to be parsed already (operators resolved). %Returns the list of possible parses. $)Returns zero or one classified patterns. KParses a left-hand side, and makes sure that it defined the expected name. O TODO: check the arities of constructors. There is a possible ambiguity with  postfix constructors: ( Assume _ * is a constructor. Then 'true *' can be parsed as either the M intended _* applied to true, or as true applied to a variable *. If we $ check arities this problem won' t appear. Parses a pattern. O TODO: check the arities of constructors. There is a possible ambiguity with  postfix constructors: ( Assume _ * is a constructor. Then 'true *' can be parsed as either the M intended _* applied to true, or as true applied to a variable *. If we $ check arities this problem won' t appear. Helper function for  and . $Helper function for  and .  ?Collect all names in a pattern into a list of qualified names. !,Return all qualifiers occuring in a list of  s. 7 Each qualifier is returned as a list of names, e.g.  for  Data.Nat._+_ we return the list  [Data,Nat]. "1Parse a list of expressions into an application. #.Parse an expression into a module application - (an identifier plus a list of arguments). 6$$$$$$$$$$$$$$$$$$$$%$%%%$%$%$ !"%%#$%%&% %  !"#$%&"#%&$! %$$$$$$$$$$$$$$$$$$$$%$%%%$%$%$ !"%%#$%%&% % None)%Record a function call in the trace. '()*+,-.'()*+,-.'()*+,-.'()*+,-.None /,Get the name of the current module, if any. 0$Set the name of the current module. 18Get the number of variables bound by anonymous modules. 2,Add variables bound by an anonymous module. 3)Set the current environment to the given 4Get the current environment 57Increases the module nesting level by one in the given  computation. 6Set highlighting level 7Restore setting for   to default. 9DIf the reduced did a proper match (constructor or literal pattern), , then record this as simplification step. <Reduce Def f vs only if f is a projection. /0123456789:;<=>?@ABCD/0123456789:;<=>?@ABCD/0123456789:;<=>?@ABCD/0123456789:;<=>?@ABCDNoneMsimplifyLevelConstraint n c cs turns an c into an equality @ constraint if it is an inequality constraint and the reverse  inequality is contained in cs . Number n is the length  of the context c is defined in. % % M% MM% % M% NonePPPPNoneQRSTUV%%%%%%%%%%%%QRSTUVTUVQRSQRSTUV%%%%%%%%%%%%NoneY+Remove ranges in keys and values of a map. %Overlaps with  KillRange [a]. Y%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/YYY%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/NoneZGet the current problem [ZSteal all constraints belonging to the given problem and add them to the current problem. _Get the awake constraints hAdd new a constraint iAdd already awake constraints jStart solving constraints Z[\]^_`abcdefghijklmnoZ[\]^_`abcdefghijklmnoZ[\]^_`abcdefghijklmnoZ[\]^_`abcdefghijklmnoNonep,Create an open term in the current context. q%Create an open term which is closed. rIExtract the value from an open term. Must be done in an extension of the * context in which the term was created. sTry to use an   the current context.  Returns / if current context is not an extension of the  context in which the   was created. pqrspqrspqrspqrsNoneWQCheck if we are in a compatible context, i.e. an extension of the given context. XGet the current context. tVarious specializations of addCtx. v Modify the   field of a  . w Modify all  s. x Modify a   in a computation. zChange the context. { Change to top (=empty) context. |Delete the last n bindings from the context. }addCtx x arg cont add a variable to the context. Chooses an unused J. ~;add a bunch of variables with the same type to the context 9Turns the string into a name and adds it to the context. JTurns the string into a name and adds it to the context, with dummy type. 5Context entries without a type have this dummy type. Go under an abstraction. LGo under an abstract without worrying about the type to add to the context.  Add a telescope to the context. Add a let bound variable %Get the size of the current context.  Generate [var (n - 1), ..., var 0]& for all declarations in the context. Get the current context as a  J. 1get type of bound variable (i.e. deBruijn index) HGet the term corresponding to a named variable. If it is a lambda bound M variable the deBruijn index is returned and if it is a let bound variable  its definition is returned. 'WXtuvwxyz{|}~%0%1%2%3%4%5%6%7%8WXtuvwxyz{|}~vwxyz{|}tu~XW&WXtuvwxyz{|}~%0%1%2%3%4%5%6%7%8None4Unfreeze meta and its type if this is a meta again. 0 Does not unfreeze deep occurrences of metas. *Check whether all metas are instantiated. G Precondition: argument is a meta (in some form) or a list of metas.  Switch off assignment of metas. Get the meta store. Lookup a meta variable >Given a meta, return the type applied to the current context. Create   in the current environment. 5Register an interaction point during scope checking. 2 If there is no interaction id yet, create one. ,Hook up meta variable to interaction point. AMove an interaction point from the current ones to the old ones. Get a list of interaction ids. 2Get all metas that correspond to interaction ids. 2Get all metas that correspond to interaction ids. ;Does the meta variable correspond to an interaction point? Time: O(n) where n% is the number of interaction metas. 8Get the information associated to an interaction point. Get  8 for an interaction point. 1 Precondition: interaction point is connected. Generate new meta variable. <Generate a new meta variable with some instantiation given. . For instance, the instantiation could be a  . Get the  for an interaction point. Get the  for a meta variable. listenToMeta l m : register l as a listener to m. This is done $ when the type of l is blocked by m. Unregister a listener. Get the listeners to a meta. Freeze all meta variables. Thaw all meta variables. %9Does not worry about raising. A%:%;%<%=%>%?%@%A%B%9%C%D%E%F%G%H%I%J//?%:%;%<%=%>%?%@%A%B%9%C%D%E%F%G%H%I%JNone%KThe with clauses haven't been translated yet %L rewrite e (many) %Mwith e (many) %Nqthe subclauses spawned by a with (monadic because we need to reset the local vars before checking these clauses) +Temporary data type to scope check a file. 0The file path from which we loaded this module. The file content. GThings that can be translated to abstract syntax are instances of this  class. %O/Make sure that each variable occurs only once. %PDCompute the type of the record constructor (with bogus target type) %Q 7checkModuleApplication modapp m0 x dir = return (modapp' , renD, renM)m0' is the new (abstract) module name and  x- its concret form (used for error messages). %R BcheckModuleMacro mkApply range access concreteName modapp open dirPreserves local variables. %SThe public) keyword must only be used together with open. %TComputes the range of all the "to" keywords used in a renaming  directive. %U(This function should be used instead of  for things that need 8 to keep track of precedences to make sure that we don't forget about it. BThis operation does not affect the scope, i.e. the original scope  is restored upon completion. %VLike 3 but returns the scope after the completion of the  second argument. %W Peel off  and represent it as an . %X Peel off  and represent it as an , throwing away any name. %YBy default, arguments are Relevant. %ZBParse a possibly dotted C.Expr as A.Expr. Bool = True if dotted. %[+Scope check a module (top level function). %\1Check whether a telescope has open declarations. %]-Returns the scope inside the checked module. The top-level module name. %^Aruns Syntax.Concrete.Definitions.niceDeclarations on main module %_KTurn an operator application into abstract syntax. Make sure to record the . right precedences for the various arguments. %`%a%b%K%c%d%L%M%N%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%O%P%Q%R%S%T%U%%%V%%%%W%X%Y%Z%%%%[%\%]!The concrete name of the module. !The abstract name of the module. The module telescope. +The code for checking the module contents. %^%%%%%_%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%h%`%c%K%b%a%d%L%M%N%e%f%g%h%i%k%j%l%m%n%o%p%q%r%s%t%w%v%u%x%y%z%{%|%}%~%%%%%%%O%P%Q%R%S%T%U%%%V%%%%W%X%Y%Z%%%%[%\%]%^%%%%%_%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%NoneFAssumes that the first module in the import path is the module we are  worried about. None&Set the mutual block for a definition Get all mutual blocks ?Get the current mutual block, if any, otherwise a fresh mutual  block is returned. None$HLookup the definition of a name. The result is a closed thing, all free ( variables have been abstracted over. DAdd a constant to the signature. Lifts the definition to top level. 3Set termination info of a defined function symbol. "Modify the clauses of a function. <Lifts clauses to the top-level and adds them to definition.  Add a section to the signature. Lookup a section. If it doesn'(t exist that just means that the module  wasn't parameterised. ?Module application (followed by module parameter abstraction).  ;Can be called on either a (co)datatype, a record type or a  (co)constructor.  @Does the given constructor come from a single-constructor type? 6Precondition: The name has to refer to a constructor.  &Look up the polarity of a definition.  ;Look up polarity of a definition and compose with polarity  represented by  . "Set the polarity of a definition. .Return a finite list of argument occurrences. (Get the mutually recursive identifiers. (Set the mutually recursive identifiers. 6Check whether two definitions are mutually recursive. EWhy Maybe? The reason is that we look up all prefixes of a module to I compute number of parameters, and for hierarchical top-level modules, & A.B.C say, A and A.B do not exist. HLook up the number of free variables of a section. This is equal to the  number of parameters if we'1re currently inside the section and 0 otherwise. ECompute the number of free variables of a module. This is the sum of ' the free variables of its sections. KCompute the number of free variables of a defined name. This is the sum of ( the free variables of the sections it's contained in. 8Compute the context variables to apply a definition to. EInstantiate a closed definition with the correct part of the current  context. (Give the abstract view of a definition. PEnter abstract mode. Abstract definition in the current module are transparent. ;Not in abstract mode. All abstract definitions are opaque. @Ignore abstract mode. All abstract definitions are transparent. FCheck whether a name might have to be treated abstractly (either if we're   or it'1s not a local name). Returns true for things not , declared abstract as well, but for those  will have no effect. !=Get type of a constant, instantiated to the current context. "Get relevance of a constant. #Get colors of a constant. $The name must be a datatype. %'Is it the name of a record projection? (%Number of dropped initial arguments. )Apply a function f- to its first argument, producing the proper  postfix projection if f is a projection. *getDefType f t3 computes the type of (possibly projection-(like))  function t whose first argument has type t.  The  parameters for f are extracted from t.  Nothing if f is projection(like) but  t is not a datarecord axiom type. Precondition: t is reduced.  See also:  70Name of new module defined by the module macro. Parameters of new module. )Name of old module applied to arguments. !Arguments of module application. $Imported names (given as renaming). &Imported modules (given as renaming).       !"#$%&'()*%6      !"#$%&'()*6      !"#$%&'()*6      !"#$%&'()*%None2A deep view on sizes. 8A useful view on sizes. <)Result of querying whether size variable i is bounded by another  size. >yes i : Size< t ?Check if a type is the s type. The argument should be reduced. E/Test whether OPTIONS --sized-types and whether # the size built-ins are defined. F%Add polarity info to a SIZE builtin. L?Transform list of terms into a term build from binary maximum. NsizeViewComparable v w checks whether v >= w (then Left)  or v <= w (then Right ). If uncomparable, it returns  NotComparable. PsizeViewPred k v decrements v by k (must be possible!). QsizeViewOffset v9 returns the number of successors or Nothing when infty. R(Remove successors common to both sides. STurn a size view into a term. VmaxViewCons v ws = max v ws. It only adds v to ws if it is not  subsumed by an element of ws. WsizeViewComparableWithMax v ws tries to find w in ws that compares with v  and singles this out.  Precondition: v / = DSizeInv. --./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY--./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY-<>=?@ABCDEFGHIJKL8;:9M726543.10/NOPQRST-UVWXY!-.10/2654378;:9<>=?@ABCDEFGHIJKLMNOPQRSTUVWXYNoneZGet the statistics. %*Modify the statistics via given function. [Increase specified counter by 1. \Increase specified counter by n. ]BSet the specified counter to the maximum of its current value and n. %'Modify specified counter by a function f. Z%[\]%Z[\][\]ZZ%[\]%None/01234                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn &'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ'()*+,-./0123456789:;<=>?@ABCDPWXZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]None^Interaction monad. _;Line reader. The line reader history is not stored between  sessions. ^_`%^_`^_`^_`%Noned"Records already processed modules , and maps them to an internal identifier. e Supply of internal identifiers. fEdges of dependency graph. gBInternal module identifiers for construction of dependency graph. i Translate a ? to an internal g.  Returns True if the ? is new, i.e., has not been I encountered before and is thus added to the map of processed modules. j&Add an arc from importer to imported. k4Recursively build import graph, starting from given  .  Modifies the state in a and returns the g of the  . l<Generate a .dot file for the import graph starting with the  given  + and write it to the file specified by the  command line option. abcdefghijkl abcdefghijkl gbcdefhaijklabcdefghijklNone%"The name of the default CSS file. m:Generates HTML files from all the sources which have been + visited during the type checking phase. <This function should only be called after type checking has  completed successfully. %<Converts module names to the corresponding HTML file names. %BGenerates an HTML file with a highlighted, hyperlinked version of  the given module. %,Constructs the web page, including headers. %)Constructs the HTML displaying the code. %m%%$Directory in which to create files. Module to be highlighted. )Syntax highlighting info for the module. %URL to the CSS file. Module to be highlighted. The contents of the module. Highlighting information. %The contents of the module. Highlighting information. mm%m%%%%Nonedata   see  unusableRelevance rel == True! iff we cannot use a variable of rel.  composition.   is dominant,  is neutral. inverseComposeRelevance r x returns the most irrelevant y  such that forall x, y we have  x ` moreRelevant` (r `composeRelevance` y)  iff  (r `inverseComposeRelevance` x) ` moreRelevant` y (Galois connection). For comparing  Relevance ignoring Forced and  UnusedArg. LIrrelevant function arguments may appear non-strictly in the codomain type. GPrepare parts of a parameter telescope for abstraction in constructors  and projections. )Used to modify context when going into a rel argument. Compose two relevance flags. = This function is used to update the relevance information  on pattern variables a! after a match against something rel. >Modify the context whenever going from the l.h.s. (term side) 6 of the typing judgement to the r.h.s. (type side). .Call me if --experimental-irrelevance is set. EInternal workhorse, expects value of --experimental-irrelevance flag  as argument. E(Conditionally) wake up irrelevant variables and make them relevant.  For instance, E in an irrelevant function argument otherwise irrelevant variables F may be used, so they are awoken before type checking the argument. DWake up irrelevant variables and make them relevant. For instance, E in an irrelevant function argument otherwise irrelevant variables F may be used, so they are awoken before type checking the argument. None% Converts the  { and  | fields to atoms readable  by the Emacs interface. %@Shows meta information in such a way that it can easily be read  by Emacs. 5Turns syntax highlighting information into a list of  S-expressions. All the properties. %%.Must contain a mapping for the definition site's  module, if any. 0Must contain a mapping for every definition site' s module. %%None Variant of . which does not insert outermost parentheses.  Variant of . which does not insert outermost parentheses. NoneCalls a compiler: A Checks the exit code to see if the compiler exits successfully. @ If not, then an exception is raised, containing the text the ( compiler printed to stderr (if any). 9 Uses the debug printout machinery to relay any progress . information the compiler prints to stdout. Generalisation of  callCompiler where the raised exception is  returned. The path to the compiler Command-line arguments. The path to the compiler Command-line arguments. None%!Is not used currently, but could * potentially be used for hyperlinks as in  the HTML output? %-Column number, used for polytable alignment. %'Indentation level, also for alignment. %(Keeps track of whether we are in a code  block or not. %,Says what debug information should printed. %The LaTeX monad is a combination of ErrorT, RWST and  IO@. The error part is just used to keep track whether we finished  or not, the reader part isn''t used, the writer is where the output F goes and the state is for keeping track of the tokens and some other  useful info, and the I/,O part is used for printing debugging info. %Run function for the LaTeX monad. %3Yields the next token, taking special care to begin/ end code E blocks. Junk occuring before and after the code blocks is separated E into separate tokens, this makes it easier to keep track of whether  we are in a code block or not. %The start state, nonCode%, prints non-code (the LaTeX part of  literate Agda) until it sees a  beginBlock. %>Deals with code blocks. Every token, except spaces, is pretty  printed as a LaTeX command. %@Fixity declarations need a special treatment. The operations in  declarations like: infix num op1 op2 op3 Dare treated as comments and thus grouped together with the newlines D that follow, which results incorrect LaTeX output -- the following 5 state remedies the problem by breaking on newlines. %BSpaces are grouped before processed, because multiple consecutive D spaces determine the alignment of the code and consecutive newline , characters need special treatment as well. The only exported function. It's (only) called in Main.hs. %'Transforms the source code into LaTeX. A%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%%&%%&%&1%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%%&%%&%&None&Monad used by the decoder. /9 is not used because the associated overheads would make  decoding slower. &Monad used by the encoder. &State of the decoder. &<Maps module names to file names. This is the only component / of the state which is updated by the decoder. & The include directories. & >Univeral memo structure, to introduce sharing during decoding & "Universal type, wraps everything. & State of the the encoder. & ,The type of hashtables used in this module. 0A very limited amount of testing indicates that &  is somewhat slower than & , and that  & and the hashtables from Data.Hashtable are  much slower. &6Constructor tag (maybe omitted) and argument indices. &:Throws an error which is suitable when the data stream is  malformed. :Encodes something. To ensure relocatability file paths in + positions are replaced with module names. &FData.Binary.runGetState is deprecated in favour of runGetIncremental. Q Reimplementing it in terms of the new function. The new Decoder type contains Q strict byte strings so we need to be careful not to feed the entire lazy byte " string to the decoder at once. ;Decodes something. The result depends on the include path. Returns 2 if the input does not start with the right magic 5 number or some other decoding error is encountered. :Encodes something. To ensure relocatability file paths in + positions are replaced with module names. ;Decodes something. The result depends on the include path. Returns 1 if the file does not start with the right magic 5 number or some other decoding error is encountered. &vcase value ix decodes thing represented by  ix :: Int32  via the valu function and stores it in &.  If ix is present in &, valu is not used, but  the thing is read from & instead. &Creates an empty dictionary. &Serialization. &Deserialization. &&&&&&&&&&& & & && && &!&"&#&$&%&&&'&(&)&*& &&+&&&,&-&&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&3Maps file names to the corresponding module names. 4 Must contain a mapping for every file name that is  later encountered. &[&\&]&^&_&`&a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & & && && &!&"&#&$&%&&&'&(&)&*& &&+&&&,&-&&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&&[&\&]&^&_&`&a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None%%%%None& Agda module names. Used to test . &8Can the character be used in a Haskell module name part  (conid;)? This function is more restrictive than what the Haskell  report allows. @Haskell module names have to satisfy the Haskell (including the : hierarchical module namespace extension) lexical syntax:  modid -> [modid.] large {small | large | digit | ' }1 is an injective function into the set of module  names defined by modid. The function preserves .s, and it also 5 preserves module names whose first name part is not . 3Precondition: The input must not start or end with . , and no two  .s may be adjacent. All the properties. &&&&&&&&&&&&&&None/A wrapper type used to avoid orphan instances. 2Encodes module names just before pretty-printing. &&&&&&&&NoneNone:When making a function projection-like, we drop the first n  arguments. &To drop the first n! arguments in a compiled clause, + we reduce the split argument indices by n and  drop n arguments from the bodies. 9 NOTE: this only works for non-recursive functions, we < are not dropping arguments to recursive calls in bodies. &-NOTE: does not work for recursive functions. &KNOTE: does not go into the body, so does not work for recursive functions. &>NOTE: This creates telescopes with unbound de Bruijn indices. &&&&&&&&&&&&&&None&>A graph is cyclic if it has any strongly connected component. &recDef names name returns all definitions from names  that are used in the body of name. anysDef names a returns all definitions from names  that are used in a. &&&&None&=Run a computation if a certain verbosity level is activated. .Precondition: The level must be non-negative. &<Apply a function if a certain verbosity level is activated. .Precondition: The level must be non-negative. &&&&&&&&&&&&&&  &&&&&&&&&&&&&&None4Contracts all eta-redexes it sees without reducing. NoneNone&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None8Expand away (deeply) all pattern synonyms in a pattern. 'Expand literal integer pattern into suc/zero constructor patterns. ''''''''''None instantiateFull' %s metas everywhere (and recursively)  but does not .  8Only unfold definitions if this leads to simplification ! which means that a constructor/literal pattern is matched. Instantiate something. 3 Results in an open meta variable or a non meta.  Doesn'Dt do any reduction, and preserves blocking tags (when blocking meta  is uninstantiated). If the first argument is !#, then a single delayed clause may  be unfolded. JReduce a non-primitive definition if it is a copy linking to another def. =Reduce a non-primitive definition once unless it is delayed.  +Reduce simple (single clause) definitions. "?Apply a definition using the compiled clauses, or fall back to 2 ordinary clauses if no compiled clauses exist. $Apply a defined function to it')s arguments, using the compiled clauses. A The original term is the first argument applied to the third. &Apply a defined function to it')s arguments, using the original clauses.       !"#$%&'(''''' ' ' ' ' ''''''''''''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['\']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~'''''"      !"#$%&'("  !"#$%&'  (        !"#$%&'(''''' ' ' ' ' ''''''''''''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['\']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~'''''None )A telescope split in two. 2 Strips all Pi'4s and return the head definition name, if possible. 3QThe permutation should permute the corresponding telescope. (left-to-right list) 6Flatten telescope: (7<Order a flattened telescope in the correct dependeny order: 9HUnflatten: turns a flattened telescope into a proper telescope. Must be  properly ordered. :)Get the suggested names from a telescope =ISplit a telescope into the part that defines the given variables and the  part that doesn't. ?telViewUpTo n t takes off the first n function types of t.  Takes off all if n < 0. @ telViewUpTo' n p t takes off $t$  the first n (or arbitrary many if n < 0) function domains  as long as they satify p. AA safe variant of piApply. DJTry to solve the instance definitions whose type is not yet known, report  an error if it doesn'0t work and return the instance table otherwise. )*+,-./0123456789:;<=>?@ABCD)*+,-./0123456789:;<=>?@ABCD.10/23456789:;<)*+,-=>?@ABCD)*+,-.10/23456789:;<=>?@ABCDNone +AGet the name of the datatype constructed by a given constructor. : Precondition: The argument must refer to a constructor ,)Get true constructor with record fields. HGet true constructor as term. IEGet true constructor with fields, expanding literals to constructors  if possible. JDAugment constructor with record fields (preserve constructor name). / The true constructor might only surface via reduce. K Analogous to H. LgetConType c t/ computes the constructor parameters from type t 4 and returns the instantiated type of constructor c.  Nothing if t is not a data/record type or does not have  a constructor c.  Precondition: t is reduced. MDReturn the number of non-parameter arguments to a data constructor, / or the field names of a record constructor. *For getting just the arity of constructor c,  use either id size  $ getConstructorArity c. NKCheck if a name refers to a datatype or a record with a named constructor. O2Check if a name refers to a datatype or a record. +,EFGHIJKLMNOPQ+,EFGHIJKLMNOPQ,HIJK+LMNEGFOPQ +,EGFHIJKLMNOPQNoneR telFromList . telToList == idSAll elements of 6/ are well-scoped under the original telescope. T unflattenTel . flattenTel == idU7 is stable. V4The result of splitting a telescope is well-scoped. WHThe permutation generated when splitting a telescope preserves scoping. RSTUVWXRSTUVWXRSTUVWXRSTUVWXNone YCompiler monad ZStuff we need in our compiler aThe initial (empty) state b"When normal errors are not enough c&Modify the state of the current module's Epic Interface d#Get the state of the current module's Epic Interface e0Returns the type of a definition given its name f;Create a name which can be used in Epic code from a QName. }"Copy pasted from MAlonzo, HAHA!!!  Move somewhere else! ~,Bind an expression to a fresh variable name &YZ[\]^_`abcdefghijklmnopqrstuvwxyz{| replace at  to replace  replace with result? }~&YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&Z[\]^_`aYbcdefghijklmnopqrstuvwxyz{|}~ YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None#Run the case-opts on an expression None!Check which arguments are forced 7Remove forced arguments from constructors and branches None#Print a function to an Epic string $Print expression to Epic expression ''''''''' '''''''''None?Get a list of all the datatypes that look like nats. The [QName] is on the  form [zeroConstr, sucConstr] 'Count the number of relevant arguments !Check if argument n is recursive None FChange constructors and cases on builtins and natish datatypes to use  primitive data -Map primitive constructors to primitive tags -Build transforms using the names of builtins +Translation to primitive integer functions *Corresponds to a case for natural numbers 5Corresponds to a case with a zero and default branch (Translation to primitive bool functions BChange all the primitives in the function using the PrimTransform ?Change all the primitives in an expression using PrimTransform Expression that is cased on Expression for the zero branch %Variable that is bound in suc branch Expression used for suc branch Result? Expression that is cased on  Zero branch Default branch Result? NoneGet the 'primLevel as a  ^, if present. Get the ~ as a  N. .Raises an error if no level kit is available.  NoneClass Match for matching a term p in the role of a pattern  against a term v. The 0th variable in p plays the role = of a place holder (pattern variable). Each occurrence of  var 0 in p* stands for a different pattern variable. FThe result of matching, if successful, is a list of solutions for the . pattern variables, in left-to-right order. *The 0th variable is in scope in the input v, but should not  actually occur!  In the output solution, the 0th! variable is no longer in scope. C (It has been substituted by __IMPOSSIBLE__ which corresponds to  a raise by -1). !Find a matching display form for q vs. % In essence this tries to reqwrite q vs with any  display form  q ps --> dt and returns the instantiated  dt# if successful. First match wins. Match a   q ps = v against q vs.  Return the   v[us] if the match was successful,  i.e., vs / ps = Just us. '''''' ''''''None' dotVars ps3 gives all the variables inside of dot patterns of ps ; It is only invoked for patternish things. (Ulf O-tone!) B Use it for printing l.h.sides: which of the implicit arguments  have to be made explicit. 'reifyDisplayForm f vs fallback  tries to rewrite f vs with a display form for f. 6 If successful, reifies the resulting display term,  otherwise, does fallback. 'reifyDisplayFormP tries to recursively & rewrite a lhs with a display form. >Note: we are not necessarily in the empty context upon entry! ' ?nameFirstIfHidden n (a1->...an->{x:a}->b) ({e} es) = {x = e} es'CMove dots on variables so that each variable is bound at its first C non-hidden occurrence (if any). If all occurrences are hidden it's bound  at the first occurrence. 'ARemoves implicit arguments that are not needed, that is, that don't bind 1 any variables that are actually used and doesn't do pattern matching. '+Getting all(!) variables of an expression. C It should only get free ones, but it does not matter to include  the bound ones. 'CSkip reification of implicit and irrelevant args if option is off. E''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''9''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''NoneH'''''''''''''''''''''''''''''''''''''''''F'''''''''''''''''''''''''''''''''''''''''oNone'Indefinite article.  Warnings. 8Invariant: The fields are never empty at the same time. 2Termination checking problems are not reported if  optTerminationCheck is . :Meta-variable problems are reported as type errors unless  optAllowUnsolved is !. Same as . BTurns warnings into an error. Even if several errors are possible  only one is raised. '3Drops the filename component of the qualified name '-Print two terms that are supposedly unequal. > If they print to the same identifier, add some explanation ( why they are different nevertheless. p''((((((((('( '( ( ( ( (((((( p pp''((((((((('( '( ( ( ( ((((((None{LCheck if a constructor name is the internally generated record constructor. |-The fields should be eta contracted already. "We can eta contract if all fields f = ... are irrelevant  or all fields f are the projection f v of the same value v, = but we need at least one relevant field to find the value v. 8TODO: this can be moved out of TCM (but only if ConHead 8 stores also the Arg-decoration of the record fields. }!Get the field names of a record. ~4Check if a name refers to an eta expandable record. $Check if a name refers to a record. % If yes, return record definition. +Order the fields of a record construction. / Use the second argument for missing fields. 2The name of the module corresponding to a record. AGet the definition for a record. Throws an exception if the name 9 does not refer to a record or the record is abstract. /Get the record name belonging to a field name. 1Find all records with at least the given fields. !Get the field types of a record. 0Get the field names belonging to a record type. (Get the type of the record constructor. Returns the given record type'"s constructor name (with an empty  range). 5Reduce a type and check whether it is a record type. 7 Succeeds only if type is not blocked by a meta var. 8 If yes, return its name, parameters, and definition. 5Reduce a type and check whether it is a record type. 7 Succeeds only if type is not blocked by a meta var. 8 If yes, return its name, parameters, and definition. : If no, return the reduced type (unless it is blocked). The analogue of . If v is a value of record type T  with field f, then projectType T f returns the type of f v. eCheck if a name refers to a record which is not coinductive. (Projections are then size-preserving) aCheck if a type is an eta expandable record and return the record identifier and the parameters. 0Check if a name refers to a record constructor. % If yes, return record definition. Mark record type as unguarded. ? No eta-expansion. Projections do not preserve guardedness. Mark record type as recursive. , Projections do not preserve guardedness. 2Check whether record type is marked as recursive. :Precondition: record type identifier exists in signature.  Version of  recRecursive with proper internal error. etaExpand r pars u, computes the eta expansion of record value u  at record type r pars. The first argument r, should be the name of a record type. Given  /record R : Set where field x : A; y : B; .z : Cand r : R,   etaExpand R [] r = (tel, [R.x r, R.y r, R.z r])where tel8 is the record telescope instantiated at the parameters pars. ?Is the type a hereditarily singleton record type? May return a  blocking metavariable. >Precondition: The name should refer to a record type, and the 1 arguments should be the parameters to the type. 1Return the unique (closed) inhabitant if exists. ? In case of counting irrelevance in, the returned inhabitant  contains garbage. <Check whether a type has a unique inhabitant and return it.  Can be blocked by a metavar. ICheck whether a type has a unique inhabitant (irrelevant parts ignored).  Can be blocked by a metavar. Auxiliary function. &{|}~&{|}~&}~{|&{|}~None  Note that Inf a b, where Inf is the INFINITY builtin, is  translated to  translationof b (assuming that all coinductive  builtins are defined).  Note that if  haskellType* supported universe polymorphism then the 4 special treatment of INFINITY might not be needed.                 None Relevance or  Relevance and 1Try to find as many unused variables as possible Initiate a function's relevancies 5Calculate if a variable is relevant in an expression 8Try to find a fixpoint for all the functions relevance.     None%Are two terms injectible? H Tries to find a mapping between constructors that equates the terms. .Precondition: t1 is normalised, t2 is in WHNF W When reducing t2, it may become a literal, which makes this not work in some cases... 'FIf the pairs of constructor names have the same tags, the function is 9 injective. If Nothing, the function is not injective. (PFind potentially injective functions, solve constraints to fix some constructor F tags and make functions whose constraints are fulfilled injections /(Turn NATURAL literal n into suc^n zero. " !"#$%&'()*"Name of the function being tested  The function' s clauses +,-."Name of the function being tested The current argument /0123456789:;(((( !"#$%&'()*+,-./0123456789:;()'*+,-./012345%&"$# !6789:; !"$#%&'()*+,-./0123456789:;((((None=)Main function, smash as much as possible ?CCan a datatype be inferred? If so, return the only possible value. AKFind the only possible value for a certain type. If we fail return Nothing <=>?@AB<=>?@AB<=>?@AB<=>?@ABNoneC8State worked on during the main loop of checking a lhs. N4__IMPOSSIBLE__, only there to make this instance of  . QSplit on projection pattern. D The projection could be belonging to an irrelevant record field. TSplit on constructor pattern.  The [Name]&s give the as-bindings for the focus. Y,Do we come from an implicit record pattern? ]/Index of focused variable in the out patterns. a=Type of variable we are splitting, kept for record patterns. b2User patterns that could not be given a type yet.  Example:   6 f : (b : Bool) -> if b then Nat else Nat -> Nat  f true = zero  f false zero = zero  f false (suc n) = n   C In this sitation, for clause 2, we construct an initial problem    problemInPat = [false]  problemTel = (b : Bool) " problemRest.restPats = [zero] ; problemRest.restType = if b then Nat else Nat -> Nat    As we instantiate b to false, the e reduces to   Nat -> Nat and we can move pattern zero over to  problemInPat. d4List of user patterns which could not yet be typed. eType eliminated by d.  Can be  to indicate that we came by 5 an irrelevant projection and, hence, the rhs must ' be type-checked in irrelevant mode. gThe permutation should permute allHoles" of the patterns to correspond to ) the abstract patterns in the problem. h&State of typechecking a LHS; input to split.  [Ulf Norell's PhD, page. 35] In Problem ps p delta,  ps( are the user patterns of supposed type delta.  p. is the pattern resulting from the splitting. jUser patterns. kPatterns after splitting. lType of patterns. m#Patterns that cannot be typed yet. nGFlexible variables are equipped with information where they come from, Q in order to make a choice which one to assign when two flexibles are unified. sNWhen we encounter a flexible variable in the unifier, where did it come from? O The alternatives are ordered such that we will assign the higher one first, " i.e., first we try to assign a DotFlex , then... tFrom a dot pattern ( %). uFrom a hidden formal argument ( ImplicitP). vFrom a record pattern ( $). (b is a right dominant monoid.  pr1 `mappend` pr2 = pr2 unless  pr2 = mempty , then it is pr1. ' Basically, this means that the left b is discarded, so  use it wisely! CCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz((((((((( (!("8CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz8xwsvutnopqryzhijklmgfbcdeUWVXYZ[\]^_`aPTQRSMONKLIJCDEFGHCDEFGHIJKLMONPTQRSU WVXYZ[\]^_`abcdefghijklmnopqrsvutwxyz((((((((( (!("None){.The call information is stored as free monoid  over  ~#. As long as we never look at it, 9 only accumulate it, it does not matter whether we use  Set, (nub) list, or Tree. > Internally, due to lazyness, it is anyway a binary tree of  (# nodes and singleton leafs.  Since we define no order on  ~ (expensive),  we cannot use a Set or nub list. H Performance-wise, I could not see a difference between Set and list. ~Extract variables from  s that could witness a decrease  via a SIZELT constraint. GThese variables must be under an inductive constructor (with no record G constructor in the way), or after a coinductive projection (with no  inductive one in the way). &The name refers to either an ordinary 9 constructor or the successor function on sized types. De Bruijn Index. .Patterns with variables as de Bruijn indices. Termination monad. !Termination monad service class. The termination environment. BAre we mining dot patterns to find evindence of structal descent? 4Do we assume that record and data type constructors  preserve guardedness? EDo we inline with functions to enhance termination checking of with? $The name of size successor, if any. 3The name of the delay constructor (sharp), if any. 0Depth at which to cut off the structural order. 4The name of the function we are currently checking. @The names of the functions in the mutual block we are checking. 4 This includes the internally generated functions ( (with, extendedlambda, coinduction). CThe list of name actually appearing in the file (abstract syntax). 0 Excludes the internally generated functions. CTarget type of the function we are currently termination checking.  Only the constructors of  are considered guarding. &Are we checking a delayed definition? Only consider the !) arguments for establishing termination. Only consider guardedness if !. ,The patterns of the clause we are checking. 0Number of additional binders we have gone under F (and consequently need to raise the patterns to compare to terms). 7 Updated during call graph extraction, hence strict. HThe current guardedness status. Changes as we go deeper into the term. 7 Updated during call graph extraction, hence strict. FWhen extracting usable size variables during construction of the call V matrix, can we take the variable for use with SIZELT constraints from the context? 2 Yes, if we are under an inductive constructor. - No, if we are under a record constructor. KPattern variables that can be compared to argument variables using SIZELT. The current guardedness level. ,The target of the function we are checking. "The mutual block we are checking. BThe functions are numbered according to their order of appearance  in this list. "An empty termination environment. 9Values are set to a safe default meaning that with these 8 initial values the termination checker will not miss > termination errors it would have seen with better settings  of these values. 2Values that do not have a safe default are set to   IMPOSSIBLE. BShould the codomain part of a function type preserve guardedness?  Lens for .  Lens for . :Compute usable vars from patterns and run subcomputation. Set  when going under constructor c. Set $ for arguments following projection q. BFor termination checking purposes flat should not be considered a % projection. That is, it flat doesn'#t preserve either structural order - or guardedness like other projections do. N Andreas, 2012-06-09: the same applies to projections of recursive records. ;Check whether a projection belongs to a coinductive record  and is actually recursive.  E.g.   ; isCoinductiveProjection (Stream.head) = return False  4isCoinductiveProjection (Stream.tail) = return True   ;A dummy pattern used to mask a pattern that cannot be used  for structural descent.  raiseDBP n ps# increases each de Bruijn index in ps by n. ? Needed when going under a binder during analysis of a term. ($*Only show intermediate nodes. (Drop last  ~). _{|}~($(%(&('((()(*(+(,(-(.T{|}~T~{|}@{|}~($(%(&('((()(*(+(,(-(.None (/(0(1(2(3 (/(0(1(2(3NoneConvert from Agda'0s internal representation to our auxiliary AST. BTranslate an Agda definition to an Epic function where applicable Translate from Agda'>s desugared pattern matching (CompiledClauses) to our AuxAST. & This is all done by magic. It uses  to translate the actual 0 terms when the cases have been gone through. L The case expressions that we get use de Bruijn indices that change after # each case in the following way.  Say we have this pattern:   f (X x y) (Y z) = term -Initially, the variables have these indexes:   f 0@(X x y) 1@(Y z) = term The first case will be on 0%, and the variables bound inside the X H pattern will replace the outer index, so we get something like this:  ' f 0 2@(Y z) = case 0 of X 0 1 -> term  Notice how (Y z) now has index 2. 9 Then the second pattern is desugared in the same way:  2 f 0 2 = case 0 of X 0 1 -> case 2 of Y 2 -> term ?This replacement is what is done using the replaceAt function. LCompiledClauses also have default branches for when all branches fail (even G inner branches), the catchAllBranch. Epic does not support this, so M we have to add the catchAllBranch to each inner case (here we are calling I it omniDefault). To avoid code duplication it is first bound by a let  expression. PTranslate the actual Agda terms, with an environment of all the bound variables N from patternmatching. Agda terms are in de Bruijn so we just check the new  names in the position. .Translate Agda literals to our AUX definition &Number of arguments in the definition None8Check that the main function has type IO a, for some a. None(4withExprClauses cl t as& generates a clause containing a fake  call to with-expression a for each a in as that is not : a variable (and thus cannot contain a recursive call). Andreas, 2013-11-11: I guess not a variable could be generalized  to 4not containing a call to a mutually defined function. Note that the as) stem from the *unraised* clause body of cl  and thus can be simply ped back there (under all the  +  abstractions). Precondition: we are {. (5inlinedClauses f cl t wf& inlines the clauses of with-function wf  of type t into the clause cl!. The original function name is f. Precondition: we are {. (6The actual work horse.  inline f pcl t wf wcl inlines with-clause wcl of with-function wf  (of type t) into parent clause pcl (original function being f). (4(5(6(7(4(5(6(7NoneSize constraints we can solve.  Leq a +n b represents a =< b + n.   Leq a -n b represents a + n =< b. Atomic size expressions. A de Bruijn level. )A size meta applied to de Bruijn levels. ICheck whether a variable in the context is bounded by a size expression.  If x : Size< a, then a is returned. 9Whenever we create a bounded size meta, add a constraint  expressing the bound.  In boundedSizeMetaHook v tel a, tel includes the current context. #trySizeUniv cmp t m n x els1 y els2 7 is called as a last resort when conversion checking m cmp n : t  failed for definitions  m = x els1 and  n = y els2,  where the heads x and y are not equal.  trySizeUniv1 accounts for subtyping between SIZELT and SIZE,  like Size< i =< Size. ?If it does not succeed it reports failure of conversion check. &Compute the deep size view of a term. * Precondition: sized types are enabled. Compare two sizes. Compare two sizes in max view. compareBelowMax u vs checks u  = max vs@. Precondition: @size vs= 2 3Checked whether a size constraint is trivial (like X <= X+1). :Test whether a problem consists only of size constraints. )Test is a constraint speaks about sizes. Find the size constraints. /Return a list of size metas and their context. DCompute a set of size constraints that all live in the same context G from constraints over terms of type size that may live in different  contexts. cf.  @Turn a constraint over de Bruijn levels into a size constraint. FTurn a term with de Bruijn levels into a size expression with offset.  Throws a c if the term isn't a proper size expression. 8Compute list of size metavariables with their arguments  appearing in a constraint. =Convert size constraint into form where each meta is applied  to levels  0,1,..,n-1 where n is the arity of that meta. X[] <= t beomes X[id] <= t[^-1]  X[] "d Y[] becomes X[id] "d Y[[^-1]] or X[[^1]] "d Y[id] : whichever is defined. If none is defined, we give up.  Main function.  &Old solver for size constraints using .   Size metas and their arity. )Size constraints (in preprocessed form). Returns False if solver fails. (8(9      (8(9None)(:>Remove all non-coinductive projections from an algebraic term  (not going under binders).  Also, remove  `s. (;*Extract recursive calls from expressions.  -The result of termination checking a module.  Must be ) and a . (<.Call graph with call info for composed calls.  (Termination check a single declaration. (=.Termination check a sequence of declarations. (>'Termination check a single declaration ! (without necessarily ignoring abstract). (?Termination check a module. (@GTermination check a bunch of mutually inductive recursive definitions. (A termMutual'/ checks all names of the current mutual block,  henceforth called allNames, for termination. allNames is taken from Internal syntax, it contains also G the definitions created by the type checker (e.g., with-functions). (B reportCalls for debug printing. 1Replays the call graph completion for debugging. (CtermFunction name checks name for termination. (DTo process the target type. (E4Termination check a definition by pattern matching. (F3Mask arguments and result for termination checking " according to type of function.  Only arguments of data/record type are counted in. (G1Is the current target type among the given ones? (H;Convert a term (from a dot pattern) to a DeBruijn pattern. (I4Masks coconstructor patterns in a deBruijn pattern. (JMasks all non-data/%record type patterns if --without-K. (Kcf.  (L)Extract recursive calls from one clause. (MRewrite a clause  f ps =tel=   {xs} -> v to f ps {xs} =(tel {xs})= v. F The pupose is to move hidden bounded size quantifications {j : Size< i} F to the lhs such that the termination checker can make use of them. (N8Extract recursive calls from a constructor application. (O0Handle guardedness preserving type constructor. (P.Extract calls from with function application. (QHandles function applications g es. (R Rewrite type  tel -> Size u@ to @tel - Size. (S compareArgs es5Compare the list of de Bruijn patterns (=parameters) pats  with a list of arguments es and create a call maxtrix ( with |es| rows and |pats| columns. 8The guardedness is the number of projection patterns in pats ( minus the number of projections in es. (T&Traverse patterns from left to right. ) When we come to a projection pattern, ' switch usage of SIZELT constraints:  on, if coinductive,  off, if inductive. UNUSED (U compareElim e dbpat(VBIn dependent records, the types of later fields may depend on the D values of earlier fields. Thus when defining an inhabitant of a ! dependent record type such as (W(W turns the result of (S into a proper call matrix (X(X7 adds guardedness flag in the upper left corner (0,0). (Y>Compose something with the upper-left corner of a call matrix (ZBStripping off a record constructor is not counted as decrease, in # contrast to a data constructor. ! A record constructor increases/)decreases by 0, a data constructor by 1. ([Compute the sub patterns of a . (\  compareTerm' t dbpat)Precondition: top meta variable resolved (]Compare two variables. AThe first variable comes from a term, the second from a pattern. (^%Extract recursive calls from a term. (_%Extract recursive calls from a type. (`*Sorts can contain arbitrary terms of type Level, . so look for recursive calls also in sorts.  Ideally,  E( would not be its own datatype but just  a subgrammar of  ^+, then we would not need this boilerplate. =(:(a(;(b (< (=(>(?(@(A(c(B(C(D(E(F(G(H(I(J(K(L(d(M(NConstructor name. ?Should the constructor be treated as inductive or coinductive? All the arguments, - and for every argument a boolean which is ! iff the 8 argument should be viewed as preserving guardedness. (O(P(Q(R(S(T(U(V(W(X(Y(Z([(e(\(f(g(h(](i(j(k(l(m(n(^(_(`(o(p(q(r(s(t    ;(:(a(;(b (< (=(>(?(@(A(c(B(C(D(E(F(G(H(I(J(K(L(d(M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(e(\(f(g(h(](i(j(k(l(m(n(^(_(`(o(p(q(r(s(tNone(uRecord pattern trees. (v RecCon t args. stands for a record constructor application:  t9 is the type of the application, and the list contains a 4 projection function and a tree for every argument. (w7Corresponds to variable and dot patterns; contains the  original pattern. (x p5 means that a variable (corresponding to the pattern  p7, a variable or dot pattern) should be kept unchanged.   (n, x, t) means that n (y variables, and n (z dot @ patterns, should be removed, and a new variable, with the name x, 3 inserted instead. The type of the new variable is t. ({VarPat# stands for variable patterns, and DotPat for dot  patterns. (|+A monad used to translate record patterns. ?The state records the number of variables produced so far, the E reader records the total number of variables produced by the entire A computation. Functions using this monad need to be sufficiently  lazy in the reader component. (} dropFrom i n drops arguments j with j  i + n@ and @j= i.  NOTE: n8 can be negative, in which case arguments are inserted. (~5Split tree annotated for record pattern translation. (Split tree annotation. ("Constructor name for this branch. (Arity of the constructor. (%Should we translate this split away?  Take a record pattern p! and yield a list of projections ? corresponding to the pattern variables, from left to right.  E.g. for  (x , (y , z)) we return [ fst, fst . snd, snd . snd ]. %If it is not a record pattern, error  O is raised. (HTake a matrix of booleans (at least one row!) and summarize the columns  using conjunction. (insertColumn i a m inserts a column before the i th column in  matrix m and fills it with value a. (cutSublist i n xs = (xs', ys, xs'') cuts out a sublist ys  of width n from xs, starting at column i. (replaceByProjections i projs cc replaces variables i..i+n-1 & (counted from left) by projections projs_1 i .. projs_n i. If n==06, we matched on a zero-field record, which means that > we are actually introduce a new variable, increasing split ! positions greater or equal to i by one.  Otherwise, we have to lower (HCheck if a split is on a record constructor, and return the projections  if yes. (,Bottom-up procedure to annotate split tree. <Bottom-up procedure to record-pattern-translate split tree. >Replaces pattern matching on record constructors with uses of C projection functions. Does not remove record constructor patterns > which have sub-patterns containing non-record constructor or  literal patterns. BIf the input clause contains dot patterns inside record patterns, D then the translation may yield clauses which are not type-correct. C However, we believe that it is safe to use the output as input to   . Perhaps A it would be better to perform record pattern translation on the ? compiled clauses instead, but the code below has already been  implemented and seems to work. (Runs a computation in the (| monad. (?Returns the next pattern variable, and the corresponding term. ( projections t- returns a projection for every non-dot leaf  pattern in t0. The term is the composition of the projection & functions from the leaf to the root. BEvery term is tagged with its origin: a variable pattern or a dot  pattern. (BConverts a record tree to a single pattern along with information & about the deleted pattern variables. (+Removes record constructors from patterns. Returns the following things:  The new pattern.  A substitution which maps the old pattern variables (in the C order they occurred in the pattern; not including dot patterns) B to terms (either the new name of the variable, or a projection ' applied to a new pattern variable). = A list explaining the changes to the variables bound in the  pattern. CRecord patterns containing non-record constructor patterns are not 0 translated (though their sub-patterns may be). Example: The pattern !rec1 (con1 a) (rec2 b c) (rec3 d) should  yield the pattern rec1 (con1 x) y z, along with a substitution  similar to #[x, proj2-1 y, proj2-2 y, proj3-1 z]. >This function assumes that literals are never of record type. (3Traverses a pattern and returns one of two things: < If there is no non-record constructor in the pattern, then   ps is returned, where ps contains one projection for > every variable in the input pattern (in the order they are  encountered). B Otherwise the output is a computation returning the same kind of  result as that coming from (. (Computations are C returned rather than values to ensure that variable numbers are " allocated in the right order.) 0Assumes that literals are never of record type. (Translates the telescope. (@Translates the clause body. The substitution should take things - in the context of the old RHS to the new RHS' s context. ()Turns a permutation into a substitution. ( dropBinds n b drops the initial n occurrences of  + from b. Precondition: b has to start with n occurrences of  +. *(u(v(w(x({(z(y(|((}(((~((((( ((((((((((((((:Explanation of how the telescope should be changed. Types 0 should be in the context of the old telescope. 3Old telescope, flattened, in textual left-to-right  order. :New telescope, flattened, in textual left-to-right order.  4 is used to indicate the locations of dot patterns. ((((((  (u(w(v(x({(y(z(|((}(((~((((( ((((((((((((((((((((NonematchCompiledE c es% takes a function given by case tree c and  and a spine es$ and tries to apply the function to es. (A stack entry is a triple consisting of 6 1. the part of the case tree to continue matching, ' 2. the current argument vector, and ? 3. a patch function taking the current argument vector back ' to the original argument vector. match'- tries to solve the matching problems on the Stack. > In each iteration, the top problem is removed and handled. If the top problem was a Done, we succeed. If the top problem was a Case n and the nth argument of the problem > is not a constructor or literal, we are stuck, thus, fail. 'If we have a branch for the constructor/ literal, we put it on the stack  to continue. J If we do not have a branch, we fall through to the next problem, which 1 should be the corresponding catch-all branch. EAn empty stack is an exception that can come only from an incomplete  function definition. NoneLinitializeIFSMeta s t$ generates an instance meta of type t  with suggested name s. CA candidate solution for an instance meta is a term with its type. 'Compute a list of instance candidates.  2 if type is a meta, error if type is not eligible  for instance search. findInScope m (v,a)s& tries to instantiate on of the types as  of the candidate terms vs to the type t of the metavariable m.  If successful, meta m% is solved with the instantiation of v. I If unsuccessful, the constraint is regenerated, with possibly reduced  candidate set. & The list of candidates is equal to Nothing when the type of the meta  wasn'Et known when the constraint was generated. In that case, try to find  its type again. EResult says whether we need to add constraint, and if so, the set of  remaining candidates. IA meta _M is rigidly constrained if there is a constraint _M us == D vs, J for inert D. Such metas can safely be instantiated by recursive instance 9 search, since the constraint limits the solution space.  Given a meta m of type t and a list of candidates cands,  checkCandidates m t cands- returns a refined list of valid candidates. CTo preserve the invariant that a constructor is not applied to its B parameter arguments, we explicitly check whether function term < we are applying to arguments is a unapplied constructor. " In this case we drop the first   arguments.  See Issue670a. D Andreas, 2013-11-07 Also do this for projections, see Issue670b. L L L LwNone"Don'1t allow the argument to produce any constraints. 8Catches pattern violation errors and adds a constraint. -Create a fresh problem for the given action. "guardConstraint c blocker tries to solve blocker first. ; If successful without constraints, it moves on to solve c, otherwise it  adds a  Guarded c cs constraint  to the blocker-generated constraints cs. $5Wake up the constraints depending on the given meta. %Wake up all constraints. !"#$% !"#$%&'(!"#$% !"#$%&'(%" !!"#$%&#$'(!"#$% !"#$%&'(None*%all prescribed kills where performed +&managed to kill some args in the list ,1there is no possible kill (because of type dep.) -the kill list is empty or only Falses .Extended occurs check. 1?Distinguish relevant and irrelevant variables in occurs check. 6!we are in an irrelevant argument 7)we are at the term root (this turns into  StronglyRigid) 89we are at the start or in the arguments of a constructor 92we are not in arguments of a meta but a bound var :we are in arguments of a meta <-Set the names of definitions to be looked at , to the defs in the current mutual block. =-Is a def in the list of stuff to be checked? >4Remove a def from the list of defs to be looked at. ALeave the top position. B#Leave the strongly rigid position. JWhen assigning  m xs := v , check that m does not occur in v " and that the free variables of v are contained in xs. Kprune m' vs xs' attempts to remove all arguments from vs whose ' free variables are not contained in xs.  If successful, m'3 is solved by the new, pruned meta variable and we  return True else False.  Issue 1147:  If any of the meta args vs, is matchable, e.g., is a constructor term, H we cannot prune, because the offending variables could be removed by @ reduction for a suitable instantiation of the meta variable. LhasBadRigid xs v = Just True# iff one of the rigid variables in v is not in xs. O Actually we can only prune if a bad variable is in the head. See issue 458. 2 Or in a non-eliminateable position (see succeed/PruningNonMillerPattern). hasBadRigid xs v = Nothing means that @ we cannot prune at all as one of the meta args is matchable.  (See issue 1147.) MCheck whether a term Def f es is finally stuck. 2 Currently, we give only a crude approximation. OkillArgs [k1,...,kn] X prunes argument i from metavar X if ki==True. @ Pruning is carried out whenever > 0 arguments can be pruned.  True4 is only returned if all arguments could be pruned. P&killedType [((x1,a1),k1)..((xn,an),kn)] b = ([k'1..k'n],t')  (ignoring Dom). Let t' = (xs:as) -> b.  Invariant: k' i == True iff  ki == True and pruning the ith argument from  type b1 is possible without creating unbound variables.  t' is type t after pruning all k'i==True. 8)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ((((((((((((((())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ);<=>5:9876243?@ABCDE1FGHI./0JKLMN)-,+*OPQ+)-,+*./012435:9876;<=>?@ABCDEFGHIJKLMNOPQ(((((((((((((((pNone)rAReturns every meta-variable occurrence in the given type, except  for those in  Es. u$Create a new metavariable, possibly vnewIFSMeta s t cands creates a new implicit from scope metavariable  of type the output type of t with name suggestion s and initial  solution candidates cands. If t( is a function type, then insert enough  lambdas in front of it. wMiller pattern unification:  assign x vs v solves problem x vs = v for meta x  if vs* are distinct variables (linearity check)  and v! depends only on these variables  and does not contain x itself (occurs check). :This is the basic story, but we have added some features:   Pruning. % 2. Benign cases of non-linearity.  3. vs may contain record patterns. 2For a reference to some of these extensions, read $ Andreas Abel and Brigitte Pientka's TLCA 2011 paper. x3Assign to an open metavar which may not be frozen. : First check that metavar args are in pattern fragment. 3 Then do extended occurs check on given thing. $Assignment is aborted by throwing a  PatternErr via a call to  patternViolation. This error is caught by catchConstraint  during equality checking ( compareAtom) and leads to , restoration of the original constraints. y!Do safe eta-expansions for meta (SingletonRecords,Levels). z)Performing the meta variable assignment. #The instantiation should not be an   or   and the  8  should point to something   or a  . ) Further, the meta variable may not be  . R8Exceptions raised when substitution cannot be inverted. S'Try to eta-expand var to remove projs. TA neutral arg: can't invert, but maybe prune. UCannot recover. [7Check whether one of the meta args is a projected var. ] Various kinds of metavariables. ^<Meta variables of level type, if type-in-type is activated. _Meta variables of "hereditarily singleton" record type. `Meta variables of record type. a$Find position of a value in a list. > Used to change metavar argument indices during assignment. reverseA is necessary because we are directly abstracting over the list. bDCheck whether a meta variable is a place holder for a blocked term. d9Skip frozen check. Used for eta expanding frozen metas. i4Create a new value meta with specific dependencies. k Create a new value meta without l4Create a new value meta with specific dependencies. pHCreate a metavariable of record type. This is actually one metavariable  for each field. s7Construct a blocked constant if there are constraints. vunblockedTester t returns False if t is a meta or a blocked term. @Auxiliary function to create a postponed type checking problem. w)Create a postponed type checking problem e : t that waits for type t A to unblock (become instantiated or its constraints resolved). x)Create a postponed type checking problem e : t that waits for conditon  unblock<. A new meta is created in the current context that has as : instantiation the postponed type checking problem. An   constraint 5 is added for this meta, which links to this meta. z8Eta expand metavariables listening on the current meta. {0Wake up a meta listener and let it do its thing |!All possible metavariable kinds. };Eta expand a metavariable, if it is of the specified kind.  Don'5t do anything if the metavariable is a blocked term. ~AEta expand blocking metavariables of record type, and reduce the  blocked thing. When faced with  _X us == D vs% for an inert D we can solve this by  _X xs := D _Ys with new constraints  _Yi us == vi. This is important K for instance arguments, where knowing the head D might enable progress. assignMeta m x t ids u solves  x ids = u for meta x of type t,  where term u lives in a context of length m.  Precondition: ids is linear.  assignMeta' m x t ids u solves x = [ids]u for meta x of type t,  where term u lives in a context of length m,  and ids is a partial substitution. Turn the assignment problem _X args < = SizeLt u into  _X args = SizeLt (_Y args) and constraint  _Y args <= u.  Eta-expand bound variables like z in  X (fst z). KEta-expand a de Bruijn index of record type in context and passed term(s). ATurn non-det substitution into proper substitution, if possible.  Otherwise, raise the error. Check that arguments args' to a metavar are in pattern fragment. : Assumes all arguments already in whnf and eta-reduced. ! Parameters are represented as Vars so  checkArgs really  checks that all args are Vars and returns the  substitution 6 to be applied to the rhs of the equation to solve.  (If args9 is considered a substitution, its inverse is returned.) (The returned list might not be ordered. ? Linearity, i.e., whether the substitution is deterministic, ! has to be checked separately. Used in . Hqrstuvwxyz{|RSTUVW*a possibly non-deterministic substitution XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(((((Cqrstuvwxyz{|RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Cabczdefghvitujklsqm{|nopqrstuvwxyz{y]`_^|}~xw[\YZXWVRUTSr@qrstuvwxyz{|RUTSVWXYZ[\]`_^abcdefghijklmnopqrstuvwxyz{|}~(((((tNoneLhighlightAsTypeChecked rPre r m runs m and returns its 4 result. Some code may additionally be highlighted:  If r% is non-empty and not a sub-range of rPre (after   has been applied to both): r is + highlighted as being type-checked while m is running (this  highlighting is removed if m completes  successfully). ( Otherwise: Highlighting is removed for rPre - r before m  runs, and if m completes successfully, then rPre - r is & highlighted as being type-checked. (=A function mapping names to the kind of name they stand for. Highlighting levels. 2Highlighting without disambiguation of overloaded  constructors. >Full highlighting. Should only be used after typechecking has  completed successfully. 6The list of termination problems is also highlighted. >Precondition: The termination problems must be located in the  module that is highlighted. 6Lispify and print the given highlighting information. 7Generate syntax highlighting information for the given 4 declaration, and (if appropriate) print it. If the    is  something, then the state is C additionally updated with the new highlighting info (in case of a 4 conflict new info takes precedence over old info). BThe procedure makes use of some of the token highlighting info in  4 (that corresponding to the interval covered by the  declaration). If the   is  something, @ then this token highlighting info is additionally removed from  . @Generate and return the syntax highlighting information for the  tokens in the given file. Same as + but takes a string instead of a filename. (2Compute syntax highlighting for the given tokens. ( Builds a ( function. (?Generates syntax highlighting information for all constructors A occurring in patterns and expressions in the given declaration. 9This function should only be called after type checking. D Constructors can be overloaded, and the overloading is resolved by  the type checker. .Prints syntax highlighting info for an error. BGenerates and prints syntax highlighting information for unsolved 2 meta-variables and certain unsolved constraints. <Generates syntax highlighting information for unsolved meta  variables. CGenerates syntax highlighting information for unsolved constraints , that are not connected to a meta variable. (9Generates a suitable file for a possibly ambiguous name. (Converts names to suitable  xs. ( A variant of ( for qualified abstract names. All the properties. L(The module to highlight. ((This should only be  something if 3 type-checking completed successfully (without any  errors). ((Maps source file paths to module names. The module to highlight. ((Maps source file paths to module names. The module to highlight. ((Maps source file paths to module names. .The file name of the current module. Used for  consistency checking. #The name qualifier (may be empty). The base name. 1Meta information to be associated with the name.  The argument is ! iff the name is an operator. 0The definition site of the name. The calculated 5 meta information is extended with this information,  if possible. ((Maps source file paths to module names. .The file name of the current module. Used for  consistency checking.  The name. 1Should the binding site be included in the file? 1Meta information to be associated with the name.  ^ The argument is ! iff the name is an operator. (((LLL((((((((((NoneNone-Instantiate full as long as things are equal (&Monad for checking syntactic equality $Syntactic equality check for terms.    checkSyntacticEquality v v' = do  (v,v') <- instantiateFull (v,v')  return ((v,v'), v==v')    only that v,v'* are only fully instantiated to the depth  where they are equal. (Return, flagging inequalty. (1If inequality is flagged, return, else continue. ("Syntactic equality ignores sorts. ( Syntactic term equality ignores  ` stuff. ((((((((((((((((((((((((((((((((((((((((NoneN0What is the polarity of a function composition? OMain function of this module. polarities i a4 computes the list of polarities of de Bruijn index i  in syntactic entity a. $Infimum on the information lattice.   a is bottom (dominant for inf),   ` is top (neutral for inf).  _+ negation, swapping monotone and antitone. #Get the next polarity from a list,  a if empty. Replace  ` by  a. BData and record parameters are used as phantom arguments all over 7 the test suite (and possibly in user developments).  enablePhantomTypes turns  ` parameters to  a  to enable phantoms. Make arguments  a if the type of a not- ` ! later argument depends on it. ;Check whether a variable is relevant in a type expression, . ignoring domains of non-variant arguments. 1Record information that an argument is unused in . Improve 0 information in a type by polarity information.   ` becomes .  Propagate  `  _ to  information in  s of a defined symbol. #Hack for polarity of size indices.  polarity i a* computes the polarity of de Bruijn index i  in syntactic entity a by taking the infimum of all . NO(((((((((((NONONO(((((((((((Nonebad named argument >hidden argument where there should have been a non-hidden arg (this many implicits have to be inserted implicitArgs n expand t generates up to n implicit arguments  metas (unbounded if n<0), as long as t is a function type  and expand) holds on the hiding info of its domain. implicitNamedArgs n expand t generates up to n named implicit arguments  metas (unbounded if n<0), as long as t is a function type  and expand2 holds on the hiding and name info of its domain. The list should be non-empty.   None3Produce a nice error message when splitting failed NoneIf matching is inconclusive (DontKnow) we want to know whether , it is due to a particular meta variable. matchCopatterns ps es matches spine es against copattern spine ps. Returns . and a substitution for the pattern variables  (in form of [Term]) if matching was successful. Returns 4 if there was a constructor or projection mismatch. Returns * if an argument could not be evaluated to 9 constructor form because of a blocking meta variable.  In any case, also returns spine es in reduced form D (with all the weak head reductions performed that were necessary  to come to a decision).  Instead of -#, we need to use this lazy version / of combining pattern matching computations. Match a single copattern. Match a single pattern. (  (None&Edge labels for the positivity graph. 3Pairing something with a node (for printing only). !Monad for computing occurrences. #Context for computing occurrences. +Items corresponding to the free variables. Name for " builtin. Description of an occurrence. *an unknown position (treated as negative)  in the definition of a constant 2matched against in a clause of a defined function (in the nth clause of a defined function %in a datatype index of a constructor in the type of a constructor !as an argument of a metavariable #as an argument to a bound variable (in the principal argument of built-in " )in the nth argument of a define constant BCheck that the datatypes in the mutual block containing the given ' declarations are strictly positive. AAlso add information about positivity and recursivity of records  to the signature. onlyVarsUpTo n occs) discards occurrences of de Bruijn index >= n. Running the monad /Compute the occurrences in a given definition. ;Eta expand a clause to have the given number of variables.  Warning: doesn'#t update telescope or permutation! 8 This is used instead of special treatment of lambdas " (which was unsound: issue 121)  Given an ! computes the target node and an  . The first = argument is the set of names in the current mutual block. (@These operations form a semiring if we quotient by the relation  "the  R components are equal". ( R* is a complete lattice with least element  X  and greatest element  S. &It forms a commutative semiring where  is meet (glb)  and 1 is composition. Both operations are idempotent. For ,  S is neutral (zero) and  X is dominant.  For ,  U is neutral (one) and  S is dominant. C((((((((((((((((((((((--- ((((((((((((((((((((((None IWhich Def.types are eligible for the principle argument " of a projection-like function? JCTurn a definition into a projection if it looks like a projection.  View for a Def f (Apply a : es) where isProjection f.  Used for projection-like fs. +Not a projection or projection-like thing. <Just a lone projection-like function, missing its principal 8 argument (from which we could infer the parameters). 9A projection or projection-like function, applied to its  principal argument  Semantics of .  Top-level  (no reduction). 1Reduce away top-level projection like functions. < (Also reduces projections, but they should not be there, B since Internal is in lambda- and projection-beta-normal form.) DTurn prefix projection-like function application into postfix ones. > This does just one layer, such that the top spine contains 1 the projection-like functions as projections.  Used in  compareElims in TypeChecking.Conversion  and in . If the  is !*, a lone projection like function will be G turned into a lambda-abstraction, expecting the principal argument.  If the  is !, it will be returned unaltered. No precondition. B Preserves constructorForm, since it really does only something 3 on (applications of) projection-like functions. IJ IJ IJIJNone*((((((((((((((((())))(((((((((((((((((())))NonebuildList A ts builds a list of type List A. Assumes that the terms  ts all have type A.  Conceptually: .redBind m f k = either (return . Left . f) k =<< m <Abbreviation: argN =  . >Abbreviation: argH =   . b      !"#$%&'()*+,-./0123456789:;<=>?@AB)))))) ) ) ) ) ))))))))))))))))))) )!)")#)$)%)&)')(=      !"#$%&'()*+,-./0123456789:;<=>?@AB=     !"#$%&'()*+,-./0123456789:;<=>? @ABV      !"#$%&'()*+,-./0123456789:;<=>?@AB)))))) ) ) ) ) ))))))))))))))))))) )!)")#)$)%)&)')(NoneH-Argument should be in weak head normal form. CDEFGHICDEFGHIFGHCEDICEDFGHINonep/Check that the first sort equal to the second. ucompareTel t1 t2 cmp tel1 tel1 checks whether pointwise  tel1 `cmp` tel2 and complains that t2 `cmp` t1 failed if  not. vEquality on Types wcompareElims pols a v els1 els27 performs type-directed equality on eliminator spines.  t is the type of the head v. x)Type-directed equality on argument lists y*Syntax directed equality on atomic values z"Type directed equality on values. JBTry whether a computation runs without errors or new constraints.  Restores state upon failure. KACheck if to lists of arguments are the same (and all variables). 1 Precondition: the lists have the same length. LintersectVars us vs) checks whether all relevant elements in us and vs > are variables, and if yes, returns a prune list which says True for 4 arguments which are different and can be pruned. N%Ignore errors in irrelevant context. P=Try to assign meta. If meta is projected, try to eta-expand # and run conversion check again. SRaise  G if there is no hope that by 5 meta solving and subsequent eta-contraction these  terms could become equal. / Precondition: the terms are in reduced form # (with no top-level pointer) and  failed to be equal in the y check. :By eta-contraction, a lambda or a record constructor term  can become anything. VCompare: two terms in irrelevant position. This always succeeds. @ However, we can dig for solutions of irrelevant metas in the  terms we compare. / (Certainly not the systematic solution, that'd be proof search...) X coerce v a b coerces v : a to type b, returning a v' : b @ with maybe extra hidden applications or hidden abstractions. =In principle, this function can host coercive subtyping, but G currently it only tries to fix problems with hidden function types. Z:Check that the first sort is less or equal to the second. opqrstuvwxyzJKLMNOPQRSTUVWXYZ[\] opqrstuvwxyzJKLMNOPQRSTUVWXYZ[\] JKLrMqNzOPQRuSTyUwVWxvoXYstZ[\p] opqrstuvwxyzJKLMNOPQRSTUVWXYZ[\]None!^DViews an expression (pair) as type shape. Fails if not same shape. _(not a type or not definitely same shape ` some meta bbuilt-in type c neutral type ddata/record g substHH u t substitutes u for the 0th variable in t. qKAre we in a homogeneous (one type) or heterogeneous (two types) situation? rheterogeneous s homogeneous xNApply the current substitution on a term and reduce to weak head normal form. ]Were two terms unifiable or did we have to postpone some equation such that we are not sure? 9Unification did not fail, but we had to postpone a part. Unification succeeded. 5Output the result of unification (success or maybe). 4Tell that something could not be unified right now, $ so the unification succeeds only . :Check whether unification proceeded without postponement. Throw-away error message. 2Force equality now instead of postponing it using . DTry equality. If constraints remain, postpone (enter unsafe mode). < Heterogeneous equalities cannot be tried nor reawakened, & so we can throw them away and flag dirty. =Check whether heterogeneous situation is really homogeneous.  If not, give up. =Check whether heterogeneous situation is really homogeneous.  If not, return Nothing. EIncludes flexible occurrences, metas need to be solved. TODO: relax? 8 TODO: later solutions may remove flexible occurences (Assignment with preceding occurs check. JTake a substitution  and ensure that no variables from the domain appear > in the targets. The context of the targets is not changed. F TODO: can this be expressed using makeSubstitution and applySubst? Unify indices. In unifyIndices_ flex a us vs, a is the type eliminated by us and vs ) (usally the type of a constructor),  need not be reduced, us and vs" are the argument lists to unify, flex3 is the set of flexible (instantiable) variabes in us and vs. *The result is the most general unifier of us and vs. >Given the type of a constructor application the corresponding D data or record type, applied to its parameters (extracted from the  given type), is returned. BPrecondition: The type has to correspond to an application of the  given constructor. Heterogeneous situation.  a1 and a2 need to end in same datatype/record. <Return record type identifier if argument is a record type. BReturn the type and its shape. Expects input in (u)reduced form. 1Return the reduced type(s) and the common shape. telViewUpToHH n t takes off the first n function types of t.  Takes off all if $n < 0$. ))Conjunctive monoid. w^_`abcdefghijklmnopqrstuvwxyz{|}~Constructor name. 1Type of constructor application (must end in data/ record). &Type of constructor, applied to pars. Constructor name. 1Type of constructor application (must end in data/ record).  Name of data/ record type, & type of constructor to be applied,  data/record parameters, and  data indices Constructor name. 9Type(s) of constructor application (must end in same data/ record). JType of constructor, instantiated possibly heterogeneously to parameters. )*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)))@)A)B)C\^_`abcdefghijklmnopqrstuvwxyz{|}~\~z{|}xytwvuqsrponmljkghi^fedcba`_W^fedcba`_ghijklmnopqsrtwvuxyz{|}~)*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)))@)A)B)CNone+Returns how many parameters a datatype has +Returns how many parameters a datatype has insertTele i xs t tele  tpos % tele := Gamma ; (i : T as) ; Delta  n := parameters T  xs' := xs  (take n as) becomes  tpos  ( Gamma ; xs' ; Delta[i := t]3 --note that Delta still reference Gamma correctly  , T as ^ (size xs')  ) (we raise the type since we have added xs'' new bindings before Gamma, and as can only bind to Gamma. @Main function for removing pattern matching on forced variables NFor a given expression, in a certain telescope (the list of Var) is a mapping $ of variable name to the telescope. >replace the forcedVar with pattern matching from the outside. HGiven a term containg the forced var, dig out the variable by inserting  the proper case-expressions. RFind the location where a certain Variable index is by searching the constructors T aswell. i.e find a term that can be transformed into a pattern that contains the @ same value the index. This fails if no such term is present. ABS pos in tele 0If Just, it is the type to insert patterns from 3 is nothing if we only want to delete a binding. Term to replace at pos The telescope tele where everything is at    None0Entry point for e.g. checking WithFunctionType. Entry point for term checking. )DinferSpine t self es checks that spine es eliminates  value self of type t and returns the remaining type  (target of elimination). )E;Type should either be a record type of a type eligible for 8 the principal argument of projection-like functions. )FCheck if sort is well-formed. )GCheck if level is well-formed. )HType of a term or sort meta. )IEUniverse subsumption and type equality (subtyping for sizes, resp.). )J)K)L)M)N)O)D)E)P)Q)R)F)G)H)I)J)K)L)M)N)O)D)E)P)Q)R)F)G)H)INone:Split a problem at the first constructor pattern which is  actually of datatype type. >Or, if there is no constructor pattern left and the rest type ? is a record type and the first rest pattern is a projection ! pattern, split the rest type. -Implicit patterns should have been inserted. checkParsIfUnambiguous [c] d pars checks that the data/ record type  behind cE is has initial parameters (coming e.g. from a module instantiation) # that coincide with an prefix of pars. ?Takes a type, which must be a data or record type application, D and checks that the indices are constructors (or literals) applied B to distinct variables which do not occur free in the parameters. @ For the purposes of this check parameters count as constructor > arguments; parameters are reconstructed from the given type. BPrecondition: The type must be a data or record type application. args ` withTypesFrom` t returns the arguments args paired up  with their types, taken from t, which is assumed to be a length  args -ary pi. Precondition: t has to start with  length args pis. .The definition we are checking at the moment. 'The current state of the lhs patterns. NoneIType check a datatype definition. Assumes that the type has already been  checked. :A parameter is small if its sort fits into the data sort.   smallParams: overapproximates the small parameters (in doubt: small). JType check a constructor declaration. Checks that the constructor targets ; the datatype and that it fits inside the declared sort. & Returns the non-linear parameters. #Bind the parameters of a datatype. PCheck that the arguments to a constructor fits inside the sort of the datatype. 6 The first argument is the type of the constructor. <Return the parameters that share variables with the indices / nonLinearParameters :: Int -> Type -> TCM [Int]  nonLinearParameters nPars t = HCheck that a type constructs something of the given datatype. The first 9 argument is the number of parameters to the datatype. DAs a side effect, return the parameters that occur free in indices.  E.g. in 9data Eq (A : Set)(a : A) : A -> Set where refl : Eq A a a  this would include parameter a , but not A. TODO: what if there's a meta here? !Is the type coinductive? Returns  if the answer cannot  be determined. None(Size constraint with de Bruijn indices. (Size expression with de Bruijn indices.  Size metas in size expressions. !Identifiers for rigid variables. %Name for printing in debug messages. De Bruijn index. -Solve size constraints involving hypotheses. JCollect constraints from a typing context, looking for SIZELT hypotheses. =Convert size constraint into form where each meta is applied  to indices  0,1,..,n-1 where n is the arity of that meta. X[] <= t beomes X[id] <= t[^-1]  X[] "d Y[] becomes X[id] "d Y[[^-1]] or X[[^1]] "d Y[id] : whichever is defined. If none is defined, we give up. ATurn a constraint over de Bruijn indices into a size constraint. $Turn a term into a size expression. Returns  if the term isn't a proper size expression. 'Turn a de size expression into a term. )S%Assumes we are in the right context. )T Only for . )U+An order which ignores the meta arguments. )V.An equality which ignores the meta arguments. %)W)X)S)Y)T)Z)[)U)V)\)])^)_)W)X)S)Y)T)Z)[)U)V)\)])^)_None'Insert implicit patterns in a problem. /Eta-expand implicit pattern if of record type. $Try to eta-expand implicit pattern.  Returns : unless dealing with a record type that has eta-expansion  and a constructor c. In this case, it returns    c _ _ ... _ R (record constructor applied to as many implicit patterns as there are fields). 0Insert implicit patterns in a list of patterns. NoneGCompute the clauses for the with-function given the original patterns. @Construct the display form for a with function. It will display O applications of the with function as applications to the original function.  For instance,  aux a b c as f (suc a) (suc b) | c n" is the number of with arguments. The name of parent function. The name of the with-function. :The arguments of the with function before the with exprs. 9The arguments of the with function after the with exprs.  The number of with expressions. The parent patterns. 4Permutation to split into needed and unneeded vars. 9Permutation reordering the variables in parent patterns. NoneIRename the variables in a telescope using the names from a given pattern *Are there any untyped user patterns left? =Try to move patterns from the problem rest into the problem. I Possible if type of problem rest has been updated to a function type. The user patterns. &The type the user patterns eliminate. 8The initial problem constructed from the user patterns. None + : The patterns in form of a substitution Names for the variables in !The patterns in internal syntax. The type of the body. Is b@ if  JCompute the set of flexible patterns in a list of patterns. The result is N the deBruijn indices of the flexible patterns. A pattern is flexible if it  is dotted or implicit.  (Compute the dot pattern instantiations.  JCheck if a problem is solved. That is, if the patterns are all variables. .For each user-defined pattern variable in the g, check > that the corresponding data type (if any) does not contain a < constructor of the same name (which is not in scope); this  " shadowing". could indicate an error, and is not allowed. ,Precondition: The problem has to be solved. #Check that a dot pattern matches it's instantiation. JBind the variables in a left hand side. Precondition: the patterns should  all be  y,  v,  s, or  q and the < telescope should have the same size as the pattern list.  There could also be  x.s resulting from eta expanded implicit record  patterns. Bind as patterns Check a LHS. Main function. checkLeftHandSide a ps a ret checks that user patterns ps eliminate  the type a1 of the defined function, and calls continuation ret  if successful.       Trace, e.g., CheckPatternShadowing clause  Trace, e.g. CheckPatternShadowing clause ,The name of the definition we are checking. The patterns. Continuation.                 NoneA Covering is the result of splitting a . )De Bruijn level of argument we split on. >Covering clauses, indexed by constructor these clauses share. Type of variables in scPats. @How to get from the variables in the patterns to the telescope. KThe patterns leading to the currently considered branch of the split tree. Substitution from scTel to old context. The type of the rhs.  -Project the split clauses out of a covering. !8Create a split clause from a clause in internal syntax. "6Old top-level function for checking pattern coverage.  DEPRECATED #2Top-level function for checking pattern coverage. $=cover f cs (SClause _ _ ps _) = return (splitTree, used, pss). # checks that the list of clauses cs covers the given split clause.  Returns the  splitTree, the used clauses, and missing cases pss. &@Check that a type is a non-irrelevant datatype or a record with  named constructor. Unless the  argument is  " the data type must be inductive. ':update the target type, add more patterns to split clause $ if target becomes a function type. ( >computeNeighbourhood delta1 delta2 perm d pars ixs hix hps con , delta1 Telescope before split point 7 n Name of pattern variable at split point + delta2 Telescope after split point , d Name of datatype to split at $ pars Data type parameters ! ixs Data type indices ' hix Index of split variable 1 hps Patterns with hole at split point , con Constructor to fit into hole    dtype == d pars ixs )Entry point from Interaction.MakeCase. *Entry point from TypeChecking.Empty and Interaction.BasicOps. +$split ind splitClause x = return res  splits  splitClause at pattern var x (de Bruijn index). Possible results res are:  Left err:  Splitting failed.  Right covering: G A covering set of split clauses, one for each valid constructor. ? This could be the empty set (denoting an absurd clause). ,GConvert a de Bruijn index relative to a telescope to a de Buijn level. J The result should be the argument (counted from left, starting with 0) ) to split at (dot patterns included!). -split' ind splitClause x = return res  splits  splitClause at pattern var x (de Bruijn index). Possible results res are:  Left err:  Splitting failed.  Right (Left splitClause'):  Absurd clause (type of x has 0 valid constructors).  Right (Right covering): G A covering set of split clauses, one for each valid constructor. . splitResult f sc = return resIf the target type of sc% is a record type, a covering set of  split clauses is returned (sc- extended by all valid projection patterns),  otherwise res == Nothing. U Note that the empty set of split clauses is returned if the record has no fields.  !"#$%&'( Telescope before split point. )Name of pattern variable at split point. Telescope after split point. Name of datatype to split at. Data type parameters. Data type indices. Index of split variable. #Patterns with hole at split point. Constructor to fit into hole.  New split clause if successful. )*+9Coinductive constructors are allowed if this argument is  . ,-9Coinductive constructors are allowed if this argument is  . . !"#$%&'()*+,-. !"#$%&'()*+,-. !"#$%&'()*+,-.NoneK)Process function clauses into case tree.  This involves: 2 1. Coverage checking, generating a split tree. F 2. Translation of lhs record patterns into rhs uses of projection.  Update the split tree. 2 3. Generating a case tree from the split tree. # Phases 1. and 2. are skipped if Nothing. 38Get the index of the next argument we need to split on. O This the number of the first pattern that does a match in the first clause. 4Is this a variable pattern? 5splitOn single n cs$ will force expansion of catch-alls  if single. 75Expand catch-alls that appear before actual matches.  Example:    true y  x false  false y will expand the catch-all x to false. 'Catch-alls need also to be expanded if  they come before/.after a record pattern, otherwise we get into < trouble when we want to eliminate splits on records later. K>Translate record patterns and coverage check with given type? /012345678 K/012345678 K0/12345678 K/012345678NoneICheck whether a type is empty. Maybe postponed as emptyness constraint. NoneEcheckArguments' exph r args t0 t k tries checkArguments exph args t0 t.  If it succeeds, it continues k* with the returned results. If it fails, M it registers a postponed typechecking problem and returns the resulting new  meta variable. Checks e := ((_ : t0) args) : t. FCheck a list of arguments: checkArgs args t0 t1 checks that  t0 = Delta -> t0' and  args : Delta. Inserts hidden arguments to 6 make this happen. Returns the evaluated arguments vs, the remaining  type t0' (which should be a subtype of t1) and any constraints cs < that have to be solved for everything to be well-formed. GType check an expression. H=Check that an expression is a type without knowing the sort. >$Check that an expression is a type. ?CCheck that an expression is a type which is equal to a given type. AFType check a telescope. Binds the variables defined by the telescope. BHCheck a typed binding and extends the context with the bound variables. N The telescope passed to the continuation is valid in the original context. CHCheck a typed binding and extends the context with the bound variables. N The telescope passed to the continuation is valid in the original context. IParametrized by a flag wether we check a typed lambda or a Pi. This flag  is needed for irrelevance. E Type check a lambda expression. FcheckAbsurdLambda i h e t# checks absurd lambda against type t.  Precondition: e = AbsurdLam i h G%checkExtendedLambda i di qname cs e t check pattern matching lambda.  Precondition: e = ExtendedLam i di qname cs HcheckRecordExpression fs e t) checks record construction against type t.  Precondition  e = Rec _ fs. I#checkRecordUpdate ei recexpr fs e t  Precondition e = RecUpdate ei recexpr fs. KcheckApplication hd args e t checks an application.  Precondition: Application hs args = appView e checkApplication disambiguates constructors  (and continues to R) " and resolves pattern synonyms. LATurn a domain-free binding (e.g. lambda) into a domain-full one, 4 by inserting an underscore for the missing type. OType check a meta variable. V If its type is not given, we return its type, or a fresh one, if it is a new meta. V If its type is given, we check that the meta has this type, and we return the same  type. PLInfer the type of a head thing (variable, function symbol, or constructor). < We return a function that applies the head to arguments. L This is because in case of a constructor we want to drop the parameters. RACheck the type of a constructor application. This is easier than F a general application since the implicit arguments can be inserted 8 without looking at the arguments to the constructor. S checkHeadApplication e t hd args checks that e has type t,  assuming that e has the form hd args. The corresponding  type-checked term is returned. If the head term hd& is a coinductive constructor, then a  top-level definition fresh tel = hd args (where the clause is  delayed) is added, where tel corresponds to the current ! telescope. The returned term is  fresh tel. Precondition: The head hd) has to be unambiguous, and there should + not be any need to insert hidden lambdas. U1Check that a list of arguments fits a telescope. VHInfer the type of an expression. Implemented by checking against a meta L variable. Except for neutrals, for them a polymorphic type is inferred. XUsed to check aliases f = e.  Switches off  , for the checking of top-level application. Y:Infer the type of an expression, and if it is of the form   {tel} -> D vs for some datatype D then insert the hidden 6 arguments. Otherwise, leave the type polymorphic. ,EFGH9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[)`)a)b)c)d'EFGH9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ['>H?@AB;=<CDEFGHIJEGKLMNOPQRSTFUVWXYZ[9:)EFGH9:;=<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[)`)a)b)c)dNone\ 'checkRecDef i name con ps contel fields name Record type identifier. con& Maybe constructor name and info. ps Record parameters. contel# Approximate type of constructor (fields -> Set). 5 Does not include record parameters. fields List of field signatures. ](checkRecordProjections m r q tel ftel fs. m  name of the generated module r  name of the record type con ! name of the record constructor tel $ parameters and record variable r (self) ftel  telescope of fields fs  the fields to be checked \Position and other info. Record type identifier. %Optional: (co)inductive declaration. Optional: constructor name. Record parameters. !Approximate type of constructor (fields -> Set). ' Does not include record parameters. Field signatures. ]\]\]\]None-Type check a definition by pattern matching. ^Parameters for creating a with -function. `parent function name awith function name barguments to parent function c;arguments to the with function before the with expressions d:arguments to the with function after the with expressions ewith expressions ftypes of the with expressions gtype of the right hand side hparent patterns iQpermutation resulting from splitting the telescope into needed and unneeded vars j;permutation reordering the variables in the parent pattern k@final permutation (including permutation for the parent clause) l(the given clauses for the with function nJA single clause without arguments and without type signature is an alias. o'Check a trivial definition of the form f = e pAInsert some patterns in the in with-clauses LHS of the given RHS qType check a function clause. sIType check a where clause. The first argument is the number of variables  bound in the left hand side. t=Check if a pattern contains an absurd pattern. For instance, suc () (the type we expect the function to have  is it irrelevant (for instance) 3are the clauses delayed (not unfolded willy-nilly) 1does the definition come from an extended lambda @ (if so, we need to know some stuff about lambda-lifted args) "is it a with function (if so, what'#s the name of the parent function)  range info the name of the function the clauses to check ^_`abcdefghijklmnopqrst^_`abcdefghijklmnopqrstnop^m_`abcdefghijklqrst ^m_`abcdefghijklnopqrstNoneu rewrite t" tries to rewrite a reduced term. {t. |t'. }core. &Append rewrite rules to a definition.  Lens for  . rewriteWith t v rew  tries to rewrite v : t with rew&, returning the reduct if successful. uvwxyz{|}~uvwxyz{|}~vwxyz{|}~uuvwxyz{|}~NonebindPostulatedName builtin e m checks that e is a postulated  name q, and binds the builtin builtin to the term m q def,  where def is the current  m of q. 'Bind a builtin thing to an expression. )e)f)g)h)i)e)f)g)h)iNone@Check an application of a section (top-level function, includes )). !Type check a single declaration. 'Type check a sequence of declarations. Instantiate all metas in  m associated to F). -- Makes sense after freezing metas. 8 Some checks, like free variable analysis, are not in /O, -- so they will be more precise (see issue 1099) after meta instantiation. > -- Precondition: name has been added to signature already. ITermination check a declaration and return a list of termination errors. ,Check a set of mutual names for positivity. ;Check that all coinductive records are actually recursive. E (Otherwise, one can implement invalid recursion schemes just like  for the old coinduction.) 8Check a set of mutual names for constructor-headedness. 5Check a set of mutual names for projection likeness. Type check an axiom. -Type check a primitive function declaration. Check a pragma. >Type check a bunch of mutual inductive recursive definitions. DAll definitions which have so far been assigned to the given mutual  block are returned. GType check the type signature of an inductive or recursive definition. Type check a module.  Helper for . 9Matches the arguments of the module application with the  module parameters. >Returns the remaining module parameters as an open telescope. & Warning: the returned telescope is not the final result, = an actual instantiation of the parameters does not occur. #Check an application of a section. 0Type check an import declaration. Actually doesn't do anything, since all ) the work is done when scope checking. Name m1( of module defined by the module macro. $Imported names (given as renaming). &Imported modules (given as renaming). Name of applied module. The module parameters. )The arguments this module is applied to. ?The remaining module parameters (has free de Bruijn indices!). Name m1( of module defined by the module macro. $Imported names (given as renaming). &Imported modules (given as renaming). NoneGVVGnNone o>Scope checks the given module. A proper version of the module 3 name (with correct definition sites) is returned. 1Merge an interface into the current proof state. @If the module has already been visited (without warnings), then B its interface is returned directly. Otherwise the computation is E used to find the interface and the computed interface is stored for  potential later use. .Type checks the main file of the interaction. D This could be the file loaded in the interacting editor (emacs), + or the file passed on the command line. +First, the primitive modules are imported.  Then,  is called to do the main work. -Type checks the given module (if necessary). )Called recursively for imported modules. BTries to return the interface associated to the given module. The A time stamp of the relevant interface file is also returned. May ; type check the module. An error is raised if a warning is  encountered. A more precise variant of . If warnings are A encountered then they are returned instead of being turned into  errors. :Print the highlighting information contained in the given  interface. >Writes the given interface to the given file. Returns the file's ! new modification time stamp, or  if the write failed. >Tries to type check a module and write out its interface. The E function only writes out an interface file if it does not encounter  any warnings. <If appropriate this function writes out syntax highlighting  information. ABuilds an interface for the current module, which should already & have been successfully type checked. !Returns (iSourceHash, iFullHash) ETrue if the first file is newer than the second file. If a file doesn't . exist it is considered to be infinitely old. o*If type checking is necessary, should all  state changes inflicted by   be preserved? The corresponding file. The file to type check. The expected module name.  for the current module. )Syntax highlighting info for the module. =Haskell modules imported in imported modules (transitively). Options set in OPTIONS pragmas. oooNonen)Extract Agda term to Haskell expression. ) Irrelevant arguments are extracted as ().  Types are extracted as ().  DontCare1 outside of irrelevant arguments is extracted as error. BNote that the INFINITY, SHARP and FLAT builtins are translated as  follows (if a M is given):   type Infinity a b = b  sharp :: a -> a  sharp x = x  flat :: a -> a  flat x = x Move somewhere else! -Irrelevant arguments are replaced by Haskells' (). n&Is the type inductive or coinductive? nnnNone3Compile an interface into an executable using Epic )jHBefore running the compiler, we need to store some things in the state, L namely constructor tags, constructor irrelevancies and the delayed field # in functions (for coinduction). )kGPerform the chain of compilation stages, from definitions to epic code )lBChange the current directory to Epic folder, create it if it doesn' t already  exist. )m)Make a program from the given Epic code. #The program is written to the file ../m, where m is the last % component of the given module name. )n>Create the Epic main file, which calls the Agda main function )oICall epic, with a given set of flags, if the |Bool| is True then include # the command line flags at the end )pTCall epic with a given set of flags, the argument function receives the flags given  at the command line )q)r)s)t)j)u)k)l)m)n)o)p )q)r)s)t)j)u)k)l)m)n)o)pNone""""None  A subset of . Parses an expression.   Try to fill hole by expression. 'Returns the given expression unchanged % (for convenient generalization to  ).  !Try to refine hole by expression e. )This amounts to successively try to give e, e ?, e ? ?, ... . Returns the successfully given expression.  :Evaluate the given expression in the current environment getSolvedInteractionPoints True returns all solutions, 9 even if just solved by another, non-interaction meta.  getSolvedInteractionPoints False only returns metas that  are solved by a non-meta. >Returns the type of the expression in the current environment A We wake up irrelevant variables just in case the user want to 1 invoke that command in an irrelevant context. ARuns the given computation as if in an anonymous goal at the end  of the top-level module. ,Sets up current module, scope, and context.  Parse a name. !*Returns the contents of the given module. C Hole. The expression to give. :If successful, the very expression is returned unchanged.  Hole. (The expression to refine the hole with. #The successfully given expression.     !"How should the types be presented  The range of the next argument. The module name. #Module names, names paired up with  corresponding types. ")v)w)x)y)z){)|)})~)9      !"9      !"+      !")v)w)x)y)z){)|)})~)None*The interaction loop. ;?The logo that prints when Agda is started in interactive mode. <The help message #$%&'()*+,-./0123456789:;<#$%&'()*+,-./0123456789:;<$'&%#()*+,-./0123456789:;<#$'&%()*+,-./0123456789:;<None@8Find the clause whose right hand side is the given meta + BY SEARCHING THE WHOLE SIGNATURE. Returns B the original clause, before record patterns have been translated 7 away. Raises an error if there is no matching clause. FAndreas, 2010-09-21: This looks like a SUPER UGLY HACK to me. You are E walking through the WHOLE signature to find an information you have / thrown away earlier. (shutter with disgust). E This code fails for record rhs because they have been eta-expanded,  so the MVar is gone. AHParse variables (visible or hidden), returning their de Bruijn indices.  Used in B. B'Entry point for case splitting tactic. D+Make a clause with a question mark as rhs. =>?@ABCDE =>?@ABCDE =?>@ABCDE=?>@ABCDENone4Binds the FLAT builtin, and changes its definition. ABinds the SHARP builtin, and changes the definitions of INFINITY  and SHARP. 8Binds the INFINITY builtin, but does not change the type's  definition. F The type of ". G The type of &o_. H The type of &m. FGHFGHFGHFGHNone4IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|4IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|4UTRSQVWJKLMNOPIXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|-IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|None}$Entry point for Auto tactic (Agsy).  "auto ii rng s = return (res, mmsg)If mmsg = Just msg, the message msg produced by Agsy should  be displayed to the user.  The result res7 of the Auto tactic can be one of the following three:   Left [(ii,s)]  A list of solutions s for interaction ids ii.  In particular, Left [] means Agsy found no solution.  Right (Left cs) 7 A list of clauses (the user allowed case-split).  Right (Right s) * A refinement for the interaction id ii in which Auto was invoked. ))))))))))}))))}} ))))))))))}))))None5Available backends. The  monad.  )" state holds the remaining input. %Displays version of the running Agda >Shows all the top-level names in the given module, along with 0 their types. Uses the scope of the given goal. &Displays the current goal and context and infers the type of an  expression. 'Displays the current goal and context. Goal commands If the range is !, then the string comes from the " minibuffer rather than the goal. &Toggle display of implicit arguments. 6Tells Agda whether or not to show implicit arguments. GTells Agda to compute highlighting information for the expression just & spliced into an interaction point. !cmd_load_highlighting_info source loads syntax highlighting  information for the module in source, and asks Emacs to apply # highlighting info from this file. AIf the module does not exist, or its module name is malformed or C cannot be determined, or the module has not already been visited, E or the cached info is out of date, then no highlighting information  is printed. DThis command is used to load syntax highlighting information when a E new file is opened, and it would probably be annoying if jumping to @ the definition of an identifier reset the proof state, so this > command tries not to do that. One result of this is that the D command uses the current include directories, whatever they happen  to be. AParse and type check the given expression (as if it were defined ; at the top-level of the current module) and normalise it. 9Parse the given expression (as if it were defined at the 6 top-level of the current module) and infer its type. >Shows all the top-level names in the given module, along with ( their types. Uses the top-level scope. MShow unsolved metas. If there are no unsolved metas but unsolved constraints  show those instead. cmd_compile b m includes compiles the module in file m using  the backend b, using includes as the include directories. cmd_load m includes loads the module in file m, using  includes as the include directories. An interactive computation. 5Monad for computing answers to interactive commands.  is / extended with state . /Auxiliary state of an interactive computation. <The interaction points of the buffer, in the order in which 9 they appear in the buffer. The interaction points are  recorded in  theTCState&, but when new interaction points are @ added by give or refine Agda does not ensure that the ranges , of later interaction points are updated. 8The file which the state applies to. Only stored if the 8 module was successfully type checked (potentially with  warnings). The 5# is the modification time stamp of # the file when it was last loaded. +Reset the options on each reload to these. =We remember (the scope of) old interaction points to make it B possible to parse and compute highlighting information for the ' expression that it got replaced by. $Initial auxiliary interaction state Build an opposite action to ) for state monads.  Opposite of ) for . 0 Use only if main errors are already catched. @Lift a TCM action transformer to a CommandM action transformer. 1Put a response by the callback function given by .  A Lens for .  A Lens for . Run an * value, catch the exceptions, emit output !If an error happens the state of  does not change, < but stPersistent may change (which contains successfully # loaded interfaces for example). Converter from the type of ) to  3 The first paramter is part of the error message  in case the parse fails. Demand an exact string. BCan the command run even if the relevant file has not been loaded  into the state? Interpret an interaction cmd_load' m includes cmd cmd2 loads the module in file m,  using includes as the include directories. >If type checking completes without any exceptions having been  encountered then the command cmd r is executed, where r is the  result of . A give"-like action (give, refine, etc). $give_gen ii rng s give_ref mk_newtxt  acts on interaction point ii  occupying range rng, + placing the new content given by string s,  and replacing ii) by the newly created interaction points  in the state. 0Sorts interaction points based on their ranges. -Pretty-prints the type of the meta-variable. 6Pretty-prints the context of the given meta-variable. MCreate type of application of new helper function that would solve the goal. ?Displays the current goal, the given document, and the current  context. >Shows all the top-level names in the given module, along with  their types. #Explain why something is in scope. BSets the command line options and updates the status information. "Computes some status information. Displays/updates status information.  display_info does what  display_info' False does, but 4 additionally displays some status information (see  and  ). -Kill meta numbers and ranges from all metas (? and _). 1Parses and scope checks an expression (using the " inside scope" B as the scope), performs the given command with the expression as ! input, and displays the result. 8Tell to highlight the code using the given highlighting  info (unless it is Nothing). ATells the Emacs mode to go to the first error position (if any). `~run lift )reverse lift in double negative position Allow unsolved meta-variables?  Normalise? %Print the elements in reverse order? The command to perform. 6The name to use for the buffer displaying the output. The expression to parse. )))))[~[~7~)))))None3 is a fake ghci interpreter for the Emacs frontend  and for interaction tests. / reads the Emacs frontend commands from stdin, 5 interprets them and print the result into stdout. )GConvert Response to an elisp value for the interactive emacs frontend. )Adds a "last" tag to a response. )<Show an iteraction point identifier as an elisp expression. ))))))NoneThe main function Print usage information. Print version information. What to do for bad options. Main ) !"#$%&'()*+,-./01234567789:;<=>?@AB6CDEFGEF?EFAEF=EFHEFIEFJEF@EF<EFK L M N O P Q R S T U V W X Y Z Y[\]^_``abcdefghijklmnopqrstuvwxyz{|}~0663      !"#$%&'()*+%,-(./01234567898:;<=>?@ABC DEFGHIJ % & ' ( ) * + , - . /KLM NOP!Q!Q!R!S!T!U!V!W!@!<!=!>!X!Y!Z!?!G!:![!\!]!^!_!`!a!b!c!d!6"e"e"f"g#h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$6%%%%%%%%%%%Q%Q%%%T%U%%%:%[%%%%V%W%@%%A%<%=%>%%%%?%%G%%X%Y%Z%%\%]%^%%_%`%a%b%c%d%6&&&&&&&&&&&&&&&&&&&&&&&''''''''6((((()n))))))))))***w******6++++++++++,,,,,,,,,A,H,<,=,,,,,>,?,@,,,,,,6---------------- - - - - -- -------0-----Q---------- -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.[.\.].^._.`.a.b.c.d.e.f.6/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/{/|/}/~/~//////////////////////////////////////////////////////////////////////////////00000000000000000000000000000000000000000000000*000000000000000000000000000 0 0 0 0 0000000000000000000 0!0"0#0$0%0&0'0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0A1B1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t2u2v2w2x2y2u2z2{2|2}2~22222222222222222222222222222222223333333333333333333333333333333333333333333455<5=5?55>55K55A5566666666666666Q6666666666666<6777777778888888888     99<9H999999:::::::::::: ::!:":#:$:%:&:':(:):*:+:,:-:.:/:0:1:2:3:4:5:6:7:8:9:::;:<:=:>:?:@:A:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:6;S;T;U;V;S;W;W;X;Y;Y;Z;Z;[; ;\;];^;_;`;a;b;c;d;e;f;g;h;i;j;k;k;l;m;n;o;p;p;q;r;s;s;t;u;v;w;x;y;y;z;{;|;|;};~;;;;;;;;;;;;;;;;;; ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<*<<<<<<<<<<<<<<<===D=E=======>>>>>>>>>>:>>>>>>?>>???????????????????@@@@@@@@@@@@@@@@@ @ @ @ @@ @@@@@@@@@@@@AAAAAAAA A!A"A#A$A%A&A'A(A)B*B+B#B,B-BB.B.B/B0B1B2BQBQB3B4B5B6BB7BB8B9B:B,B.B;B(B<B=BB%B(BB>B?B@BABBBCBDBEBFBGBHBIBJB(BKBLBMB4BNBOBPBQBRBBTBSBTBUBVBWBXBYB6CZCZCCC[C\C,C]C^C<C_C`CaCbC6DcDdDeDeDfDDDgDhDDiDjDkDjDlDmDnDoDpDqDrDsDtDuDvDwDxDyDzD{D|D}E~EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGHHHHHHHHHHHIIIIAI IIIIIIIIIIIIIIIIIIIIIIIII/I6JJJJJJJJJJJJJJJ J J J J6K K KKKKKKKKKKKKKK<KHK=K>K?KAKK6LLLLLLLLLAL@L<LHL?L>L L!L6M"M#M$MM6N%N&N'N'N(N)N*N+N,N-N.N/N0N1N2N3N4N5N6N7N8N9N:N;N<N=N>N?N@NANBNCNDNENFNGNHNINJNKNLNMNNNONPNQNRNSNTNUNVNWNXNYNZN[N\N]N^N_N`NaNbNcNdNeN6OfOgOhOiOjOkOlOmOOnOoOpOpOqOrOOOsOtOjOjOuOvOwOxOyOzO{O|O}O~OOOOOOOyOOOvOpOOOOOOPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRSSSSSSSSSSSSSSSSTTT T T U U VVVVVVVVVVVVVVSSRRW W W!W!W"W#W$W%W&W'W(W)W*W+W,W-W.W/W0X1X1XX2X3X4X5X6X7X8X9X:X;X<X=X>X?X&X@XAXBXCXDXEXFX2XGXXHXXIXJXXKXLXXMXNX XOXPXQXXRXSXTXUXXVXWXXXXXYXZX[X[X\X]X^X_X_X`XaXbXcXXdXdXeXfXgXhXiXjXkXlXmXnXoXpXoXqXrXsXtXuXvXwXxXyXzX{XX|XX}X~XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXvXXXXXXX|XnXyXXXXXXXXXXYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ:Z:ZZ Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z !Z "Z #Z $Z %Z &Z 'Z (Z )Z *Z +Z ,Z -Z .Z /Z 0Z 1Z 2Z 3Z 4Z 5Z 6[ 7[ 7[ 8[ 9[ :[ ;[ <[ =[ >[ ?[ ?[ @[ A[ B[ B[ C[ D[ E[ E[ F[ G[ H[ I[ J[ K[ L[ M[ M[ N[ O[ P[ Q[ R[ S[ T[ U[ V[ V[ W[ X[ Y[ Z[ [[ \[ ][ ^\ _\ `\ a] b] c] d]] e] f] g]]]]]] h] i] j] k] l] m]q] n]r]s]t]u]v]w]x]y]]] o] p] q] r] r] s] t] u] v]o] w] x]p]o] y]] z]] {] |] }]]]]]]]]]]T]]W] ~] ] ] ] ]2]4]7]8]9]=]<]:];]>]?]&]C]D]E] ] ]F] ]G] ] ] ] ]R] ]I]2]]] ]M]J]T] ] ] ] ] ] ] ]]N]]]]]]] ]]]]]]]]]]]]]]v]]] ]]] ]|]n]s]y]] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ^ ^ ^ ^1^ ^^ ^ ^ ^ ^ _ _ _ _ _ __ __ i__ j_ _ _ _ _ _ ___ _ _ _ _ _ _u_ _u_ _ _ _ _ _ _ _ _ __ __ __ _ ____ _ _ __ _ _ _ __ __ _ _ _ _ _ _ ___ __ ____ ___ ___ _ _ _ _ _ _ _ _ _ _n_s_y_|__ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _3_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ !_ "_ #_ $_ %_ &` '` '` (` )` *` +` ,` -` .` /` 0` 1` 2` 3` 4` 5` 6` 7` 8` 9` :` ;` <` =` >` ?` @` A` B` C` D` E` F` Ga Ha Ha Ia Ja Ka La Ma Na Oa Pa Qa Qa Ra Sa Ta Uaa Va Waaa Xaa Yaaa Za [a \b ]b ^b _b `b ]b ab bb cb dbb eb fbbbbbb bbbbb gb hb ib jbb kb lbb mb nb ob pb qb rb sb tb ub vb wb xb ybb zb {b |c }c ~c ccc c c c c c c c c c c c c c d d did d d d d d d d d d e e e e e e e e e e e f f f f f g g g g g g g g g g g g g g g g g ggg g g^g gg g g g g g h h h h i i i i i i Vi Vi i i i i i i i i i i ii i iPiJiii iTiiii iji ii iii ti=i i i i i i i i i i i i6j j j j j j j j j j j j j j j j j j j j jjj 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 k6lll ll l l l m m                      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                               J                                          <                                                                                                  ! " # $ % & ' ( ) * + , - , . / 0 1 2 3 3 4J 5 6 7 8 9 : ; < =P > ? @ A B C D E F G H I J K L M N O P Q R S  T U V W X Y Z [ \ ] ^ _  ` ` a b c d e / 0 f g h i j k l m n o p q r s t u v w x y z { | } ~ 4          I                                          V V               I                      I                        7                      M M                                          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K K L H M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f gn ho ip jp kp lp mp np op pp qp rp sp tp uq vq wq xq yq zq {q |q }q }q ~q q q q q q q q q q qq qqq q q q q q q q q q q q q qq q q q q q q q qq 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 s s s s s s s s s s s sss sss s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s ssssssssss s s    !"#$ %&'()*+,-./t0u1u1u2u3u4u5u6u7u8u9u:u;u<u=u>u?u@uAuBuCuDuEuFuGuHuIuJuKuLuMuNuOuPuQuRuSuTuUuVuWuXuYuZu[u\u]u^u_u`uaubucudueufuguhuiujukulumunuoupuqurusutuuuvuwuxuyuzu{u|u}u~uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvwwwwwKxx x x x x xxxxxxxxxxxxxxxxxxx x!x"x#x$x%x&x'x(x)x*x+x,x-x.x/x0x1x2x3x4x5x6x7x8x9x:x;x<y=y>y?y@yAyByCyDyEzFzGzHzIzJzKzLzMzNzOzPzQ{R{S{T{U{V{W{{X{Y{Z{[{\{]{^{_{`{a{b{c{d{e{f{g{h{i{j{k{l{m{n{o{p{q{r{s{tvuvvvwvivavxvyvzv{v|v}v~vvvXvvvvvvvvvvvvdvvv||||||||||||||||}}}}}}}}} }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~        !"#$%&'(()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi jklmnopqrstuvwxyz{|}~30      !"#$%&'()*+,,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX6YZ[\]^_`abc6defghijklmnopqrstuvwxyz{|}~6?$W f   g  6     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH IJKLMNOPPQRSTUVWXYZ[\]^_`abcdef ghijklmnno<pqrEefGHstuvwxyzo{o{o|o}o~ooMPK J       !"##$%&'()*+,-./012345 6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#(wwwwwwwwwww 3(%pppppppppppppppppppppppppppppppppppppppppppppp p p p p pppppttttttttttttt6 !"e#$%&'()*+,-./0123456789:;<=>?@@ABCDEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghigjklmnopqrstuvwxyz{|}~ V        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJJKLMNOPQRRSTUVWXYZ[\]^_`abcdefghijkklmnopqrstuvwxyz{|}~~nnnnnnnnnnnnnnnn n n n n n J !"#$%&'()*+,-./01234567897:q;"%'(<=>?@ABCD EFGHIJKLMNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv wxyz{|}~V$ B      !"#$%&'%&(%&)%&*%&+,-./01%&2%&3%&456789:;<=>?@ABCDEF S G H I ] J K L M N O P Q RS!TUVWwXYUZ[\]^_`a(a)bcdefgefhefiefjefkeflemnemoempemqemremsemtemuemvemwemxemyemzem{em em em|em}em~ememememememememememememeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeebcbcbcba*      ~  !bc"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIHI@HIJHIHIKHIHIHIHI>HI=HLAHLMHLNHL$HLOHLPHLQHLRHLSHLTHLUHLVHLGHL?HLKHLWHLXHL:HLIHL HLHHL<HLYZ[\]^_`ab`ac`ad`ae`af`ag`ah`ah`ai`aj`ak`al`am`an`ao`ap`aq`ar`as`ar`ap`aq`ao`at`au`av`aw`a_`ab`ax`a^`ay`az`a{`a|`az`a}`ax`au`a`a~`a`a``as`a`aa`a`a`a<`a`a`a`a`aw`av`a]`a\`at`a[aaa'a+a2aa3a4a!!!!!!!!""##bb!b%%%%%%%%%%%%%%%%%%%%&&&&'''''''*,,E,---------------------------------...../////1111111115555555555V555557888 8 #     !!!!!! !"#$%&'()*+,-./012345969798999::;:<:=:>:?:@:A:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:\:]:^:_:`:a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p;q;r;s;t;u;v;w;x;y;z;{;|;};~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<========???BBBBBBBBbCCCCCDDDDDDDDDDDDDDDDDDDDDDDEEEEFFFFFF+FFFFFFFFFHHHHHHIIIIII##IIIIIIIIIIIIIIIIII I I I I IIIAIIIIIIIIIIIIIIIII I!I"JNJ#J$J%J&J'J(J)J*J+J,J-J.J/J0J1J2J3J4K5K6K7K8K9K:K;K<K=K>K?K@KALBLCLDLELFLGLHLILJLKMLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM[M\M]M^N_N`NaNbNcNdNeNfNgNhNiNjNkNlNmNnNoNpNqNrNsNtNuNvNwNxNyNzN{N|N}N~NNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPQUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV V V V V VVVVVVVVVVVVVVVVVVV V!V"V#V$V%V&V'V(V)V*V+V,V-V.V/V0V1V2V3V4V5V6V7V8V9V:V;S<S=S>S?S@SARBWCWDWEWFWGXHXIXJXKXLXMXNXOXPXQXRXSXTXUXVXWXXXYXZX\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXkXlXmXnXoXpYqYrYsYtY YuYvYwYxYyYzY{Y|Y}Y~YYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]R]]]]Q]W]V]]]]]]]]]c]]]d]k]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^________O____ _ _ _ _ ___________________ _!_"_#_$_%_&_'_(_)_v_*_+_,_-_._/_0_1`2``3`4`?`K`5`=`G`<`6`7`8`9`:`;`<`=`>`?`@`A`B`C`D`EaFcGccHcIcJcKcLdMdNdOdPeQeReSeTeUeVeWeXeYeZe[e\e]e^e_e`eaebfcfdfefffgfhfifjfkflfmfnfofpfqfrfsftfufvgw!hxhyhzh{h|h}hh~hhhhhhhhhhiiii i6iiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjSjjjjjjjjjjjjjjkkkkikkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk k k k k kkkkkkkkkkkkkkkkkkk k!k"k#k$k%k&k'k(k)k*k+k,k-k.k/k0k1k2k3k4k5k6k7k8k9k:k;k<k=k>k?k@kAkBkCkDkEkFkGkHkIkJkKkLkMkNkOkPkQkRkSkTkUkVkWkXkYkZk[k\k]k^k_k`kakbkckdkekfkgkhkikjkkklkmknkokpkqkrksktkukvkwkxkykzk{k|k}k~kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk k k k k kkkkkkkkkkkkkkkkkkk k!k"k#k$k%k&k'k(k)k*k+k,k-k.k/k0k1k2k3k4k5k6k7k8k9k:k;k<k=k>k?k@kAkBkCkDkEkFkGkHkIkJkKkLkMkNkOkPkQkRkSkTkUkVkWkXkYkZk[k\k]k^k_k`kakbkckdkekfkgkhkikjkkklkmknkokpkqkrksktkukvkwkxkykzk{k|k}k~kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk k k k k kkkkkkkkkkkkkkkkkkk k!k"k#k$k%k&k'k(k)k*k+k,k-k.k/k0k1k2k3k4k5k6k7k8k9k:k;k<k=k>k?k@kAkBkCkDkEkFkGkHkIkJkKkLkMkNkOkPkQkRkSkTkUkVkWkXkYkZk[k\k]k^k_k`kakbkckdkekfkgkhkikjkkklkmknkokpkqkrksktkukvkwkxkykzk{k|k}k~kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk 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 0k 1k 2k 3k 4k 5k 6k 7k 8k 9k :k ;k <k =k >k ?k @k Ak Bk Ck Dk Ek Fk Gk Hk Ik Jk Kk Lk Mk Nk Ok Pk Qk Rk Sk Tk Uk Vk Wk Xk Yk Zk [k \k ]k ^k _k `k ak bk ck dk ek fk gk hk ik jk kk lk mk nk ok pk qk rk sk tk uk vk wk xk yk zk {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 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!0k!1k!2k!3k!4k!5k!6k!7k!8k!9k!:k!;k!<k!=k!>k!?k!@k!Ak!Bk!Ck!Dk!Ek!Fk!Gk!Hk!Ik!Jk!Kk!Lk!Mk!Nk!Ok!Pk!Qk!Rk!Sk!Tl!Ul!Vll!Wll!Xl!Yll!ZE![H!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!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!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!s!s!s!s!s!s!s!s!s"s"s"s"s"s"s"s"s"s" s" s" s" s" s"s"s"s"s"s"s"s"s"s"s"s"s"s"s"s"s"s"s" s"!s""s"#s"$s"%s"&s"'s"(!u")y"*y"+{",{"-{".{"/{"0{"1{"2{"3{"4{"5{"6{"7{"8{"9{":{";v"<|"=|">| |"?|"@|"A|"B|"C|"D|"E|"F|"F|||"G|"H|"I|"J|"K|"L|"M|"N||"O|"P|"Q|"R|"S|"T|"U|"V|"W|"X|"Y|"Z|"[|"\|"]|"^|"_|"`|"a|"b|"c|"d|"e|"f|"g|"h|"i|"j|"k|"l|"m|"n|"o|"p|"q|"r|"s|"t|"u|"v"w"x"y"z"{"|"}"~""""""""""y"""""""""""""""""""""""""""""""""""""""""""""""" ""o"""""""""""""""""""""""""""_""""""""""""""""""""""""""""""""""""""""""""""########## # # # # ##########n########## #!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f!f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}b#~######\################|##################################################################################################################$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$f$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$LPV$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%% % % % % %%%%%%%%%%%\[%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%.%/%0%1%2%3%4%5%6%7%8 y%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%o%%%%%%%!o%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %A%%%%%%%%%%%%%%%%C%%%%%%%%%%%%%%%%%%&&&&&&&&&& & & & & &&&&&&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.p&/p&0p&1p&2p&3t&4t&5t&6t&7tt&8t&9t&:t&;t&<&=&>&?&@&A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[w&\&]&^&_&`&a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'&&&&&&&&&&&&''''c'''''' ' ' ' '  '' ' ''''''''''''' Agda-2.4.2Agda.Utils.FunctorAgda.Utils.MonadAgda.Utils.Maybe.StrictAgda.Utils.SemiRingAgda.TypeChecking.Monad.DebugAgda.Utils.ClusterAgda.Utils.BiMapAgda.Utils.PointedAgda.Utils.VarSetAgda.Utils.CharAgda.Utils.UnicodeAgda.Utils.PointerAgda.Termination.CutOffAgda.Utils.FreshAgda.Utils.IO.BinaryAgda.Utils.TupleAgda.Utils.UpdateAgda.Utils.TestHelpersAgda.Utils.QuickCheckAgda.Termination.SemiringAgda.Utils.PartialOrdAgda.Utils.ReadPAgda.Utils.IO.UTF8Agda.Utils.Function"Agda.TypeChecking.SizedTypes.Utils#Agda.TypeChecking.SizedTypes.SyntaxAgda.TypeChecking.Monad.BaseAgda.Utils.TimeAgda.Interaction.ResponseAgda.Utils.SizeAgda.Utils.PrettyAgda.Utils.MaybeAgda.Utils.Graph.AdjacencyMapAgda.Utils.ImpossibleAgda.ImpossibleTestAgda.Utils.List,Agda.Utils.Graph.AdjacencyMap.UnidirectionalAgda.Utils.PermutationAgda.Utils.FileNameAgda.Utils.HashAgda.Utils.SuffixAgda.Utils.EitherAgda.Utils.MapAgda.Utils.Favorites+Agda.TypeChecking.SizedTypes.WarshallSolver"Agda.TypeChecking.SizedTypes.TestsAgda.Auto.NarrowingSearchAgda.Auto.SyntaxAgda.Auto.SearchControlAgda.Auto.TypecheckAgda.Auto.CaseSplit Agda.VersionAgda.Utils.Trie&Agda.TypeChecking.Monad.Base.BenchmarkAgda.Utils.StringAgda.Interaction.EmacsCommandAgda.Utils.NullAgda.Syntax.PositionAgda.Syntax.CommonAgda.Compiler.JS.SyntaxAgda.Compiler.JS.PrettyAgda.Compiler.JS.SubstitutionAgda.Compiler.JS.CaseAgda.Compiler.JS.ParserAgda.Syntax.NotationAgda.Utils.Warshall#Agda.Interaction.Highlighting.RangeAgda.Syntax.Concrete.NameAgda.Syntax.FixityAgda.Syntax.Parser.MonadAgda.Syntax.Parser.AlexAgda.Syntax.Parser.LookAheadAgda.Termination.SparseMatrixAgda.Termination.OrderAgda.Termination.CallMatrixAgda.Termination.CallGraphAgda.Termination.TerminationAgda.Interaction.OptionsAgda.Syntax.Abstract.NameAgda.Syntax.LiteralAgda.Syntax.Parser.TokensAgda.Syntax.Parser.LayoutAgda.Syntax.Parser.LexActionsAgda.Syntax.Parser.Comments!Agda.Syntax.Parser.StringLiteralsAgda.Syntax.Parser.Lexer$Agda.TypeChecking.Coverage.SplitTreeAgda.Syntax.ConcreteAgda.Syntax.Concrete.PrettyAgda.Syntax.Scope.BaseAgda.Syntax.InfoAgda.Utils.GeniplateAgda.Syntax.AbstractAgda.Syntax.Abstract.ViewsAgda.Syntax.InternalAgda.TypeChecking.FreeAgda.Compiler.Epic.InterfaceAgda.Compiler.Epic.AuxAST Agda.TypeChecking.CompiledClauseAgda.Syntax.Internal.PatternAgda.Syntax.Internal.DefsAgda.Syntax.Internal.Generic Agda.TypeChecking.Coverage.MatchAgda.Syntax.Concrete.Generic%Agda.Interaction.Highlighting.Precise Agda.Syntax.Concrete.DefinitionsAgda.Syntax.Parser.ParserAgda.Syntax.ParserAgda.Interaction.ExceptionsAgda.Interaction.ImportsAgda.TypeChecking.ErrorsAgda.TypeChecking.MetaVarsAgda.TypeChecking.SubstituteAgda.TypeChecking.Abstract!Agda.TypeChecking.Test.Generators&Agda.Interaction.Highlighting.GenerateAgda.TypeChecking.Monad.BuiltinAgda.TypeChecking.Monad.OptionsAgda.TypeChecking.ConstraintsAgda.TypeChecking.Monad.State!Agda.TypeChecking.Monad.BenchmarkAgda.Interaction.FindFileAgda.Interaction.Options.Lenses*Agda.Syntax.Translation.AbstractToConcreteAgda.Syntax.Scope.MonadAgda.TypeChecking.Monad.SharingAgda.Syntax.Abstract.Copatterns%Agda.Syntax.Concrete.Operators.ParserAgda.Syntax.Concrete.OperatorsAgda.TypeChecking.Monad.TraceAgda.TypeChecking.Monad.EnvAgda.TypeChecking.Rules.Term Agda.TypeChecking.ProjectionLike(Agda.TypeChecking.CompiledClause.Compile#Agda.TypeChecking.InstanceArguments"Agda.TypeChecking.LevelConstraintsAgda.TypeChecking.PolarityAgda.TypeChecking.Monad.Closure!Agda.TypeChecking.Monad.ExceptionAgda.TypeChecking.Monad.Context&Agda.TypeChecking.Monad.Base.KillRange#Agda.TypeChecking.Monad.ConstraintsAgda.TypeChecking.Monad.Open Agda.TypeChecking.Monad.MetaVars*Agda.Syntax.Translation.ConcreteToAbstractAgda.TypeChecking.Monad.ImportsAgda.TypeChecking.Monad.Mutual!Agda.TypeChecking.Monad.SignatureAgda.TypeChecking.Datatypes"Agda.TypeChecking.Monad.SizedTypes"Agda.TypeChecking.Monad.StatisticsAgda.Interaction.Monad!Agda.Interaction.Highlighting.Dot"Agda.Interaction.Highlighting.HTMLAgda.Compiler.MAlonzo.CompilerAgda.TypeChecking.ConversionAgda.TypeChecking.RecordsAgda.TypeChecking.IrrelevanceAgda.TypeChecking.Pretty#Agda.Interaction.Highlighting.EmacsAgda.Syntax.Abstract.PrettyAgda.Compiler.CallCompiler#Agda.Interaction.Highlighting.LaTeXAgda.TypeChecking.SerialiseAgda.Compiler.MAlonzo.MiscAgda.Compiler.MAlonzo.EncodeAgda.Compiler.MAlonzo.Pretty!Agda.Interaction.Highlighting.VimAgda.TypeChecking.DropArgsAgda.Termination.RecCheckAgda.TypeChecking.Rules.DeclAgda.TypeChecking.Reduce.MonadAgda.TypeChecking.EtaContract&Agda.TypeChecking.CompiledClause.MatchAgda.TypeChecking.EmptyAgda.TypeChecking.Forcing"Agda.TypeChecking.MetaVars.Mention#Agda.TypeChecking.Patterns.Abstract Agda.TypeChecking.Patterns.MatchAgda.TypeChecking.ReduceAgda.TypeChecking.TelescopeAgda.TypeChecking.TestsAgda.Compiler.Epic.CompileStateAgda.Compiler.Epic.CaseOptsAgda.Compiler.Epic.ForceConstrsAgda.Compiler.Epic.EpicAgda.Compiler.Epic.NatDetectionAgda.Compiler.Epic.PrimitiveAgda.TypeChecking.LevelAgda.TypeChecking.DisplayForm*Agda.Syntax.Translation.InternalToAbstractAgda.Compiler.HaskellTypesAgda.Compiler.Epic.ErasureAgda.Compiler.Epic.InjectionAgda.Compiler.Epic.Smashing#Agda.TypeChecking.Rules.LHS.ProblemAgda.Termination.MonadAgda.Compiler.Epic.StaticAgda.Compiler.Epic.FromAgda Agda.Compiler.MAlonzo.PrimitivesAgda.Termination.InliningAgda.TypeChecking.SizedTypesAgda.Termination.TermCheck Agda.TypeChecking.RecordPatterns!Agda.TypeChecking.MetaVars.Occurs Agda.Tests#Agda.TypeChecking.SyntacticEqualityAgda.TypeChecking.Implicit'Agda.TypeChecking.Rules.LHS.InstantiateAgda.TypeChecking.PositivityAgda.TypeChecking.QuoteAgda.TypeChecking.PrimitiveAgda.TypeChecking.Injectivity!Agda.TypeChecking.Rules.LHS.UnifyAgda.Compiler.Epic.ForcingAgda.TypeChecking.CheckInternal!Agda.TypeChecking.Rules.LHS.Split+Agda.TypeChecking.Rules.Builtin.CoinductionAgda.TypeChecking.Rules.Data"Agda.TypeChecking.SizedTypes.SolveAgda.TypeChecking.Rules.Def$Agda.TypeChecking.Rules.LHS.ImplicitAgda.TypeChecking.With'Agda.TypeChecking.Rules.LHS.ProblemRestAgda.TypeChecking.Rules.LHSAgda.TypeChecking.CoverageAgda.TypeChecking.Rules.RecordAgda.TypeChecking.RewritingAgda.TypeChecking.Rules.BuiltinAgda.Compiler.Epic.CompilerAgda.Compiler.JS.CompilerAgda.Interaction.BasicOps(Agda.Interaction.CommandLine.CommandLineAgda.Interaction.MakeCaseAgda.Auto.ConvertAgda.Auto.AutoAgda.Interaction.InteractionTopAgda.Interaction.EmacsTop Agda.MainLazy listToMaybe maybeToList catMaybesmapMaybe TraversableforM Paths_AgdaAgda.Utils.HashMapData.TraversableforAgda.TypeChecking.SubstitutionliftS Control.MonadmapMLHSAgda.TypeChecking IrrelevancemakeIncludeDirsAbsoluteDataTreeQName whyInScopeGenericAbstractSyntax AtTopLevelinteractionLoopTest.QuickChecksize localState getConTypeAgda.TypeChecking.Monad Agda.SyntaxCommonsimplifyLevelConstraint Agda.UtilsWarshallTypeChecking.Coverage.MatchbuildMPatternscompileClausesgiveExpr CheckInternalAgda.TheTypeCheckerbase Data.Functor<$>Control.Applicative<*>GHC.Base<$toStricttoLazyunionMaybeWith unzipMaybe filterMaybeforMaybe caseMaybemaybeM fromMaybeM caseMaybeMifJustMwhenJust whenJustMSemiRingoplusotimesdebugclustercluster'testsBiMap biMapThere biMapBacklookup invLookupempty singletoninsertunionfromListtoListprop_BiMap_invariantPointedpointcontainers-0.5.0.0Data.IntSet.Baseunionsnullmember isSubsetOfdeleteVarSetsubtractdecDigithexDigitoctDigit isUnicodeIdconvertLineEndingsPtrnewPtrderefPtr updatePtrsetPtr updatePtrMCutOff DontCutOffHasFresh nextFreshfresh withFreshreadBinaryFile'List2list2-*-mapFstmapSnd/\swapfst3snd3thd3uncurry3uncurry4mapPairMmapFstMmapSndMUpdater2updater2updates2update2Updater1updater1updates1update1ChangeUpdater MonadChange tellDirty listenDirty runChange runUpdaterdirtyifDirtysharing associative commutative idempotentisZeroidentityleftDistributiverightDistributive distributivenaturalpositivelistOfElementselementsUnlessEmptymaybeGen maybeCoGentwothreerunTests isSuccess quickCheck'quickCheckWith'SemiringaddmulzeroHasZero zeroElementmultiplysemiringInvariantintegerSemiring intSemiring boolSemiringISetiset Inclusion inclusion Pointwise pointwise PartialOrd comparable ComparablePartialOrderingPOAnyPOGTPOGEPOEQPOLEPOLTleqPOoppPOorPOseqPO fromOrdering fromOrderings toOrderings comparableOrdrelatedprop_comparable_related prop_oppPOsortUniqprop_leqPO_soundprop_orPO_soundprop_associative_orPOprop_commutative_orPOprop_idempotent_orPOprop_zero_orPOproperty_seqPO prop_seqPOprop_identity_seqPOprop_zero_seqPOprop_associative_seqPOprop_commutative_seqPOprop_idempotent_seqPOprop_distributive_seqPO_orPOprop_sorted_toOrderings#prop_toOrderings_after_fromOrdering$prop_fromOrderings_after_toOrderings$prop_toOrderings_after_fromOrderingsprop_related_pairprop_comparable_PartialOrderingReadPparsegetlookpfail+++<++gathersatisfycharstringmunchmunch1choice skipSpacescountbetweenoptionoptionalmanymany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTillparse' readTextFilehPutStr writeFile trampoline trampolineM iterateUntil iterateUntilMiterate' applyWhen applyUnless applyWhenM applyUnlessMDioidcompose unitComposeMeetSemiLatticemeetPlusplusToptopisToptracetraceM$>FlexsflexsRigidsrigidsTruncateOffsettruncateOffset ValidOffset validOffsetCTrans SubstitutesubstSolution PolaritiesPolarityAssignmentPolarityGreatestLeast Constraint Constraint'leftExprcmp rightExprCmpLeLtSizeExpr SizeExpr'FlexflexInftyRigidrigidConstoffsetFlexIdflexIdRigidIdrigidIdOffsetemptyPolaritiespolaritiesFromAssignments getPolarity emptySolution simplify1ifLe compareOffsetTCMTCMTunTCMTCStateTCEnv ClockTime getClockTime measureTimeInteractionOutputCallbackResponse defaultInteractionOutputCallbackSizedPrettypretty prettyPrecpwordsfwordsmparensalign Decoration traverseF distributeF<.>dmapdgetGraphunGraph invariantedges edgesFromnodes fromNodes removeNode removeEdge filterEdges neighbourssccs'sccsacyclictransitiveClosure1transitiveClosurefindPathallPathsnodeInedgeIn ImpossiblethrowImpossiblecatchImpossibleimpossibleTest PreOrSuffixIsNofix IsBothfixIsSuffixIsPrefixSuffixPrefixmheadunconsmconsinitLast!!!downFrom updateLast mapEitherdeal takeWhileJustspanJustpartitionMaybe isSublistOfmaybePrefixMatch preOrSuffixwordsBychopholessorteddistinct fastDistinctprop_distinct_fastDistinctallEqualgroupBy' prop_groupBy'groupOnsplitExactlyAtextractNthElement'extractNthElementprop_extractNthElementgenericElemIndexprop_genericElemIndexzipWith' prop_zipWith'uniqBy prop_uniqBy commonSuffix commonPrefixprop_commonPrefixprop_commonSuffixNodessrcNodestgtNodesallNodesEdgesourcetargetlabelgraph transposeEdgeedgesTodiagonal sourceNodes targetNodes computeNodes fromListWith insertEdge insertWithinsertEdgeWith unionWith unionsWithunzip composeWithDoDropdoDropdropMoreunDropDropdropNdropFrom PermutationPerm permRange permPickspermuteidPtakePdroppedPliftPcomposePinvertPcompactPreversePexpandPtopoSort AbsolutePathfilePath mkAbsoluterootNameabsolute===doesFileExistCaseSensitiveHashhashByteStringhashFile combineHashes hashString SubscriptIndexPrimeNoSuffixisSubscriptDigittoSubscriptDigitfromSubscriptDigit nextSuffix suffixView addSuffix whileLeft caseEitherMmapLeftmapRightisRightisLeftallRight EitherOrBothRBL unionWithMinsertWithKeyM allWithKey filterKeysunzip3 CompareResult IsDominated dominator Dominates dominated notDominated FavoritescompareWithFavoritescompareFavorites unionComparedinsertComparedproperty_null_emptyproperty_not_null_singletonprop_compareWithFavoritesprop_fromList_after_toListprop_union_union2Bounds lowerBounds upperBounds mustBeFiniteBound SetToInfty setToInfty ConGraphsConGraphHypGraphHyp'HypGraphsNodeNodeFlex NodeRigid NodeInftyNodeZeroLabelLInflcmploffsetNegativenegativeWeightInfinity LabelledEdgeKeyEdge'srcdest lookupEdge graphToList graphFromListoutgoingincomingsetFoldl transClostoWeight isFlexNode isZeroNode isInftyNodenodeToSizeExpr emptyGraphsmentionsaddEdgereflClosimpliesnodeFromSizeExpredgeFromConstraintgraphFromConstraintsgraphsFromConstraintshypGraphhypConnsimplifyWithHypothesesconstraintGraphconstraintGraphs infinityFlexs emptyBoundedgeToLowerBoundedgeToUpperBoundgraphToLowerBoundsgraphToUpperBoundsboundssmallestlargest commonSuccs commonPredslub'glb'lubglbfindRigidBelow solveGraph solveGraphsverifySolution testSuccstestLubAsWeightRelationevalRelationprop_MeetSoundprop_MeetCompleteprop_ComposeSoundprop_ComposeCompletepropCommutativepropAssociativepropIdempotentpropUnitpropZero propDistL propDistRpropDistributivepropSemiLatticepropBoundedSemiLattice propMonoid propDioid propDioid_Genprop_Dioid_Weightprop_SemiLattice_Labelprop_Unit_Labelprop_BoundedSemiLattice_Labelprop_Monoid_Labelprop_DistL_Labelprop_DistR_Labelprop_Dist_Labelprop_Zero_Labelprop_Dioid_LabelChoice RightDisjunct LeftDisjunctSRes HandleSolQPBQPDoubleBlocked QPBlockedPBPDoubleBlockedPBlockedNotPBMBFailedBlockedNotBMetaEnvMMMetaNotMBlkInfo Refinable refinementsPair RefCreateEnvUndoRestorePrioMetaNoPrioSubConstraintsscflip sccomcountscsub1scsub2CTree ctpriometactsubctparent cthandlesMetavarmbindmprincipalpresentmobs mcompoint mextrarefsOKMetaOKHandleOKValProp ConnectHandleOr SideconditionAnd AddExtraRefErrorOKTermTravtraversePrio hequalMetavarnewMetainitMetanewCTreenewSubConstraints ureadIORef uwriteIORef umodifyIORefureadmodifyIORefrunUndonewPlaceholder newOKHandledryInstantiatemmcasemmmcasemmpcase doubleblockmbcasembpcasemmbpcasewaitokmbretmbfailedmpret expandbind topSearchextractblkinfosrecalcsseqcrecalcreccalccalcchoosePrioMeta propagatePriochooseEECtxCActionWeakSkipSubTrBrCExpClosICExp ICArgList CALConcatCALNil HNArgList HNALConParHNALConsHNALNilHNExpHNSortHNPiHNLamHNAppMArgListArgListALConParALProjALConsALNilMExpExp AbsurdLambdaSortPiLamAppappUIdappOKappHeadappElimsType UnknownSortSetElrVarConstRefPatPatExpPatVar PatConAppClauseDeclCont Postulate ConstructorDatatypeDefConstDefcdnamecdorigincdtypecdcont cddeffreevarsAbsMIdNoIdIdFMode NotHiddenInstanceHiddenNatMyMBMyPBRefInfoRICheckProjIndex RICheckElim RIEqRState RIPickSubsvar RIUsedVarsRINotConstructorRIInferredTypeUnknown RIIotaStep RICopyInfo RIUnifInfo RIMainInforiMainCxtLength riMainType riMainIotaRIEnvrieHintsrieDefFreeVarsrieEqReasoningConstsEqReasoningStateEqRSPrf3EqRSPrf2EqRSPrf1 EqRSChainEqRSNoneEqReasoningConstseqrcId eqrcBegineqrcStepeqrcEndeqrcSymeqrcCongHintMode HMRecCallHMNormalUId stringToMyIddontCaredetecteliminanddetectsemiflexcategorizedecl metaliseokh expandExpaddtrailingargsclosifysubsubiweakweaki weakarglistweakelrdoclos ExpRefInfoeriMaineriUnifseriInfTypeUnknowneriIsEliminand eriUsedVars eriIotaSteperiPickSubsVar eriEqRStategetinfounivarsubsvarsextraref costIncreasecostUnificationOccurscostUnification costAppVarcostAppVarUsed costAppHintcostAppHintUsedcostAppRecCallcostAppRecCallUsedcostAppConstructorcostAppConstructorSinglecostAppExtraRefcostLam costLamUnfoldcostPicostSort costIotaStepcostInferredTypeUnkown costAbsurdLam costEqStep costEqEnd costEqSym costEqCongprioNoprioTypeUnknown prioTypecheckprioTypecheckArgListprioInferredTypeUnknown prioCompBetaprioCompBetaStructured prioCompIotaprioCompChoice prioCompUnif prioCompCopyprioCompareArgList prioNoIotaprioAbsurdLambda prioProjIndexCMFlex CMFBlockedCMFSemiCMFFlexCModeCMRigidPEvalPEConAppPENoHNResHNMetaHNDoneHNNBlkstcExp getDatatypeconstructorImpossibleunequalsunequal traversePitcargsaddendcopyargnoblksaddblkhnnhnn_blks hnn_checkstephnn'hnbhnc hnarglistgetNArgs getAllArgsiotastep noiotastepnoiotastep_termcomp'checkeliminandmaybeor iotapossmetameta_not_constructor calcEqRStatepickidtcSearchSolCSPatI CSOmittedArgCSAbsurdCSWithCSPatExpCSPatVar CSPatConAppCSCtxCSPatHI abspatvarnamecostCaseSplitVeryHighcostCaseSplitHighcostCaseSplitLowcostAddVarDepthdrophidcaseSplitSearchcaseSplitSearch' infertypevarreplace betareduce concatargseqelrreplaceprmmmunifyexplift removevarnotequalfindpermfreevars applypermrenrenamerenamepseqctx depthofvarlocalTerminationEnvlocalTerminationSidecondgetblksversionTrieadjust toAscList lookupPath BenchmarkCPUTimeAccountPhase BuildParser Operators ModuleNameWithCompareLevelReduceRecCheck Serialization HighlightingCoverageProjectionLikeness Injectivity Positivity TerminationTypingScopingDeserializationImportParsing addCPUTimeStrgetStrquote showIndexaddFinalNewLineindentshowThousandSepLispQConsAresponse putResponse display_info'clearRunningInfodisplayRunningInfoContwhen_unless_whenMunlessMifMifNotMand2MandMor2MorMaltM1mapM'forM'thread zipWithM' mapMaybeM dropWhileMfinallybracketbracket_readMNullifNullifNullMwhenNull unlessNull whenNullM unlessNullM KillRangeT KillRange killRangeSetRangesetRangeHasRangegetRangeRangeRange'Interval Interval'iStartiEndPosition Position'PnsrcFileposPosposLineposColpositionInvariantintervalInvariantrangeInvariant rightMargin killRange1 killRange2 killRange3 killRange4 killRange5 killRange6 killRange7 killRange8 killRange9 killRange10 killRange11 killRange12 killRange13 killRange14 killRange15 killRange16 killRange17 killRange18 killRange19startPosnoRangemovePosmovePosByString backupPostakeIdropI posToRangerangeToInterval continuouscontinuousPerLinerStartrEnd fuseRanges fuseRange beginningOfbeginningOfFile withRangeOfTerminationCheckTerminationMeasureNonTerminatingNoTerminationCheck InteractionId interactionIdConstrNameIdArity IsInstanceNotInstanceDef InstanceDef IsAbstract ConcreteDef AbstractDefAccess OnlyQualified PublicAccess PrivateAccessIsInfix PrefixDefInfixDefRStringRawNameRangedrangeOf rangedThingNamedArgNamed_NamednameOf namedThingDomdomInfounDom Underscore underscore isUnderscoreArgargInfounArgArgInfo argInfoHidingargInfoRelevance argInfoColors LensRelevance getRelevance setRelevance mapRelevance Relevance UnusedArgForced Irrelevant NonStrictRelevant LensHiding getHiding setHiding mapHidingHiding Induction CoInductive InductiveDelayed NotDelayedisHidden notHiddenvisible notVisiblehide makeInstance isRelevant isIrrelevant moreRelevantmapArgInfoColorsdefaultArgInfo mapArgInfo argColors mapArgColors setArgColors defaultArgdefaultColoredArg noColorArg withArgsFromwithNamedArgsFrom mapDomInfo domColors argFromDom domFromArg defaultDomunnamednamednamedArgdefaultNamedArgupdateNamedArgunrangedrawNameToStringstringToRawNameGlobalsglobalsUsesusesModulemodNameexportsExportexpNamedefnMemberIdGlobalIdLocalIdPreOpBinOpIfLookupApplyObjectLambdaDoubleIntegerCharString UndefinedGlobalLocalSelfPrettiesprettiesbrunescape unescapesblockblock'modnamemapshift shiftFromshifter substitutermap'subst'applyselffix curriedApply curriedLambdaempvineobjectTagPattTaggedVarPattCasepatsbodynumVarsnumVars'lambdalambda'popmatchrefinevisittagstagParser identifier wordBoundarytokenpunctparenedbraced bracketedquoted stringLit stringStr stringChrescChrintLitundeflocalidglobalidpreopbinopfieldfunction bracedBlock returnBlockifBlockexp0exp1exp2exp2'exp3exp3'exptopLevelGenPartIdPart NormalHoleBindHoleNotationHoleNameExprHole LambdaHoleholeName stringParts holeTargetisAHole isBindingHole isLambdaHole mkNotationdefaultNotation noNotationDistanceDist SizeConstSizeVar LegendMatrixmatrixrowdescrcoldescrGM flexScopenodeMapintMapnextNode ConstraintsArcNewFlexScopeNodeIdRVarRConstInfiniteFiniteAdjListMatrixwarshall warshallGincinfiniteisBelowemptyConstraints initGraphaddFlexaddNode addConstraint buildGraphmkMatrixextendSolution sizeRigidsolvegenGraph genGraph_ prop_smallernewEdgegenPath prop_pathmapNodes prop_disjoint prop_stableRangesfromtorangesInvariant overlappingrangeToPositionsrangesToPositionsrToRminusIsNoNameisNoNameTopLevelModuleNamemoduleNamePartsQualNamePartHoleNameNoName nameToRawName namePartsnameStringPartsstringNameParts isOperatorisHoleisPrefix isPostfixisInfixisNonfixqualify unqualify qnamePartstoTopLevelModuleNamemoduleNameToFileName projectRootnoName_noName Precedence DotPatternCtx WithArgCtx WithFunCtxInsideOperandCtx ArgumentCtx FunctionCtxRightOperandCtxLeftOperandCtxFunctionSpaceDomainCtxTopCtxFixityNonAssoc RightAssoc LeftAssoc NewNotationThingWithFixityFixity' theFixity theNotationoldToNewNotationsyntaxOfdefaultFixity'noFixity fixityLevel defaultFixityhiddenArgumentCtx opBrackets lamBrackets appBracketswithAppBrackets piBracketsroundFixBrackets ParseResult ParseFailedParseOk ParseErrorerrPoserrInput errPrevTokenerrMsg ParseFlagsparseKeepComments LayoutContextLayoutNoLayoutLexState ParseStatePStateparsePos parseLastPosparseInp parsePrevCharparsePrevToken parseLayout parseLexState parseFlags initStatedefaultParseFlagsparsePosString parseFile setParsePos setLastPos setPrevTokengetParseInterval getLexState pushLexState popLexState getParseFlags parseError parseErrorAt parseError'lexError topContext popContext pushContextpushCurrentContext LexPredicate LexAction TokenLength CurrentInput PreviousInput AlexInputlexPoslexInput lexPrevCharalexInputPrevChar alexGetChar alexGetByte getLexInput setLexInput.&&..||.not' LookAheadgetInputsetInputnextCharsyncrollback eatNextCharmatch' runLookAhead transposeDiagonalMIxrowcolSizerowscolssquareisEmpty fromIndexList fromListstoLists isSingleton zipMatrices intersectWith addColumnaddRow sizeInvariant mIxInvariantmatrixInvariantmatrixUsingRowGenNotWorsenotWorseOrderMatincreasedecreasedecrorderMatleltunknown decreasingisDecr.*. collapseOsupremuminfimum orderSemiringCMSetcmSet CallMatrixAug augCallMatrix augCallInfoCallComb>*< CallMatrix CallMatrix'mat ArgumentIndexnoAug callMatrix CallGraph theCallGraphCall callMatrixSetmkCallmkCall'completecompletionStep terminatesterminatesFilterendosFlag OptionsPragma PragmaOptionsoptShowImplicitoptShowIrrelevant optVerboseoptProofIrrelevanceoptAllowUnsolvedoptDisablePositivityoptTerminationCheckoptTerminationDepthoptCompletenessCheckoptUniverseCheck optSizedTypesoptInjectiveTypeConstructorsoptGuardingTypeConstructorsoptUniversePolymorphismoptIrrelevantProjectionsoptExperimentalIrrelevance optWithoutK optCopatternsoptPatternMatchingCommandLineOptionsOptionsoptProgramName optInputFileoptIncludeDirsoptShowVersion optShowHelpoptInteractive optRunTestsoptGHCiInteraction optCompileoptCompileNoMainoptEpicCompile optJSCompile optCompileDiroptGenerateVimFileoptGenerateLaTeXoptGenerateHTMLoptDependencyGraph optLaTeXDir optHTMLDir optCSSFileoptIgnoreInterfaces optForcing optGhcFlagsoptPragmaOptions optEpicFlagsoptSafe IncludeDirs Verbosity isLiteratemapFlagdefaultVerbositydefaultInteractionOptionsdefaultOptions defaultCutOff checkOptsunsafePragmaOptionsstandardOptions_parseStandardOptionsparsePragmaOptionsparsePluginOptionsusage FreshName freshName_MkNamemkNamemkName_AmbiguousQNameAmbQunAmbQMName mnameToListQNamedqnameqnamed qnameModule qnameNamenameId nameConcretenameBindingSite nameFixityisAnonymousModuleName withRangesOf withRangesOfQ mnameFromList noModuleName qnameToList qnameFromList qnameToMName mnameToQName showQNameIdqnameToConcretemnameToConcretequalifyMqualifyQ isSubModuleOf isInModule freshName freshNoName freshNoName_nextNameLiteralLitQNameLitChar LitStringLitFloatLitInt showString' showChar'TokenTokEOFTokDummy TokCommentTokTeXTokSetN TokString TokSymbol TokLiteralTokQIdTokId TokKeywordSymbol SymEndComment SymDotDot SymEllipsisSymClosePragma SymOpenPragmaSymCloseVirtualBraceSymOpenVirtualBrace SymCloseBrace SymOpenBraceSymDoubleCloseBraceSymDoubleOpenBrace SymCloseParen SymOpenParenSymAsSymQuestionMark SymUnderscore SymLambdaSymEqualSymArrowSymColonSymBarSymVirtualSemiSymSemiSymDotKeywordKwTactic KwPatternSynKwSyntax KwUnquoteDecl KwUnquote KwQuoteTermKwQuoteKwQuoteContext KwQuoteGoal KwREWRITEKwSTATIC KwMEASUREKwNON_TERMINATINGKwNO_TERMINATION_CHECKKwETA KwIMPOSSIBLEKwIMPORT KwCOMPILED_JSKwCOMPILED_EPICKwCOMPILED_EXPORT KwCOMPILEDKwCOMPILED_TYPEKwCOMPILED_DATAKwLINE KwBUILTIN KwOPTIONSKwPublicKwTo KwRenamingKwUsingKwHiding KwCoInductive KwInductiveKwField KwConstructorKwRecordKwForallKwPropKwSet KwRewriteKwWithKwInfixRKwInfixLKwInfix KwPrimitiveKwModuleKwImportKwOpen KwInstance KwPrivate KwAbstractKwMutual KwPostulateKwCoDataKwDataKwWhereKwInKwLetlayoutKeywords emptyLayoutnewLayoutContext offsideRuleinStateeof followedByliteralsymbolkeywordend_begin_endWithbegin withLayout withInterval' withIntervallexToken keepComments keepCommentsM nestedCommenthole skipBlock litStringlitChar AlexReturn AlexTokenAlexSkip AlexErrorAlexEOFliteratenormallayout empty_layoutbolimp_dirlexercode alexScanUser withInterval_end openBrace closeBraceCNameSplitTreeLabellblConstructorName lblSplitArg lblBindings SplitTrees' SplitTree'SplitAtsplitArg splitTrees SplittingDone splitBindings SplitTrees SplitTreetoTreetoTreestestSplitTreePrintingAppViewPragmaTerminationCheckPragma EtaPragmaImpossiblePragma ImportPragma StaticPragmaCompiledJSPragmaCompiledEpicPragmaCompiledExportPragmaCompiledPragmaCompiledTypePragmaCompiledDataPragma RewritePragma BuiltinPragma OpenShortHandDontOpenDoOpenModuleApplicationRecordModuleIFS SectionApp Declaration UnquoteDecl ModuleMacroOpen Primitive InstanceBPrivateMutual PatternSynInfixRecord RecordSigDataSig FunClauseFieldTypeSigTypeSignatureOrInstanceBlock TypeSignatureAsNameasNameasRangeRenamingrenFromrenTo renToRange ImportedNameImportedModule importedName UsingOrHidingUsingImportDirectiveimportDirRange usingOrHidingrenaming publicOpen WhereClause' SomeWhereAnyWhereNoWhere WhereClauseRHS'RHS AbsurdRHSLHSCoreLHSProj lhsDestructor lhsPatsLeftlhsFocus lhsPatsRightLHSHead lhsDefNamelhsPatsWithExpr RewriteEqnEllipsislhsOriginalPatternlhsWithPattern lhsRewriteEqn lhsWithExpr TelescopeColoredTypedBinding WithColors TypedBinding'TLetTBind TypedBinding BoundNameBName boundName boundLabel bnameFixityTypedBindings' TypedBindings LamBinding' DomainFull DomainFree LamBindingPatternLitPDotPAsPAbsurdPWildPParenP InstancePHiddenPOpAppPRawAppPAppPQuotePIdentPExprEqualDontCareUnquoteTactic QuoteTermQuote QuoteContext QuoteGoalETelDotAsAbsurdParenLet RecUpdateRecSetNFun ExtendedLam AbsurdLam InstanceArg HiddenArgWithAppOpAppRawApp QuestionMarkLitIdentOrdinarySyntaxBindingLambdaColor fromOrdinary mkBoundName_ mkBoundName countTelVarsdefaultImportDirtopLevelModuleNameappView patternHead patternNamesTelbraces'dbracesbracesAndSemicolonsarrowpHidden pRelevancepColorssmashTel prettyOpAppAllowAmbiguousConstructorsNoAmbiguousConstructorsAbstractModule AbsModuleamodName amodLineage AbstractNameAbsName anameName anameKind anameLineage WhyInScopeAppliedOpenedDefined KindOfName QuotableNamePatternSynNameDefNameFldNameConNameInScope inScopeTag InScopeTag ModuleTagNameTagModulesInScope NamesInScope ThingsInScope NameSpacensNames nsModules LocalVars ScopeInfo scopeCurrent scopeModules scopeLocalsscopePrecedence NameSpaceIdOnlyQualifiedNS ImportedNSPublicNS PrivateNS scopeName scopeParentsscopeNameSpaces scopeImportsscopeDatatypeModulelocalNameSpacenameSpaceAccessscopeNameSpacemodifyScopeLocalssetScopeLocals inNameSpaceallKindsOfNames mergeNamesemptyNameSpace mapNameSpace zipNameSpace mapNameSpaceM emptyScopeemptyScopeInfomapScope mapScope_ mapScopeM mapScopeM_zipScope zipScope_ filterScopeallNamesInScopeallNamesInScope'exportedNamesInScope namesInScopeallThingsInScope thingsInScope mergeScope mergeScopessetScopeAccess setNameSpaceaddNamesToScopeaddNameToScoperemoveNameFromScopeaddModuleToScopeapplyImportDirectiverenameCanonicalNamesrestrictPrivateremoveOnlyQualifiedinScopeBecause publicModuleseverythingInScope flattenScope scopeLookup scopeLookup'inverseScopeLookupinverseScopeLookup'inverseScopeLookupNameinverseScopeLookupName'inverseScopeLookupModule blockOfLines ConPatInfo patImplicitpatInfoPatInfo PatSourcePatRangeLHSInfoLHSRange MutualInfomutualTermCheck mutualRangeDeclInfodeclName declRangeDefInfo defFixity defAccess defAbstract defInstancedefInfoLetInfoLetRange ModuleInfo minfoRange minfoAsTo minfoAsNameminfoOpenShortminfoDirectiveExprInfo ExprSource ExprRangeMetaInfo metaRange metaScope metaNumbermetaNameSuggestion emptyMetaInfo mkDefInfomkDefInfoInstance patNoRangedontDescendIntoinstanceUniverseBiT'instanceTransformBiMT'IsProjPisProjPPatternsPattern' PatternSynP ImplicitPDefPConPVarP LHSToSpine lhsToSpine spineToLhsLHSCore'lhsInfolhsCore lhsWithPatsSpineLHS spLhsInfo spLhsDefName spLhsPats spLhsWithPats RewriteRHSWithRHS SpineClauseClause' clauseLHS clauseRHSclauseWhereDecls LetBindingLetOpenLetApply LetPatBindLetBind GetDefInfo getDefInfo ScopedDecl PatternSynDefRecDefRecSigDataDefFunDefSectionAxiomRenNoFunSigFunSigAssignsAssign ScopedExprConArgslhsCoreToSpinespineToLhsCore lhsCoreApplhsCoreAddSpinelhsCoreAllPatternslhsCoreToPattern mapLHSHeadPatternSynDefnsPatternSynDefn AnyAbstract anyAbstractallNames axiomNameapp patternToExprlambdaLiftExpr substPattern substExprsubstLetBindingssubstLetBindingsubstTypedBindingssubstTypedBindinginsertImplicitPatSynArgsExprLike traverseExprmapExpr Application unAppViewasViewisSetunScope deepUnScope IsProjElim isProjElimSuggestsuggestConPatternInfoProjP PatVarName ClauseBody ClauseBodyFNoBodyBindBody clauseRange clauseTel clausePermnamedClausePats clauseBody clauseType NotBlockedMetaIdmetaId LevelAtomUnreducedLevel NeutralLevel BlockedLevel MetaLevel PlusLevel ClosedLevelMaxDLubInfTele ExtendTelEmptyTelType'ElgetSortunElNoAbsabsNameunAbsArgNameElimsElimElim'ProjSharedMetaVExtLam LensConName getConName setConName mapConNameConHeadconName conFields NamedArgsargNameToStringstringToArgNameappendArgNames nameToArgName mapAbsNamesM mapAbsNamesreplaceEmptyName clausePatspatVarNameToStringnameToPatVarName namedVarP patternVarsproperlyMatching absurdBody isAbsurdBodyabsurdPatternNameisAbsurdPatternName ignoreSharingignoreSharingTypeshared sharedTypeupdateSharedFM updateSharedM updateShared pointerChaincompressPointerChainvar typeDontCaretopSortset0setpropsortvarSortsSuclevelSucmkTypeimpossibleTermsgTelhackReifyToMetaisHackReifyToMeta blockingMetablocked notBlockedignoreBlocking stripDontCarearityargNameunSpinehasElims argFromElim isApplyElim allApplyElimssplitApplyElims dropProjElims argsFromElimsshowTermFreeConf fcIgnoreSorts IgnoreSorts IgnoreAllIgnoreInAnnotations IgnoreNotFree freeVars' OccurrenceUnusedFlexible WeaklyRigid StronglyRigid Irrelevantly NoOccurrenceFreeVarsFVstronglyRigidVarsweaklyRigidVars flexibleVarsirrelevantVars unusedVars rigidVarsallVars relevantVars occurrencefreeVarsfreeInfreeInIgnoringSortsfreeInIgnoringSortAnnrelevantInIgnoringSortAnn relevantIn isBinderUsed EInterface constrTags definitions defDelayedconAritymainName relevantArgs forcedArgs injectiveFuns InjectiveFuninjArginjArity RelevantArgs ForcedArgsRelIrr NotForcedPrimTagpairwiseFilter notForcedforcedBranchDefaultBrIntbrIntbrTagbrNamebrVarsbrExpr IMPOSSIBLEUNITLFloatLStringLCharLIntEpicFun funEpicCode funInlinefunNamefunQName funCommentfunArgsfunExprInlineComment getBrVarslettlazycaseeappssubsts substBranchfvCompiledClausesFailDoneBranches conBranches litBranchescatchAllBranch WithAritycontent:-> emptyBrancheslitCaseconCasecatchAll prettyMapOneHolePatternOHConOneHolePatternsOHPatsFunArityfunArity clauseArgs clauseElimspatternsToElimsplugHoleallHolesallHolesWithContentsGetDefsgetDefs MonadGetDefsdoDefdoMeta GetDefsEnv lookupMetaembDefGetDefsMgetDefs'TermLike traverseTerm traverseTermMfoldTermcopyTermMatchLit BlockingVars BlockingVar blockingVarNoblockingVarConsMatchBlockPBlockNoYesMPatProjMPWildMPLitMPConMPVarMPmapBlockingVarConsclearBlockingVarConszipBlockingVars noMatchLit yesMatchLit matchLits matchClause matchPatsmatchPatfoldExprCompressedFilerangesHighlightingInfoFileaspect otherAspectsnotedefinitionSite OtherAspect TypeChecksIncompletePatternTerminationProblemUnsolvedConstraint UnsolvedMeta DottedPatternNameKindArgumentFunctionAspect PrimitiveTypeNumberseveral smallestPostoMapcompressedFileInvariantcompress decompressnoHighlightingInRange singletonCseveralCsplitAtC smallestPosCNiceDeclarationExceptionInvalidMeasureMutualInvalidTerminationCheckPragmaAmbiguousFunClausesWrongContentPostulateBlockUselessInstanceUselessAbstractUselessPrivateDeclarationPanicCodataUnknownNamesInFixityDeclNotAllowedInMutualWrongParametersWrongDefinitionMissingDataSignatureMissingTypeSignatureMissingWithClausesMissingDefinitionMultipleFixityDeclsNiceTypeSignatureNiceConstructorMeasureNiceDeclarationNiceUnquoteDeclNicePatternSyn NiceFunClause NiceDataSig NiceRecSig NicePragma NiceImportNiceOpenNiceModuleMacro NiceModule NiceMutualPrimitiveFunction NiceFieldrunNiceniceDeclarationsnotSoNiceDeclaration tokensParser exprParser moduleParser parseLiterate parseFile'handleParseExceptionfailOnExceptionMonadTCMliftTCMReduceM unReduceM ReduceEnvredEnvredStTCErr PatternErr IOException Exception TypeError LHSOrPatSynIsPatSynIsLHSNeedOptionCopatternsSafeFlagPrimTrustMeSafeFlagNoTerminationCheckSafeFlagPragmaSafeFlagPostulateIFSNoCandidateInScopeAmbiguousParseForLHS NoParseForLHSAmbiguousParseForApplicationNoParseForApplicationPatternSynonymArityMismatchUnusedVariableInPatternSynonymNothingAppliedToInstanceArgNothingAppliedToHiddenArgNotAValidLetBindingNotAnExpressionNotAModuleExprRepeatedVariablesInPatternInvalidPatternDuplicateImportsModuleDoesntExportPatternShadowsConstructorClashingModuleImportClashingImportClashingModuleClashingDefinitionUninstantiatedModuleAmbiguousModule AmbiguousName NoSuchModule NotInScopeBothWithAndRHSModuleDefinedInOtherFileClashingFileNamesForModuleNameDoesntMatchFileNameAmbiguousTopLevelModuleNameOverlappingProjects FileNotFoundCyclicModuleDependencyUnsolvedConstraints UnsolvedMetasLocalVsImportedModuleClashNotStrictlyPositive SplitError WithoutKErrorCoverageCantSplitTypeCoverageCantSplitIrrelevantTypeCoverageCantSplitOnUnreachableClausesCoverageFailureIncompletePatternMatchingModuleArityMismatchFieldOutsideRecordWithClausePatternMismatchUnexpectedWithPatternsDuplicateConstructorsDuplicateFields TooManyFields TooFewFieldsAbsurdPatternRequiresNoRHSNoRHSRequiresAbsurdPatternIllegalLetInTelescopeBuiltinInParameterisedModuleShadowedModuleNoSuchPrimitiveFunctionNoBindingForBuiltinDuplicateBuiltinBindingNoSuchBuiltinNameBuiltinMustBeConstructorGenericDocError GenericErrorMetaOccursInItselfMetaCannotDependOn NotLeqSortHeterogeneousEquality UnequalBecauseOfUniverseConflict UnequalSorts UnequalColors UnequalHidingUnequalRelevance UnequalTypes UnequalTermsVariableIsIrrelevantDefinitionIsIrrelevantSplitOnIrrelevant InvalidTypeSetOmegaNotValidTypeNotAProperTermNotAProjectionPatternShouldBeRecordPatternShouldBeRecordType ShouldBePi ShouldBeASort ShouldBeEmpty!WrongNumberOfConstructorArgumentsTooManyArgumentsInLHSCannotEliminateWithPatternIllformedProjectionPatternIlltypedPatternUninstantiatedDotPattern NotInductive ColorMismatchRelevanceMismatchHidingMismatchWrongIrrelevanceInLambdaWrongNamedArgumentWrongHidingInApplicationWrongHidingInLambdaWrongHidingInLHSDifferentAritiesDoesNotConstructAnElementOf6CantResolveOverloadedConstructorsTargetingSameDatatypeIndicesFreeInParametersIndexVariablesNotDistinct!IndicesNotConstructorApplications!ConstructorPatternInWrongDatatypeShouldBeApplicationOf&ShouldBeAppliedToTheDatatypeParameters#ShouldEndInApplicationOfTheDatatypeDataMustEndInSortPropMustBeSingletonTerminationCheckFailedCompilationError NotSupportedNotImplemented InternalErrorGenericSplitError CantSplitCoinductiveDatatypeIrrelevantDatatype NotADatatypeTerminationErrortermErrFunctions termErrCallsCallInfocallInfoTarget callInfoRange callInfoCallOccPos ArgumentTo NonPositivelyOcc OccClause occFunction occClauseOccCon occDatatypeoccConstructor occPositionExpandInstancesDontExpandInstanceArgumentsExpandInstanceArguments ExpandHiddenDontExpandLast ExpandLast AbstractModeIgnoreAbstractMode ConcreteMode LetBindingsCtxId ContextEntryctxIdctxEntryContext envContextenvLetBindingsenvCurrentModuleenvCurrentPathenvAnonymousModules envImportPathenvMutualBlockenvSolvingConstraintsenvAssignMetasenvActiveProblemsenvAbstractMode envRelevance envColorsenvDisplayFormsEnabledenvReifyInteractionPointsenvEtaContractImplicitenvRangeenvHighlightingRangeenvCallenvHighlightingLevelenvHighlightingMethodenvModuleNestingLevelenvAllowDestructiveUpdate envExpandLast envAppDefenvSimplificationenvAllowedReductionsenvCompareBlockedenvPrintDomainFreePienvInsideDotPatternenvReifyUnquotedHighlightingMethodIndirectDirectHighlightingLevel InteractiveNonInteractiveNoneBuiltinPrim BuiltinThings BuiltinInfo builtinName builtinDescBuiltinDescriptorBuiltinUnknownBuiltinPostulate BuiltinPrimBuiltinDataCons BuiltinDataTempInstanceTable InstanceTableNoHighlighting ScopeCheckLHSScopeCheckDeclarationScopeCheckExprCheckSectionApplicationCheckWithFunctionType CheckIsEmptyCheckPrimitive CheckPragma CheckFunDefCheckConstructor CheckRecDef CheckDataDefCheckArgumentsInferDefInferVarIsType_ IsTypeCallCheckPatternShadowingCheckDotPattern CheckExprCall InferExprCheckLetBinding CheckPattern CheckClause StatisticsMutualIdMutIdTermHeadConsHeadPiHeadSortHeadFunctionInverse'Inverse NotInjectiveFunctionInversePrimFun primFunName primFunArityprimFunImplementationAllowedReductionsAllowedReductionNonTerminatingReductionsLevelReductionsFunctionReductionsProjectionReductionsMaybeReducedElimsMaybeReducedArgs MaybeReducedMaybeRed isReduced ignoreReduced IsReducedReduced NotReduced YesReduction NoReductionSimplificationNoSimplificationYesSimplificationFieldsDefn primAbstrprimName primClauses primCompiledconPars conSrcConconDataconAbstrconIndrecPars recClause recConHead recNamedCon recConType recFieldsrecTel recMutualrecEtaEquality recInduction recRecursiverecAbstrdataPars dataSmallParsdataNonLinParsdataIxs dataInduction dataClausedataConsdataSort dataMutual dataAbstr funClauses funCompiledfunInv funMutualfunAbstr funDelayed funProjection funStaticfunCopy funTerminates funExtLamfunWith Projection projProper projFromType projIndex projDropPars projArgInfoGuardPos StrictPosJustPosJustNegMixedCompiledRepresentation CompiledRepcompiledHaskell exportHaskell compiledEpic compiledJS Nonvariant Invariant Contravariant Covariant HaskellExportHsExportHaskellRepresentationHsTypeHsDefnJSCodeEpicCode HaskellType HaskellCode Definition defArgInfodefNamedefType defPolaritydefArgOccurrences defDisplay defMutualdefCompiledRepdefRewriteRulestheDef RewriteRulerewName rewContextrewLHSrewRHSrewType RewriteRules DisplayTermDTermDDotDDefDConDWithApp DisplayFormDisplay dfFreeVarsdfPatsdfRHS secTelescope secFreeVars DefinitionsSections SignatureSig sigSectionssigDefinitionsInteractionPointsInteractionPointipRangeipMeta MetaStore NamedMeta nmSuggestionnmidMetaNameSuggestion miClosRangemiMetaOccursCheckmiNameSuggestionRunMetaOccursCheckDontRunMetaOccursCheck MetaPriorityTypeCheckingProblem CheckArgs CheckExprMetaInstantiationPostponedTypeCheckingProblem BlockedConstOpenIFSInstSInstVFrozen InstantiableListenerCheckConstraint EtaExpand MetaVariableMetaVarmvInfo mvPriority mvPermutation mvJudgementmvInstantiation mvListenersmvFrozen JudgementIsSortHasTypejMetaId jMetaType OpenThingopenThingCtxIds openThingCompareDirectionDirGeqDirLeqDirEq ComparisonCmpLeqCmpEq FindInScopeIsEmptyGuardedUnBlockLevelCmpSortCmpTelCmpTypeCmpElimCmpValueCmpProblemConstraintPConstrconstraintProblem theConstraintClosure clSignatureclEnvclScopeclValue Interface iSourceHashiImportedModules iModuleNameiScope iInsideScope iSignatureiBuiltiniHaskellImports iHighlightingiPragmaOptions iPatternSynsDecodedModulesVisitedModules miInterface miWarningsSourceToModuleModuleToSource ProblemId FreshThingsFreshfMeta fInteractionfMutualfNamefCtxfProblemfIntPersistentTCStatePersistentTCStstDecodedModulesstPersistentOptionsstInteractionOutputCallback stBenchmarkTCSt stFreshThings stSyntaxInfostTokens stTermErrs stMetaStorestInteractionPointsstAwakeConstraintsstSleepingConstraintsstDirtystOccursCheckDefs stSignature stImportsstImportedModulesstModuleToSourcestVisitedModulesstCurrentModulestScope stPatternSynsstPatternSynImportsstInstanceDefsstPragmaOptions stStatisticsstMutualBlocksstLocalBuiltinsstImportedBuiltinsstHaskellImports stPersistentinitPersistentStatestBuiltinThingssourceToModule iFullHash buildClosurefromCmpflipCmpdirToCmpnormalMetaPrioritylowMetaPriorityhighMetaPriority getMetaInfo getMetaScope getMetaEnv getMetaSiggetMetaRelevance getMetaColorsemptySignaturedefaultDisplayForm defRelevance defColors defaultDefn noCompiledRep emptyFunctionrecCon defIsRecorddefIsDataOrRecord notReducedreduced allReductions defClauses defCompileddefJSDef defEpicDefdefNonterminatingdefCopy ifTopLevelAndHighlightingLevelIsinitEnv mapRedEnvmapRedSt mapRedEnvSt runReduceM runReduceF catchError_mapTCMTpureTCM returnTCMTbindTCMTthenTCMTfmapTCMTapTCMTpatternViolation internalError typeError typeError_runTCM runTCMTop runTCMTop' runSafeTCMforkTCMextendlambdanameabsurdLambdaNameisAbsurdLambdaNamescopeCheckImport prettyError ConditionallMetas newTelMetanewNamedValueMeta newValueMeta newIFSMetaassignassignVetaExpandMetaSafe assignTerm newArgsMeta newArgsMeta'GetBodygetBodygetBodyUnraised TeleNoAbs teleNoAbsListTelListTel'TelVtheTeltheCoreTelViewSubst applySubst SubstitutionLift:#WkEmptySIdSabstractapplyE canProjectconAppdefApp argToDontCarepiApplytelVars namedTelVars abstractArgsidSwkSraiseS singletonSdropScomposeSsplitS++# parallelSlookupSraise raiseFrom substUnder telFromList' telFromList telToList bindsToTel' bindsToTeltelView'mkPitelePi'telePitelePi_teleLamdLubabsAppabsBodymkAbsreAbsunderAbs underLambdassLublvlViewlevelMaxsortTm levelSortlevelTm unLevelAtom AbstractTerm abstractTerm IsPrefixOf isPrefixOfpiAbstractTermKillVarkillVarShrinkCshrinkCnoShrink SizedList unSizedListProjName unProjName unConName unDefNameVarName unVarNameNoTypeunNoTypeYesType unYesTypeGenCgenC UseLiteralsUseLit useLitInt useLitFloat useLitString useLitChar SortFreqssetFreqspropFreq HiddenFreqs hiddenFreq notHiddenFreq ElimFreqs applyFreqprojFreq TermFreqsvarFreqdefFreqconFreqlitFreqsortFreqlamFreqpiFreqfunFreq FrequenciesFreqs hiddenFreqs elimFreqs sortFreqs termFreqsTermConfigurationTermConftcDefinedNamestcConstructorNamestcProjectionNamestcFreeVariables tcLiterals tcFrequencies tcFixSizetcIsTypedefaultFrequenciesnoProp noLiterals fixSizeConf resizeConfdecrConfdivConf isTypeConf isntTypeConf extendConfextendWithTelConfmakeConfigurationfixSizegenArgsgenElimsgenConfkillAbs isWellScopedprop_wellScopedVars GiveResult Give_NoParen Give_Paren Give_StringStatussShowImplicitArgumentssChecked DisplayInfo Info_VersionInfo_HelperFunction Info_ContextInfo_InferredTypeInfo_CurrentGoal Info_GoalTypeInfo_NormalFormInfo_WhyInScopeInfo_ModuleContents Info_Auto Info_Intro Info_Error Info_AllGoalsInfo_ConstraintsInfo_CompilationOkMakeCaseVariantExtendedLambdaResp_ClearHighlightingResp_ClearRunningInfoResp_RunningInfoResp_DisplayInfo Resp_SolveAll Resp_MakeCaseResp_GiveActionResp_InteractionPointsResp_JumpToError Resp_StatusResp_HighlightingInfohighlightAsTypeCheckedCoinductionKit nameOfInf nameOfSharp nameOfFlat HasBuiltinsgetBuiltinThinglitTypesetBuiltinThingsbindBuiltinName bindPrimitive getBuiltin getBuiltin' getPrimitive' getPrimitiveconstructorFormconstructorForm' primInteger primFloatprimChar primStringprimBoolprimTrue primFalseprimListprimNilprimConsprimIOprimNatprimSucprimZero primNatPlus primNatMinus primNatTimesprimNatDivSucAuxprimNatModSucAuxprimNatEquality primNatLessprimSize primSizeLt primSizeSuc primSizeInf primSizeMaxprimInf primSharpprimFlat primEqualityprimRefl primRewrite primLevel primLevelZero primLevelSuc primLevelMax primIrrAxiom primQNameprimArg primArgArg primAgdaSort primAgdaTypeprimAgdaTypeEl primHiding primHidden primInstance primVisible primRelevance primRelevantprimIrrelevant primArgInfoprimArgArgInfoprimAgdaSortSetprimAgdaSortLitprimAgdaSortUnsupported primAgdaTermprimAgdaTermVarprimAgdaTermLamprimAgdaTermExtLamprimAgdaTermDefprimAgdaTermConprimAgdaTermPiprimAgdaTermSortprimAgdaTermLitprimAgdaTermUnsupportedprimAgdaLiteralprimAgdaLitNatprimAgdaLitFloatprimAgdaLitCharprimAgdaLitStringprimAgdaLitQNameprimAgdaFunDefprimAgdaFunDefConprimAgdaDataDefprimAgdaRecordDefprimAgdaPatternprimAgdaPatConprimAgdaPatVarprimAgdaPatDotprimAgdaPatLitprimAgdaPatProjprimAgdaPatAbsurdprimAgdaClauseprimAgdaClauseClauseprimAgdaClauseAbsurdprimAgdaDefinitionFunDefprimAgdaDefinitionDataDefprimAgdaDefinitionRecordDef!primAgdaDefinitionDataConstructorprimAgdaDefinitionPostulateprimAgdaDefinitionPrimitiveprimAgdaDefinition builtinNat builtinSuc builtinZerobuiltinNatPlusbuiltinNatMinusbuiltinNatTimesbuiltinNatDivSucAuxbuiltinNatModSucAuxbuiltinNatEqualsbuiltinNatLessbuiltinInteger builtinFloat builtinChar builtinString builtinBool builtinTrue builtinFalse builtinList builtinNil builtinCons builtinIO builtinSize builtinSizeLtbuiltinSizeSucbuiltinSizeInfbuiltinSizeMax builtinInf builtinSharp builtinFlatbuiltinEquality builtinReflbuiltinRewritebuiltinLevelMax builtinLevelbuiltinLevelZerobuiltinLevelSucbuiltinIrrAxiom builtinQNamebuiltinAgdaSortbuiltinAgdaSortSetbuiltinAgdaSortLitbuiltinAgdaSortUnsupportedbuiltinAgdaTypebuiltinAgdaTypeEl builtinHiding builtinHiddenbuiltinInstancebuiltinVisiblebuiltinRelevancebuiltinRelevantbuiltinIrrelevant builtinArgbuiltinArgInfobuiltinArgArgInfo builtinArgArgbuiltinAgdaTermbuiltinAgdaTermVarbuiltinAgdaTermLambuiltinAgdaTermExtLambuiltinAgdaTermDefbuiltinAgdaTermConbuiltinAgdaTermPibuiltinAgdaTermSortbuiltinAgdaTermLitbuiltinAgdaTermUnsupportedbuiltinAgdaLiteralbuiltinAgdaLitNatbuiltinAgdaLitFloatbuiltinAgdaLitCharbuiltinAgdaLitStringbuiltinAgdaLitQNamebuiltinAgdaFunDefbuiltinAgdaFunDefConbuiltinAgdaClausebuiltinAgdaClauseClausebuiltinAgdaClauseAbsurdbuiltinAgdaPatternbuiltinAgdaPatVarbuiltinAgdaPatConbuiltinAgdaPatDotbuiltinAgdaPatLitbuiltinAgdaPatProjbuiltinAgdaPatAbsurdbuiltinAgdaDataDefbuiltinAgdaRecordDefbuiltinAgdaDefinitionFunDefbuiltinAgdaDefinitionDataDefbuiltinAgdaDefinitionRecordDef$builtinAgdaDefinitionDataConstructorbuiltinAgdaDefinitionPostulatebuiltinAgdaDefinitionPrimitivebuiltinAgdaDefinitioncoinductionKitprimEqualityName HasOptions pragmaOptionscommandLineOptions VerboseKey reportSDoc reportSLnverboseS hasVerbositygetIncludeDirsifNoConstraints_ noConstraintssolveAwakeConstraints'solveConstraint resetState resetAllState localTCStateupdatePersistentStatemodifyPersistentStategetScopesetScope modifyScope withScope withScope_ localScope notInScope printScopemodifySignaturemodifyImportedSignature getSignaturegetImportedSignature setSignaturesetImportedSignature withSignaturelookupDefinitionupdateDefinition updateTheDef updateDefTypeupdateDefArgOccurrencesupdateDefPolarityupdateDefCompiledRepupdateFunClausessetTopLevelModulewithTopLevelModuleaddHaskellImportgetHaskellImportsgetInteractionOutputCallbackappInteractionOutputCallbacksetInteractionOutputCallbackgetPatternSynssetPatternSynsmodifyPatternSynsgetPatternSynImportslookupPatternSyn theBenchmarkupdateBenchmark getBenchmarkmodifyBenchmarkfreshTCMaddSignatureInstancesupdateInstanceDefsmodifyInstanceDefsgetAllInstanceDefsgetAnonInstanceDefsclearAnonInstanceDefsaddUnknownInstanceaddNamedInstance benchmarkingreportBenchmarkingLnreportBenchmarkingDocbillTobillTopbillSub billPureTo reimburse reimburseTop FindError AmbiguousNotFoundtoIFilefindErrorToTypeErrorfindFile findFile' findFile''findInterfaceFilecheckModuleName moduleName' moduleNameLensPersistentVerbositygetPersistentVerbositysetPersistentVerbositymapPersistentVerbosityPersistentVerbosityLensIncludeDirssetIncludeDirsmapIncludeDirs LensSafeMode getSafeMode setSafeMode mapSafeModeSafeModeLensCommandLineOptionsgetCommandLineOptionssetCommandLineOptionsmapCommandLineOptions LensVerbosity getVerbosity setVerbosity mapVerbosityLensPragmaOptionsgetPragmaOptionssetPragmaOptionsmapPragmaOptionsmodifyPragmaOptionsmodifyVerbosity putVerbositymodifyCommandLineOptionsmodifySafeMode putSafeModemodifyIncludeDirsputIncludeDirsmodifyPersistentVerbosityputPersistentVerbosity RelativeTo CurrentDir ProjectRootsetOptionsFromPragmaenableDisplayFormsdisableDisplayFormsdisplayFormsEnableddontEtaContractImplicitdoEtaContractImplicitshouldEtaContractImplicitdontReifyInteractionPointsshouldReifyInteractionPoints setInputFile getInputFile hasInputFileproofIrrelevancehasUniversePolymorphismshowImplicitArgumentsshowIrrelevantArgumentswithShowAllArgumentsignoreInterfacespositivityCheckEnabled typeInTypedisplayDebugMessagereportSverboseBracketRangeAndPragma DontTouchMe ToConcrete toConcretebindToConcreteAbsToConEnvmakeEnv noTakenNames runAbsToConabstractToConcreteEnvabstractToConcreteCtxabstractToConcrete_ toConcreteCtxWSMOut ResolvedName UnknownNamePatternSynResNameConstructorName FieldName DefinedNameScopeMisDatatypeModulegetCurrentModulesetCurrentModulewithCurrentModulewithCurrentModule' getNamedScopegetCurrentScope createModulemodifyScopeInfo modifyScopesmodifyNamedScopemodifyCurrentScopemodifyNamedScopeMmodifyCurrentScopeMmodifyCurrentNameSpacesetContextPrecedencegetContextPrecedencewithContextPrecedence getLocalVars setLocalVars withLocalVarsfreshAbstractNamefreshAbstractName_freshAbstractQName resolveName resolveName' resolveModule getFixity bindVariablebindName rebindName bindModule bindQModule stripNoNames copyScopeapplyImportDirectiveM openModule_updateSharedTermupdateSharedTermFupdateSharedTermTforceEqualTermsdisableDestructiveUpdatetranslateCopatternClausesIsExprexprView unExprViewExprViewParenVLamV InstanceArgV HiddenArgVOpAppVAppVOtherVWildVLocalVpartPpostopopPrebuildrebuildBindingprefixPpostfixPinfixlPinfixrPinfixPnonfixPargsPappPatomP UseBoundNamesDontUseBoundNamesgetDefinedNames buildParser buildParserspatternAppViewparsePatparseLHS parsePatternparsePatternSynvalidConPattern patternQNamesqualifierModulesparseApplicationparseModuleApplication fullParenparenmpareninterestingCall traceCallM traceCall traceCall_ traceCallCPS traceCallCPS_getCurrentRangesetCurrentRange currentModulegetAnonymousVariableswithAnonymousModulewithEnvgetEnvwithIncreasedModuleNestingLevelwithHighlightingLevel doExpandLastdontExpandLastperformedSimplificationperformedSimplification'getSimplificationonlyReduceProjectionsdontReduceProjectionsdontReduceLevelsallowAllReductionsallowNonTerminatingReductionsinsideDotPatternisInsideDotPatternisReifyingUnquotednowReifyingUnquotedcheckArguments'checkArguments checkExprisType_eligibleForProjectionLikemakeProjectioninitializeIFSMeta composePolcomputePolarity enterClosureMonadExceptionthrowExceptioncatchException ExceptionT runExceptionT getContextId getContext killRangeMapcurrentProblemstealConstraintssolvingProblemisProblemSolvedgetConstraintsForProblemgetAwakeConstraintswakeConstraintsdropConstraintsputAllConstraintsToSleeptakeAwakeConstraintgetAllConstraintswithConstraintbuildProblemConstraintbuildConstraintaddConstraint'addAwakeConstraintsnowSolvingConstraintsisSolvingConstraintsmapAwakeConstraintsmapSleepingConstraintsmodifyAwakeConstraintsmodifySleepingConstraintsmakeOpen makeClosedgetOpentryOpen AddContext addContextmodifyContextEntrymodifyContextEntries modifyContextmkContextEntry inContext inTopContext escapeContextaddCtxaddCtxs addCtxString addCtxString_addCtxStrings_dummyDomunderAbstractionunderAbstraction_ addCtxTel addLetBindinggetContextSizegetContextArgsgetContextTermsgetContextTelescopelookupBV typeOfBV'typeOfBVnameOfBV getVarInfo UnFreezeMeta unfreezeMetaIsInstantiatedMetaisInstantiatedMetadontAssignMetas getMetaStoremodifyMetaStore updateMetaVargetMetaPriority isSortMeta isSortMeta_ getMetaTypegetMetaTypeInContextisInstantiatedMeta'createMetaInfocreateMetaInfo'setValueMetaNamegetMetaNameSuggestionsetMetaNameSuggestionupdateMetaVarRangemodifyInteractionPointsregisterInteractionPointconnectInteractionPointremoveInteractionPointgetInteractionPointsgetInteractionMetasgetInteractionIdsAndMetasisInteractionMetalookupInteractionPointlookupInteractionIdnewMeta'getInteractionRange getMetaRangegetInteractionScope withMetaInfo' withMetaInfogetInstantiatedMetas getOpenMetas listenToMetaunlistenToMetagetMetaListenersclearMetaListeners freezeMetas unfreezeMetasisFrozen LeftHandSide AbstractRHS RightHandSideLetDefLetDefs TopLevelInfo topLevelDecls outsideScope insideScopeTopLevel topLevelPathtopLevelTheThing OldModuleNameNewModuleQName NewModuleNameAPatNamePatNameOldNameOldQNameNewName ToAbstract toAbstractconcreteToAbstract_concreteToAbstractlocalToAbstract addImportaddImportCycleCheck getImports isImported getImportPath visitModulesetVisitedModulesgetVisitedModules isVisitedgetVisitedModulegetDecodedModulessetDecodedModulesgetDecodedModulestoreDecodedModuledropDecodedModulewithImportPathcheckForImportCycle noMutualBlock inMutualBlocksetMutualBlockgetMutualBlockscurrentOrFreshMutualBlocklookupMutualBlockfindMutualBlock HasConstInfo getConstInfo addConstant setTerminatesmodifyFunClauses addClausesaddHaskellCodeaddHaskellExportaddHaskellType addEpicCode addJSCode markStaticunionSignatures addSection lookupSectionaddDisplayForms applySectionaddDisplayForm canonicalNamesameDef whatInductionsingleConstructorType getConInfo getPolarity' setPolaritygetArgOccurrencesgetArgOccurrencesetArgOccurrences getMutual setMutualmutuallyRecursive getSectiongetSecFreeVarsgetModuleFreeVarsgetDefFreeVarsfreeVarsToApplyinstantiateDef makeAbstractinAbstractModeinConcreteModeignoreAbstractModetreatAbstractlytreatAbstractly' typeOfConst relOfConst colOfConst sortOfConst isProjection isProjection_isProperProjectionprojectionArgsapplyDef getDefTypegetConstructorData getConHead SizeMaxViewSizeViewComparableYesBelowYesAbove NotComparable DeepSizeView DOtherSize DSizeMetaDSizeVarDSizeInfSizeView OtherSizeSizeSucSizeInf BoundedSize BoundedNo BoundedLt isSizeTypeisSizeTypeTestgetBuiltinDefNamegetBuiltinSizeisSizeNameTestisSizeNameTestRawhaveSizedTypesbuiltinSizeHook sizeType_sizeType sizeSucNamesizeSucsizeSuc_sizeMaxsizeViewsizeViewComparable sizeViewSuc_ sizeViewPredsizeViewOffset removeSucs unSizeViewunDeepSizeView maxViewMax maxViewConssizeViewComparableWithMax maxViewSuc_ unMaxView getStatisticsticktickNtickMaxIMreadlinerunIMDotMDotState dsModules dsNameSupply dsConnectionModuleIdinitialDotState addModule addConnectiondottify generateDot generateHTMLtermleqType equalSort equalType equalTerm compareLevel compareSort compareTel compareType compareElims compareArgs compareAtom compareTermisGeneratedRecordConstructoretaContractRecordgetRecordFieldNames isEtaRecordisRecordirrelevantOrUnusedunusableRelevancecomposeRelevanceinverseComposeRelevance ignoreForcedirrToNonStrictnonStrictToIrrhideAndRelParamsinverseApplyRelevanceapplyRelevance workOnTypes doWorkOnTypes workOnTypes'applyRelevanceToContextwakeIrrelevantVars prop_galois PrettyTCM prettyTCM$$<+><>sepvcathsepfseptextlispifyHighlightingInfoshowAprettyAprettyAsshowATop prettyATop callCompiler callCompiler' generateLaTeXEmbPrjencodedecodeencodeInterface encodeFiledecodeInterface decodeHashes decodeFile setInterfacecurIFcurSigcurMNamecurHsModcurDefssigMNameihnameunqhnametlmodOftlmnamexqualxhqnconhqnbltQualdsubnamehsVarUQmazstrmazNamemazMod'mazModmazerror mazCoercemazIncompleteMatchrtmIncompleteMatchmazRTErtmModrtmQualrtmVarrtmErrorunsafeCoerceModfakeDfakeDSfakeDQfakeTypefakeExpdummyencodeModuleNameWrapunwrap prettyPrintvimFileescape wordBoundedmatchestoVimgenerateVimFileDropArgsdropArgs recursiveanyDefscheckSectionApplication checkDecl checkDecls traceSDoctraceSLn BinAppViewNoApp binAppView etaContractetaOncematchCompiledE matchCompiled isEmptyTypeaddForcingAnnotationsforcedVariablesforce MentionsMeta mentionsMetaExpandPatternSynonymsexpandPatternSynonymsexpandLitPatternDontKnowmatchCopatterns matchPatternsInstantiateFullinstantiateFull' Normalise normalise'Simplify simplify'reduce'reduceB' Instantiate instantiate' instantiateinstantiateFullreducereduceB normalisesimplify ifBlocked ifBlockedTypeunfoldDefinitionunfoldDefinitionEunfoldDefinition' reduceDefCopy reduceDef reduceDef_ reduceHead reduceHead'appDef_appDefE_appDefappDefEappDef'appDefE'simplifyBlocked'SplitTel firstPart secondPart splitPermOutputTypeNameNoOutputTypeNameOutputTypeNameNotYetKnowngetOutputTypeNamerenameP renamingR flattenTel reorderTel reorderTel_ unflattenTel teleNames teleArgNamesteleArgssplitTelescopetelView telViewUpTo telViewUpTo'piApplyMaddTypedInstanceresolveUnknownInstanceDefsgetInstanceDefs DataOrRecordIsRecordIsData getConTerm getConFormgetOrigConHeadgetOrigConTermgetConstructorArity isDatatypeisDataOrRecordTypeisDataOrRecordgetNumberOfParametersprop_telToListInvprop_flattenTelScopeprop_flattenTelInvprop_reorderTelStableprop_splitTelescopeScopeprop_splitTelescopePermScopeCompile CompileState nameSupplycompiledModules curModuleimportedModulescurFuninitCompileState epicErrormodifyEIgetsEIgetTypeunqnameresetNameSupply getDelayed putDelayednewName putConstrTagassignConstrTagassignConstrTag' getConData getDataCon getConstrTag getConstrTag' addDefName topBindings getConArity putConArityputMaingetMain lookInterface constrInScope getForcedArgs putForcedArgs replaceAtconstructorAritybindExprcaseOpts caseOptsExprmakeForcedArgs forceConstrsforceFun prettyEpicFun prettyEpic getNatishisNatishnrRelisRecargIsDef PrimTransformPrimTFmapCon translateCaseprZeroprSucprTrueprFalseprPred prNatEquality primitivise initialPrims getBuiltinshead'' natPrimTF primNatCaseZS primNatCaseZD boolPrimTFprimFunprimExprLevelKitlvlTypelvlSuclvlMaxlvlZerotypeNamesucNamemaxNamezeroNamemlevel levelTypelevelSucFunctionbuiltinLevelKit requireLevelsunLevelreallyUnLevelViewunlevelWithKitunPlusV maybePrimCon maybePrimDef levelView levelView'levelLub displayFormmatchDisplayForm NamedClauseReifyreify reifyWhen reifyPatterns PrettyContextDoccommacolonequalshcat$+$nestbracesbracketsparens prettyList punctuateWarningsterminationProblemsunsolvedMetaVariablesunsolvedConstraintswarningsToError tcErrString orderFields recordModule getRecordDefgetRecordOfFieldrecordFieldNamesfindPossibleRecordsgetRecordFieldTypesgetRecordTypeFieldsgetRecordConstructorTypegetRecordConstructor isRecordType tryRecordType projectTypeisEtaConisInductiveRecordisEtaRecordTypeisRecordConstructorunguardedRecordrecursiveRecordisRecursiveRecord recRecursive_etaExpandBoundVarcurryAtetaExpandRecordetaExpandRecord_etaExpandAtRecordTypeisSingletonRecord isSingletonRecordModuloRelevanceisSingletonRecord'isSingletonTypeisSingletonTypeModuloRelevanceisSingletonType'emap HaskellKindhsStarhsKFunhsFunhsUnithsVarhsApphsForallnotAHaskellKindnotAHaskellType getHsTypegetHsVar isHaskellKind haskellKind haskellTypeErasure ErasureState relevanciesfunsisIrrisRel||-&&-erasure removeUnusedinitiate initialRelsrelevantstepdiffTagseqGroups constrGroupTagEqIsTagSame Injectible<:InjConstraints findInjection replaceFunCC isInjective patternToTermnrBinds substForDotisInjectiveHerelitToConlitIntinsertAtemptyCunionConstraints initialTagsunifysetTag mergeGroups unifiable!!!!defnParssmash'em inferable inferableTerm smashable buildLambdaLHSState lhsProblemlhsSubstlhsDPIlhsAsB AsBindingAsBDotPatternInstDPI SplitPanicNothingToSplit SplitProblem SplitRestsplitProjection splitRestTypeSplitFocusLitFocusfocusCon focusImplicit focusConArgs focusRange focusOutPat focusHoleIx focusDatatype focusParams focusIndices focusType ProblemRestrestPatsrestType ProblemPartProblemProblem' problemInPat problemOutPat problemTel problemRest FlexibleVar flexHidingflexKindflexVarFlexibleVarKindDotFlex ImplicitFlex RecordFlex FlexibleVarsdefaultFlexibleVarflexibleVarFromHidingCallPath callInfosUsableSizeVarsusableSizeVars DeBruijnPat'ProjDBPLitDBPConDBPVarDBP DeBruijnPat DeBruijnPatsTerMterMMonadTerterAskterLocalterAsksTerEnvterUseDotPatternsterGuardingTypeConstructorsterInlineWithFunctions terSizeSucterSharp terCutOff terCurrent terMutual terUserNames terTarget terDelayed terMaskArgs terMaskResult terPatternsterPatternsRaise terGuarded terUseSizeLt terUsableVarsTarget MutualNames defaultTerEnvrunTermterGetGuardingTypeConstructorsterGetInlineWithFunctionsterGetUseDotPatternsterSetUseDotPatterns terGetSizeSuc terGetCurrent terSetCurrent terGetSharp terGetCutOff terGetMutualterGetUserNames terGetTarget terSetTarget terGetDelayed terSetDelayedterGetMaskArgsterSetMaskArgsterGetMaskResultterSetMaskResultterGetPatternsterSetPatternsterRaise terGetGuardedterModifyGuarded terSetGuarded terUnguarded terPiGuardedterGetUsableVarsterModifyUsableVarsterSetUsableVarsterGetUseSizeLtterModifyUseSizeLtterSetUseSizeLtwithUsableVars conUseSizeLt projUseSizeLtisProjectionButNotCoinductiveisCoinductiveProjection unusedVarraiseDBPEvaluateevaluatenormaliseStatic evaluateCC etaExpandfromAgda translateDefn reverseCCBody substTermsubstLitcheckTypeOfMainimportsForPrim declsForPrimmazNatToIntegermazIntegerToNat mazNatToInt mazIntToNatmazCharToIntegermazListToHListmazHListToListmazListToStringmazStringToListmazBoolToHBoolmazHBoolToBoolxForPrimprimBodyreplpconNamehasCompiledDatabltQual'inlineWithClausesisWithFunctionexpandWithFunctionCallSizeConstraintLeqSizeMeta isBoundedboundedSizeMetaHook trySizeUniv deepSizeView sizeMaxView compareSizescompareMaxViewscompareBelowMaxcompareSizeViewstrivial isSizeProblemisSizeConstraintgetSizeConstraints getSizeMetascomputeSizeConstraintscomputeSizeConstraintsizeExprflexibleVariablescanonicalizeSizeConstraintsolveSizeConstraints oldSolverResulttermDeclrecordPatternToProjectionstranslateCompiledClausestranslateSplitTreetranslateRecordPatternsStackFrameunfoldCorecursionEunfoldCorecursion Candidates CandidateinitialIFSCandidates findInScope findInScope'rigidlyConstrainedMetascheckCandidatesapplyDroppingParameterscatchConstraint newProblem newProblem_ifNoConstraintsguardConstraintwhenConstraintswakeupConstraintswakeupConstraints_solveAwakeConstraintssolveConstraint_checkTypeCheckingProblem PruneResultPrunedEverythingPrunedSomething PrunedNothingNothingToPruneOccursoccurs metaOccursVarsUnfoldStrategyNoUnfold YesUnfold OccursCtxIrrelmodifyOccursCheckDefsinitOccursCheckdefNeedsCheckingtallyDefdefArgsunfoldleaveTopweaklystronglypatternViolation'abort goIrrelevant allowedVar takeRelevant liftUnderAbs occursCheckprune hasBadRigid isNeutralrigidVarsNotContainedInkillArgs killedType performKill InvertExcept ProjectedVar NeutralArg CantInvertRes SubstCandFVs ProjVarExcNoProjectedVarnoProjectedVarMetaKindLevelsSingletonRecordsRecordsfindIdx isBlockedTermisEtaExpandable assignTerm' newSortMetanewSortMetaCtx newTypeMeta newTypeMeta_ newIFSMetaCtxnewValueMetaCtx newValueMeta'newValueMetaCtx' trueConditionnewArgsMetaCtxnewArgsMetaCtx' newRecordMetanewRecordMetaCtxnewQuestionMark blockTermblockTermOnProblemblockTypeOnProblemunblockedTesterpostponeTypeCheckingProblem_postponeTypeCheckingProblem problemTypeetaExpandListenerswakeupListener allMetaKinds etaExpandMetaetaExpandBlocked assignWrapperattemptInertRHSImprovement assignMeta assignMeta'subtypingForSizeLtexpandProjectedVarsetaExpandProjectedVarcheckLinearity inverseSubst updateMetaPartialFullprintHighlightingInfogenerateAndPrintSyntaxInfogenerateTokenInfogenerateTokenInfoFromStringprintErrorInfoerrorHighlightingprintUnsolvedInfocomputeUnsolvedMetaWarningscomputeUnsolvedConstraints testSuiteSynEqcheckSyntacticEquality HasPolarity polaritiesneg polFromOcc nextPolaritypurgeNonvariantenablePhantomTypesdependentPolarityrelevantInIgnoringNonvariantmkUnusednonvariantToUnusedArgnonvariantToUnusedArgInDefnonvariantToUnusedArgInClause sizePolaritycheckSizeIndexpolarityImplicitInsertionNoInsertNeeded NoSuchName BadImplicits ImpInsert implicitArgsimplicitNamedArgs impInsertinsertImplicitinstantiateTelnothingToSplitError foldMatchmatchCopattern matchPatternyesSimplificationWithNodeArgNodeDefNodeComputeOccurrences occurrencesOccMOccEnvvarsinf OccurrencesItemADefAnArg OccursWhereUnknownHereInDefOfMatchedInClause IndArgType ConArgTypeMetaArgVarArgUnderInfDefArg LeftOfArrowcheckStrictlyPositive getDefArity>+< concatOccursoccursAshere onlyVarsUpTowithExtendedOccEnvgetOccurrencescomputeOccurrencesetaExpandClausebuildOccurrenceGraph computeEdgeProjectionView NoProjectionLoneProjectionLike projViewProj projViewSelf projViewSpine unProjViewprojViewreduceProjectionLikeelimViewUnquotedFunDefUnQFununquote quotingKit quoteName quoteConName quoteTerm quoteType agdaTermType qNameTypeisConunquoteFailedGeneric unquoteFailedunquoteHunquoteN ensureDef ensureConpickName reifyUnquotedPredOpFromTermfromTermFromTermFunctionToTermtoTermtoTermRPrimTermprimTermPrimTypeprimTypeLvlunLvlunNatunStr PrimitiveImplPrimImpl buildListredBind redReturnfromReducedTerm fromLiteral primTrustMe primQNameTypeprimQNameDefinitionprimDataConstructorsmkPrimLevelZeromkPrimLevelSucmkPrimLevelMax mkPrimFun1TCM mkPrimFun1 mkPrimFun2 mkPrimFun4-->.-->gpihPinPivarMgApply<@><#>listioeltsetargNdomNargHdomHprimitiveFunctionslookupPrimitiveFunctionlookupPrimitiveFunctionQInvViewNoInvInv headSymbolcheckInjectivityfunctionInverseuseInjectivity tryConversionsameVars intersectVars equalAtom convError unifyPointersassignEcompareTermDir compareTerm' etaInequalcompareAtomDircompareRelevancecompareIrrelevantcompareWithPolcoerce coerceSizeleqSortleqLevel equalLevel bothAbsurd ShapeViewElseShMetaShSortShLitShVarShDefShFunShPiShSubstHH substUnderHH trivialHHApplyHHapplyHHArgsHH TelViewHHTelHHTypeHHTermHHHomHetHetHomUnificationResultNoUnifyUnifiesUReduceureduce UnifyStateUStuniSub uniConstrUnifyExceptionGenericUnifyExceptionWithoutKExceptionUnclearOccurrenceStronglyRigidOccurrenceConstructorMismatchEquality UnifiablePossibly Definitely UnifyOutputUnifyEnvUnifyMayPostponeMayNotPostpone MayPostponeUnifyUunUnify emptyUEnv noPostponing askPostpone emptyUOutputreportPostponingifClean emptyUStateprojectionMismatchconstructorMismatchconstructorMismatchHHonSubmodSubcheckEqualities checkEqualitycheckEqualityHHforceHommakeHom addEquality addEqualityHHtakeEqualities|->makeSubstitutionflattenSubstitutionisHomfromHomleftHHrightHHabsAppHHsubstHH unifyIndices_ unifyIndicesdataOrRecordTypedataOrRecordType'dataOrRecordTypeHHdataOrRecordTypeHH'isEtaRecordTypeHH shapeView shapeViewHH telViewUpToHHdataParametersdataParametersTCMreport piApplyM' insertTelemkConunifyItakeTele remForced forcedExpr replaceForced buildTerm findPosition checkType checkInternal splitProblemcheckParsIfUnambiguouswellFormedIndices withTypesFrombindBuiltinFlatbindBuiltinSharpbindBuiltinInf checkDataDef smallParamscheckConstructorbindParametersfitsIn constructs isCoinductiveHypSizeConstraint sizeContext sizeHypIdssizeHypothesessizeConstraint DBSizeExpr sizeMetaId sizeMetaArgs NamedRigid rigidName rigidIndexsolveSizeConstraints_ solveClustergetSizeHypotheses unSizeExpr checkFunDef' checkFunDefinsertImplicitProblemexpandImplicitPatternexpandImplicitPattern' implicitPinsertImplicitPatternsinsertImplicitPatternsTwithFunctionTypebuildWithFunctionstripWithClausePatternswithDisplayForm patsToTermsuseNamesFromPattern noProblemRestproblemFromPatsupdateProblemRest_updateProblemRest LHSResultlhsPatternTele lhsVarTelelhsSubstitution lhsVarNames lhsPatterns lhsBodyTypelhsPermutationflexiblePatternsdotPatternInstsinstantiatePatternisSolvedProblemnoShadowingOfConstructorscheckDotPattern bindLHSVarsbindAsPatternscheckLeftHandSidenoPatternMatchingOnCodataCoverMCovering covSplitArgcovSplitClauses SplitClauseSClausescTelscPermscPatsscSubstscTarget splitClausesclauseToSplitClause checkCoverage coverageCheckcover splitStrategy fixTargetcomputeNeighbourhoodsplitClauseWithAbsurd splitLastsplitdbIndexToLevelsplit' splitResultClsClcompileWithSplitTreecompile nextSplitisVarsplitOnsplitCexpandCatchAlls substBody ConvColor convColorLamOrPiPiNotLamLamNotPiisType isTypeEqualToleqType_checkTelescope_checkTypedBindings_checkTypedBindingscheckTypedBinding checkLambdacheckAbsurdLambdacheckExtendedLambdacheckRecordExpressioncheckRecordUpdate checkLiteralcheckApplication domainFree checkMeta inferMetacheckOrInferMeta inferHeadinferDefcheckConstructorApplicationcheckHeadApplication traceCallEcheckArguments_ inferExprdefOrVarcheckDontExpandLastinferExprForWithcheckLetBindingscheckLetBinding checkRecDefcheckRecordProjectionsWithFunctionProblem WithFunction wfParentNamewfName wfParentTel wfBeforeTel wfAfterTelwfExprs wfExprTypes wfRHSType wfParentPats wfPermSplit wfPermParent wfPermFinal wfClausesNoWithFunctionisAlias checkAliasinsertPatterns checkClausecheckWithFunction checkWherecontainsAbsurdPatternrewriteverifyBuiltinRewriteRelView relViewTel relViewDelta relViewType relViewType' relViewCorerelViewaddRewriteRuleaddRewriteRulesupdateRewriteRules rewriteWithbindPostulatedName bindBuiltininstantiateDefinitionTypecheckTermination_checkPositivity_checkCoinductiveRecordscheckInjectivity_checkProjectionLikeness_ checkAxiomcheckPrimitive checkPragma checkMutualcheckTypeSignature checkSectioncheckModuleAritycheckSectionApplication' checkImport MaybeWarnings SomeWarnings NoWarningsmergeInterfaceaddImportedThings hasWarningsalreadyVisited typeCheckMain typeCheck getInterface getInterface_ getInterface'highlightFromInterface readInterfacewriteInterfacecreateInterfacebuildInterfacegetInterfaceFileHashessafeReadInterface moduleHash isNewerThan compilerMainimports definitioncheckConstructorType checkCoverconArityAndParsclauseargpatts clausebodyterm'hslitlitqnamecondeclcdecltvaldeclinfodeclhsCasthsCast'hsCoerce writeModule rteModuleexplicitForAll compileDiroutFile'outFileoutFile_callGHCprefixjsMod jsFileNamejsMemberglobal'globalreorderreorder'isTopLevelValue isEmptyObject insertAfternumParsmappingmapping'pattern visitorNameargs dummyLambdaOutputConstraint'OfType'ofNameofExprOutputConstraint FindInScopeOF IsEmptyTypePostponedCheckArgs TypedAssignGuardCmpSortsJustSortCmpTeles CmpLevelsCmpTypesJustTypeCmpElim CmpInTypeOfType OutputFormRewrite Normalised Simplified HeadNormal InstantiatedAsIs parseExpr parseExprIngive evalInCurrent evalInMeta normalForm outputFormIdshowComparisonjudgToOutputFormgetConstraintsgetSolvedInteractionPoints typeOfMetaMI typeOfMeta typeOfMeta'typesOfVisibleMetastypesOfHiddenMetasmetaHelperType contextOfMeta typeInCurrent typeInMetawithInteractionId withMetaId introTactic atTopLevel parseNamemoduleContentsCommandExitCodeReturn ContinueInContinue matchCommand interaction continueAfterloadFileshowConstraints showMetas showScope metaParseExpr actOnMetagiveMeta refineMetaretryConstraintsevalInevalTermtypeOftypeIn showContext splashScreenhelp CaseContext FunctionDef findClauseparseVariablesmakeCasemakeAbsurdClausemakeAbstractClause deBruijnIndex typeOfInf typeOfSharp typeOfFlatTOMSsConstssMetassEqssCurMeta sMainMetaMapSTModeTMAllOnorminitMapSpopMapStomygetConstgetdfvgetMetagetEqscopatternsNotImplemented tomyClauses tomyClausetomyPattomyBodyweakenweakenstomyTypetomyExptomyExpstomyIneqfmTypefmExpfmExpsfmLevelcnvhicnvhfrommy frommyType frommyExp frommyExps abslamvarnamemodifyAbstractExprmodifyAbstractClause constructPats frommyClausecontains_constructoretaContractBodynegtypefindClauseDeep matchTypeauto GiveRefineRefineGiveBackendJSEpic MAlonzoNoMainMAlonzo GoalCommandParseIOTCM'IOTCM Interaction'Cmd_show_versionCmd_why_in_scope_toplevelCmd_why_in_scope Cmd_compute Cmd_make_caseCmd_show_module_contentsCmd_goal_type_context_inferCmd_goal_type_context Cmd_goal_type Cmd_inferCmd_helper_function Cmd_contextCmd_autoCmd_refine_or_intro Cmd_intro Cmd_refineCmd_giveToggleImplicitArgsShowImplicitArgs Cmd_highlightCmd_load_highlighting_infoCmd_compute_toplevelCmd_infer_toplevel Cmd_solveAll!Cmd_show_module_contents_toplevel Cmd_metasCmd_constraints Cmd_compileCmd_load InteractionCommandMOldInteractionScopes CommandStatetheInteractionPointstheCurrentFileoptionsOnReloadoldInteractionScopesinitCommandStaterevLift commandMToIO liftCommandMTmodifyTheInteractionPointsmodifyOldInteractionScopesinsertOldInteractionScoperemoveOldInteractionScopegetOldInteractionScoperunInteraction readsToParseparseToReadsPrecexact readParseparens' independent interpret cmd_load'withCurrentFilegive_gen highlightExprsortInteractionPointsprettyTypeOfMeta prettyContextcmd_helper_functioncmd_goal_type_context_andshowModuleContentssetCommandLineOptions'status displayStatus display_info refreshStr nameModifiers lowerMetaparseAndDoAtTopleveltellToUpdateHighlightingtellEmacsToJumpToError mimicGHCirunAgda printUsage printVersion optionErrormainGHC.Listfilter strict-0.3.2Data.Strict.MaybemaybeMaybeJustNothing fromMaybe$fArbitraryMaybe $fBinaryMaybe $fNFDataMaybe$fTraversableMaybe$fFoldableMaybe $fMonoidMaybefromJust isNothingisJust$fSemiRingMaybeC exactlyTwo atLeastTwoprop_cluster_emptyprop_cluster_permutationprop_cluster_singleprop_cluster_idemprop_two_clusterstesttest1$fArbitraryBiMap $fShowBiMap $fOrdBiMap $fEqBiMap $fPointedSet$fPointedMaybe $fPointed[]ptrTagptrReffreshVar $fNFDataPtr $fHashablePtr$fOrdPtr$fEqPtr$fTraversablePtr $fFoldablePtr $fFunctorPtr $fShowPtr $fShowCutOff$fApplicativeList2FunctorChangeT evalUpdater$fMonadChangeIdentity fromChangeEndoFun fromChangeT$fUpdater2Either $fUpdater2(,) $fUpdater1[]$fUpdater1Maybe$fMonadChangeChange$fMonadChangeChangeT Data.Maybeghc-prim GHC.TypesTrueQuickCheck-2.7.6Test.QuickCheck.AllverboseCheckAll quickCheckAllforAllProperties monomorphicpolyVerboseCheckpolyQuickCheckTest.QuickCheck.TestverboseCheckWithResultverboseCheckResultverboseCheckWith verboseCheckquickCheckWithResultquickCheckResultquickCheckWith quickCheckstdArgschattymaxSizemaxDiscardRatio maxSuccessreplayoutputlabelsnumTestsSuccessGaveUp theExceptionreasonusedSizeusedSeednumShrinkFinalnumShrinkTries numShrinksFailureNoExpectedFailureTest.QuickCheck.Propertydisjoinconjoin.&. forAllShrinkforAllwithin==>classifycollectonce expectFailureverbose whenFail'whenFail printTestCasecounterexample noShrinking shrinkingmapSize ioPropertyProperty exhaustivepropertyTestableDiscardTest.QuickCheck.ModifiersgetBlindBlindgetFixedFixed getOrderedOrdered OrderedList getNonEmptyNonEmpty NonEmptyList getPositivePositive getNonZeroNonZerogetNonNegative NonNegativegetLargeLargegetSmallSmall getShrink2Shrink2Smart Shrinking shrinkState shrinkInit ShrinkStateTest.QuickCheck.Arbitrary infiniteList orderedListvectorcoarbitraryEnumcoarbitraryShowcoarbitraryRealcoarbitraryIntegral><shrinkRealFracshrinkRealFracToIntegershrinkIntegral shrinkNothingarbitrarySizedBoundedIntegralarbitraryBoundedEnumarbitraryBoundedRandomarbitraryBoundedIntegralarbitrarySizedFractionalarbitrarySizedIntegral shrinkListsubtermsrecursivelyShrink genericShrinkshrink arbitrary Arbitrary coarbitrary CoArbitraryTest.QuickCheck.GeninfiniteListOfvectorOflistOf1listOfgrowingElementselements frequencyoneof suchThatMaybesuchThatsamplesample'generateresizesizedvariantGenTest.QuickCheck.ExceptiondiscardBool $fHasZeroIntInt$fHasZeroInteger integer-gmpGHC.Integer.Typeprop_integerSemiringprop_intSemiringprop_boolSemiring $fSemiRingInt $fMonoidInt$fSemiRingInteger$fMonoidIntegerOrdering GHC.ClassesOrd$fPartialOrdPartialOrdering$fPartialOrdInclusion$fPartialOrdInclusion0$fPartialOrdPointwise$fPartialOrd(,)$fPartialOrdEither$fPartialOrdMaybe$fSemiRingPartialOrdering$fMonoidPartialOrdering$fArbitraryISet$fArbitraryPartialOrdering$fPartialOrd()$fPartialOrdInteger$fPartialOrdInt readP_to_S readS_to_PPFinalLookGetfinalrunrun'$fMonadPlusReadP$fAlternativeReadP $fMonadReadP$fApplicativeReadP$fFunctorReadP $fMonadPlusP$fAlternativeP$fMonadP$fApplicativePGHC.Num+False$fPlusSizeExpr'IntSizeExpr'$fOrdCmp$fFlexsflexConstraint'$fFlexsflexSizeExpr' $fFlexsflex[]$fRigidsrConstraint'$fRigidsrSizeExpr' $fRigidsr[]$fTruncateOffsetSizeExpr'$fTruncateOffsetInt$fValidOffsetSizeExpr'$fValidOffsetInt$fShowConstraint' $fShowCmp$fShowPolarityAssignment$fShowPolarity$fShowSizeExpr'$fSubstituterf[]$fSubstituterfConstraint'$fSubstituterfSizeExpr'$fTopCmp$fMeetSemiLatticeCmp $fShowFlex $fShowRigidcatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName Picosecondsunordered-containers-0.2.5.1Data.HashMap.StrictintersectionWith mapWithKeyData.HashMap.Baseelemskeys filterWithKey foldrWithKeyfoldr foldlWithKey'foldl' intersection differencetraverseWithKey! lookupDefaultHashMap $fSizedMaybe $fSizedSet $fSizedMap $fSized[] $fPrettyDoc$fEqDocpretty-1.1.1.0Text.PrettyPrint.HughesPJstyleModeLeftMode OneLineModePageMode ZigZagModeStyle lineLengthmoderibbonsPerLinespacesemirparenrbrackrbracelparenlbracklbrace fullRenderPStrChr zeroWidthText sizedText renderStylerenderrationalquotesptextintegerinthangfloatfcat doubleQuotesdoublecat$fDecoration(,)$fDecorationCompose$fDecorationIdentityEGunEprop_nodes_fromNodesprop_transitiveClosure $fSemiRingE$fArbitraryGraph$fExceptionImpossible$fShowImpossibleinitlastEq Data.ListgroupBy==.sortBycompare elemIndexN discardEmptyremoveSourceNoderemoveTargetNodecompleteUntilWithprop_neighboursprop_insertWithn$fShowN$fCoArbitraryEdge$fArbitraryEdge$fDoDropPermutation $fDoDrop[]$fSizedPermutation$fShowPermutationbytestring-0.10.0.2Data.ByteString.Internal ByteStringGHC.IOFilePathabsolutePathInvariantdirectory-1.2.0.1System.DirectorycanonicalizePathbyteStringPathprop_mkAbsoluterootPath$fArbitraryAbsolutePath$fShowAbsolutePath Data.EithereitherEitherRightLeft prop_allRight$fMonoidFavorites Data.MonoidMonoid $fEqFavorites Data.Set.Base$fArbitraryFavorites$fNegativeGraph$fNegativeEdge $fNumWeight$fPlusSizeExpr'LabelSizeExpr'$fPlusSizeExpr'WeightSizeExpr'$fPlusIntWeightWeight$fPlusIntIntInt$fSetToInftyfGraph$fSetToInftyfEdge$fSetToInftyfNode $fNegative[] $fDioidEdge $fTopEdge$fMeetSemiLatticeEdge $fShowNode $fDioidLabel $fDioidCmp $fDioidWeight $fTopLabel$fMeetSemiLatticeLabel $fShowLabel $fOrdLabel $fEqLabel$fNegativeLabel$fNegativeWeight $fNegativeInt$fPlusWeightIntWeight $fEnumWeight $fTopWeight$fMeetSemiLatticeWeight $fOrdWeight $fShowWeight$fMeetSemiLatticeInt$fAsWeightRelationLabel$fAsWeightRelationCmp$fArbitraryLabel$fArbitraryWeight$fArbitraryCmp$fRefinableOKValblk$fRefinableChoiceblk $fEqPrioMeta $fEqMetavar $fTravMMblk$fTravArgListRefInfo$fTravExpRefInfo$fTravTrBrRefInfo$fTrav(,)RefInfo $fTrav[]blk$fRefinableIORefRefInfo$fRefinableClosRefInfo$fRefinableExpRefInfo$fRefinableArgListRefInfoModelVal modelToTrie modelPath$fArbitraryModel$fArbitraryVal$fArbitraryKey $fShowVal $fShowKeyGHC.Showshow System.IOputStrLn $fShowStrrunningInfoBufferName $fShowLisp $fPretty[] $fPrettyLisp dropWhiletransformers-0.4.1.0Control.Monad.Trans.Error $fError()ErrorTfail>>=>>fmapreturnguardliftMMonad MonadPlus<=<>=>apfilterMfoldMfoldM_forM_foreverjoinliftM2liftM3liftM4liftM5 mapAndUnzipMmfiltermsum replicateM replicateM_unlessvoidwhenzipWithM zipWithM_mplusmzero=<<mapM_sequence sequence_ $fNullSet $fNullSeq $fNullMap$fNull[]$fNullByteStringiLength fuseIntervals iPositions rPositions makeIntervalsetFileintervalInSameFileAsSrcFile importantPart prop_iLength prop_startPos prop_noRangeprop_takeI_dropIprop_rangeToIntervalprop_continuousprop_fuseIntervalsprop_fuseRangesprop_beginningOfprop_beginningOfFileprop_intervalInSameFileAsprop_positionInvariantprop_intervalInvariantprop_rangeInvariant $fShowRange'$fShowInterval'$fShowPosition'$fArbitraryRange'$fArbitraryInterval'$fArbitraryPosition' $fShowRange'0$fShowInterval'0$fShowPosition'0$fKillRangeEither$fKillRangeMaybe$fKillRange(,,)$fKillRange(,) $fKillRange[]$fKillRangeInt$fKillRangeBool $fKillRange()$fKillRangeRange'$fSetRangeRange'$fHasRangeMaybe$fHasRange(,,,,,,)$fHasRange(,,,,,)$fHasRange(,,,,)$fHasRange(,,,)$fHasRange(,,) $fHasRange(,) $fHasRange[]$fHasRangeRange'$fHasRangeInterval'$fOrdPosition' $fEqPosition'$fKillRangeTerminationCheck$fKillRangeInteractionId$fShowInteractionId$fHashableNameId $fEnumNameId $fShowNameId$fKillRangeIsAbstract$fDecorationRanged$fKillRangeRanged$fHasRangeRanged $fOrdRanged $fEqRanged $fShowRanged $fShowNamed $fSizedNamed$fKillRangeNamed$fHasRangeNamed$fDecorationNamed$fLensRelevanceDom$fLensHidingDom $fShowDom $fSizedDom$fKillRangeDom $fHasRangeDom$fDecorationDom$fUnderscoreDoc$fUnderscoreByteString$fUnderscore[]$fLensRelevanceArg$fLensHidingArg $fShowArg$fEqArg $fSizedArg$fKillRangeArg $fHasRangeArg$fDecorationArg$fLensRelevanceArgInfo$fLensHidingArgInfo$fKillRangeArgInfo$fLensRelevanceRelevance$fOrdRelevance$fArbitraryRelevance$fKillRangeRelevance$fLensHidingHiding$fKillRangeHiding$fCoArbitraryInduction$fArbitraryInduction$fKillRangeInduction$fHasRangeInduction$fShowInduction$fKillRangeDelayed$fGlobalsModule$fGlobalsExport $fGlobalsExp $fGlobalsMap $fGlobals[] $fUsesExport $fUsesExp $fUsesMap$fUses[]$fPrettyModule $fPrettyExp$fPrettyMemberId$fPrettyGlobalId$fPrettyLocalId $fPrettiesMap $fPretties[] $fPretty(,) $fShowTag $fPrettyPatt $fPrettyCase$fSemiRingDistance$fShowSizeExpr$fShowLegendMatrix$fShowConstraint$fSemiRingWeight<=prop_rangesToPositions prop_minus$fArbitraryRanges$fCoArbitraryRange$fArbitraryRange$fEqName$fKillRangeName$fKillRangeQName$fSetRangeQName$fSetRangeName$fHasRangeQName$fHasRangeName$fCoArbitraryTopLevelModuleName$fArbitraryTopLevelModuleName$fPrettyTopLevelModuleName $fShowQName$fShowNamePart $fShowName$fIsNoNameQName$fIsNoNameName$fIsNoNameByteString $fIsNoName[]$fUnderscoreQName $fOrdNamePart $fEqNamePart $fOrdName$fUnderscoreName $fNFDataName$fKillRangeFixity'$fKillRangeFixity$fHasRangeFixity $fEqFixityunP initStatePos getLastPos setLexState setContext$fHasRangeParseError$fShowParseError$fMonadStateParseStateParser$fMonadErrorParseErrorParser$fApplicativeParser$fFunctorParser $fMonadParser$fExceptionParseError ErrorFunctionErrorFun throwError unLookAhead$fMonadLookAheadTM TransposeunMtoBoundssupSizeinfSizelengthall toSparseRows toSparseRows'blowUpSparseVec zipAssocWithunionAssocWithinterAssocWithstrictlySortedprop_fromIndexListprop_fromLists_toListsprop_isSingleton prop_diagonalprop_transpose zipMatrices'prop_zipMatrices_correctprop_addprop_add_correctinterAssocWith'prop_interAssocWith_correctprop_mul$fArbitraryMatrix$fTransposeMatrix$fTransposeMIx$fTransposeSize$fDiagonalMatrixbprop_toSparseRowsblowUpSparseVec'interAssocWith2prop_interAssocWith_correct2prop_addColumn prop_addRowprop_Arbitrary_Size prop_sizeprop_Arbitrary_MIx prop_matrixprop_Arbitrary_Matrixprop_diagonal'$fCoArbitraryMatrix$fCoArbitraryMIx$fArbitraryMIx$fCoArbitrarySize$fArbitrarySize$fPrettyMatrix $fShowMatrixDecrmaxO$fNotWorseMatrix$fNotWorseOrder$fPartialOrdMatrix$fPartialOrdOrder withinCutOffisOrder prop_decrcollapseokMminOprop_orderSemiring$fCoArbitraryOrder$fArbitraryOrder $fPrettyOrder$fHasZeroOrder $fShowOrder$fCallCombCMSet$fCallCombCallMatrixAug$fCallCombCallMatrix'$fCoArbitraryCallMatrixAug$fArbitraryCallMatrixAug$fArbitraryCallMatrix' $fPrettyCMSet$fPrettyCallMatrixAug$fPrettyCallMatrix'$fNotWorseCallMatrixAug$fPartialOrdCallMatrixAug$fDiagonalCallMatrixAugOrder$fDiagonalCallMatrix'acombineNewOldCallGraph callGraph$fPrettyCallGraph$fMonoidCallGraph$fCallCombEdge CombineNewOld combineNewOldCombineNewOldT$fCombineNewOldGraph$fCombineNewOldFavoritesCGbuildCallGraphexample1example2example3example4example5example6 checkIdems checkIdem hasDecreaseprop_terminates_example1prop_terminates_example2prop_terminates_example3prop_terminates_example4prop_terminates_example5prop_terminates_example6example7prop_terminates_example7defaultLaTeXDirdefaultHTMLDir parseOptions'defaultPragmaOptionsprop_defaultOptionsdefaultPragmaOptionsSafe inputFlag versionFlaghelpFlagsafeFlagproofIrrelevanceFlagexperimentalIrrelevanceFlagnoIrrelevantProjectionsFlagignoreInterfacesFlagallowUnsolvedFlagshowImplicitFlagshowIrrelevantFlag runTestsFlagghciInteractionFlagvimFlag latexFlag latexDirFlagnoPositivityFlagdontTerminationCheckFlagdontCompletenessCheckFlagdontUniverseCheckFlag sizedTypes noSizedTypesinjectiveTypeConstructorFlagguardingTypeConstructorFlaguniversePolymorphismFlagnoUniversePolymorphismFlag noForcingFlag withKFlag withoutKFlagcopatternsFlagnoPatternMatchingFlaginteractiveFlag compileFlagcompileFlagNoMaincompileEpicFlag compileJSFlagcompileDirFlagghcFlag epicFlagsFlaghtmlFlagdependencyGraphFlag htmlDirFlagcssFlag includeFlag verboseFlagterminationDepthFlagintegerArgumentstandardOptions$fSizedModuleName $fSizedQName$fKillRangeAmbiguousQName$fKillRangeModuleName$fSetRangeModuleName$fHasRangeModuleName$fShowModuleName$fHashableQName $fOrdQName $fEqQName$fHashableName $fFreshName()$fFreshNameRange' $fFreshName[]$fFreshName(,) $fMkName[]$fKillRangeLiteral$fSetRangeLiteral$fHasRangeLiteral $fOrdLiteral $fEqLiteral$fPrettyLiteral $fShowLiteral$fHasRangeTokenlitError stringToken lexString lexStringGaplexChar lexEscapereadNum readNumAccsillyEscapeCharspragmaalexScanGHC.Err undefined AlexAccPredAlexAccAlexAccSkipPred AlexAccSkip AlexAccNone AlexLastAcc AlexLastSkipAlexNoneAlexAddrAlexA# alex_base alex_table alex_check alex_deflt alex_acceptbol_ empty_layout_imp_dir_layout_pragma_tex alex_action_0 alex_action_1 alex_action_4 alex_action_5 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_27alex_action_28alex_action_29alex_action_30alex_action_31alex_action_32alex_action_34alex_action_36alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_43alex_action_44alex_action_45alex_action_46alex_action_47alex_action_48alex_action_49alex_action_50alex_action_51alex_action_52alex_action_53alex_action_54alex_action_55alex_action_56alex_action_57alex_action_58alex_action_59alex_action_60alex_action_61alex_action_62alex_action_63alex_action_64alex_action_65alex_action_66alex_action_67alex_action_68alex_action_69alex_action_70alex_action_71alex_action_72alex_action_73alex_action_74alex_action_75alex_action_76alex_action_77alex_action_78alex_action_79alex_action_80alex_action_81alex_action_82alex_action_83alex_action_84alex_action_85alex_action_86alex_action_87alex_action_88alex_action_89alex_action_90alex_action_91alex_action_92alex_action_93alex_action_94alex_action_95alex_action_96alex_action_97alex_action_98alex_action_99alex_action_100alex_action_101alex_action_102alex_action_103alex_action_104alexIndexInt16OffAddralexIndexInt32OffAddr quickIndex alex_scan_tkn alexAndPredalexPrevCharIsalexPrevCharMatchesalexPrevCharIsOneOfalexRightContextiUnbox$fFunctorAlexLastAcc returnEOFskipTonewInputfoolAlex qualified postToken getOffside$fArbitraryCName $fShowCName$fArbitrarySplitTree'$fShowSplitTree'$fShowSplitTreeLabel$fKillRangeWhereClause'$fKillRangeUsingOrHiding$fKillRangeTypedBindings'$fKillRangeTypedBinding'$fKillRangeRHS'$fKillRangeRenaming$fKillRangePragma$fKillRangePattern$fKillRangeOpApp$fKillRangeModuleApplication$fKillRangeLHS$fKillRangeLamBinding'$fKillRangeImportedName$fKillRangeImportDirective$fKillRangeExpr$fKillRangeDeclaration$fKillRangeBoundName$fKillRangeAsName$fHasRangePattern$fHasRangeAsName$fHasRangeRenaming$fHasRangeImportedName$fHasRangeImportDirective$fHasRangeUsingOrHiding$fHasRangePragma$fHasRangeRHS'$fHasRangeLHSCore $fHasRangeLHS$fHasRangeDeclaration$fHasRangeModuleApplication$fHasRangeWhereClause'$fHasRangeBoundName$fHasRangeLamBinding'$fHasRangeTypedBinding'$fHasRangeTypedBindings'$fHasRangeExpr$fHasRangeOpApp$fShowImportedName$fNFDataLHSCore$fNFDataPattern $fNFDataExpr$fPrettyImportedName$fPrettyUsingOrHiding$fPrettyImportDirective$fPrettyPattern $fPrettyNamed $fPrettyArg$fPrettyFixity$fPrettyPragma$fPrettyOpenShortHand$fPrettyDeclaration$fPrettyModuleApplication$fShowModuleApplication $fPretty[]0$fPrettyLHSCore $fShowLHSCore $fPrettyLHS $fShowLHS$fPrettyWhereClause'$fShowWhereClause' $fPrettyRHS'$fPrettyTypedBinding'$fPrettyColoredTypedBinding $fPrettyTel$fPrettyTypedBindings'$fPrettyLamBinding'$fPrettyBoundName $fPrettyExpr $fPrettyOpApp$fPrettyInduction$fPrettyRelevance $fPrettyQName $fPrettyName$fPrettyThingWithFixity $fShowRHS' $fShowPragma$fShowImportDirective$fShowLamBinding'$fShowTypedBindings'$fShowTypedBinding' $fShowPattern$fShowDeclaration $fShowExpr$fSetRangeAbstractName$fHasRangeAbstractName$fKillRangeScopeInfo$fShowScopeInfo $fShowScope$fShowNameSpace$fShowNameSpaceId$fShowAbstractModule$fShowAbstractName$fOrdAbstractModule$fEqAbstractModule$fOrdAbstractName$fEqAbstractName$fInScopeAbstractModule$fInScopeAbstractName$fSetRangeConPatInfo$fKillRangeConPatInfo$fHasRangeConPatInfo$fShowConPatInfo$fKillRangePatInfo$fHasRangePatInfo $fShowPatInfo$fKillRangeLHSInfo$fHasRangeLHSInfo$fKillRangeMutualInfo$fHasRangeMutualInfo$fKillRangeDeclInfo$fSetRangeDeclInfo$fHasRangeDeclInfo$fKillRangeDefInfo$fSetRangeDefInfo$fHasRangeDefInfo$fKillRangeLetInfo$fHasRangeLetInfo$fKillRangeModuleInfo$fSetRangeModuleInfo$fHasRangeModuleInfo$fKillRangeExprInfo$fHasRangeExprInfo$fKillRangeMetaInfo$fHasRangeMetaInfogeniplate-0.6.0.5Data.Generics.GeniplateinstanceUniverseBiT universeBiinstanceTransformBiMT transformBiM$fLHSToSpine[][]$fLHSToSpineClause'Clause'$fLHSToSpineLHSSpineLHS$fKillRangeLetBinding$fKillRangeRHS$fKillRangeClause'$fKillRangeLHSCore'$fKillRangeSpineLHS$fKillRangePattern'$fKillRangeThingWithFixity$fKillRangeTypedBinding$fKillRangeTypedBindings$fKillRangeLamBinding$fSetRangePattern'$fHasRangeLetBinding $fHasRangeRHS$fHasRangeClause'$fHasRangeLHSCore'$fHasRangeSpineLHS$fHasRangePattern'$fHasRangeTypedBinding$fHasRangeTypedBindings$fHasRangeLamBinding$fIsProjPNamed $fIsProjPArg$fIsProjPPattern'$fGetDefInfoDeclaration $fOrdExpr$fEqExpr$fUniverseBiDeclarationQName%$fUniverseBiDeclarationAmbiguousQName$fUniverseBiDeclarationExpr!$fUniverseBiDeclarationLetBinding!$fUniverseBiDeclarationLamBinding#$fUniverseBiDeclarationTypedBinding$fUniverseBiDeclarationPattern'"$fUniverseBiDeclarationDeclaration!$fUniverseBiDeclarationModuleName!$fUniverseBiDeclarationModuleInfo$fAnyAbstractDeclaration$fAnyAbstract[]$fUniverseBiDeclarationRanged$fExprLikeClause'$fExprLikePattern' $fExprLikeArg$fExprLikeLetBinding$fExprLikeTypedBinding$fExprLikeTypedBindings$fExprLikeLamBinding $fExprLike(,) $fExprLike[]$fExprLikeNamed$fExprLikeExpr$fKillRangeElim'$fKillRangeAbs$fKillRangeBlocked$fKillRangeTele$fKillRangeClauseBodyF$fKillRangeClause$fKillRangePermutation$fKillRangeSort$fKillRangeType'$fKillRangeLevelAtom$fKillRangePlusLevel$fKillRangeLevel$fKillRangeTerm$fKillRangeConHead $fSizedElim' $fSizedAbs $fSizedTele$fSizedLevelAtom$fSizedPlusLevel $fSizedLevel $fSizedType' $fSizedTerm $fShowBlocked $fShowMetaId $fShowAbs$fIsProjElimElim'$fSuggestAbsAbs $fSuggest[][]$fHasRangeClause$fApplicativeBlocked$fDecorationType'$fLensConNameConHead$fSetRangeConHead$fHasRangeConHead $fShowConHead $fOrdConHead $fEqConHead$fUniverseBi(,)Pattern$fUniverseBi[]Pattern$fUniverseBi[]Pattern0$fUniverseBi(,)Term$fUniverseBi[]Term$fUniverseBi[]Term0 $fPrettyElim' $fPrettyType' $fPrettySort$fPrettyLevelAtom$fPrettyPlusLevel $fPrettyLevel $fPrettyTerm$fUniverseBi[]Term1flexible irrelevantlyunused subtractFV $fFreeClause$fFreeClauseBodyF $fFreeTele $fFreeAbs $fFreeDom $fFreeArg $fFreeElim' $fFree(,) $fFreeMaybe$fFree[]$fFreeLevelAtom$fFreePlusLevel $fFreeLevel $fFreeSort $fFreeType' $fFreeTerm$fMonoidEInterface$fPrettyCompiledClauses$fPrettyWithArity$fShowCompiledClauses $fShowCase $fMonoidCase$fMonoidWithArity $fFunArity[]$fFunArityClause $fFunArity[]0$fIsProjPPattern $fGetDefs(,) $fGetDefsAbs $fGetDefsDom $fGetDefsArg$fGetDefsArgInfo$fGetDefsElim' $fGetDefs[]$fGetDefsMaybe$fGetDefsLevelAtom$fGetDefsPlusLevel$fGetDefsLevel $fGetDefsSort$fGetDefsType'$fGetDefsMetaId $fGetDefsTerm$fGetDefsClauseBodyF$fGetDefsClause$fMonadGetDefsReaderT$fTermLikeType'$fTermLikeLevelAtom$fTermLikePlusLevel$fTermLikeLevel$fTermLikeTerm $fTermLikePtr $fTermLikeAbs$fTermLike(,,,)$fTermLike(,,) $fTermLike(,)$fTermLikeMaybe $fTermLike[] $fTermLikeDom $fTermLikeArg$fTermLikeElim'$fTermLikeQName$fTermLikeChar$fTermLikeInteger $fTermLikeInt$fTermLikeBool $fMonoidMatch$fExprLikeDeclaration$fExprLikeModuleApplication $fExprLikeLHS$fExprLikeTypedBindings'$fExprLikeLamBinding'$fExprLikeOpApp$fExprLike(,,)$fExprLikeWhereClause'$fExprLikeRHS'$fExprLikeTypedBinding'$fExprLikeMaybe$fExprLikeQName$fExprLikeName mergeMetaInfomergemergeC prop_compressprop_singleton prop_several prop_merge prop_splitAtCprop_smallestPos$fArbitraryCompressedFile$fCoArbitraryFile$fArbitraryFile$fCoArbitraryMetaInfo$fArbitraryMetaInfo$fCoArbitraryOtherAspect$fArbitraryOtherAspect$fCoArbitraryNameKind$fArbitraryNameKind$fCoArbitraryAspect$fArbitraryAspect$fMonoidCompressedFile $fMonoidFile$fMonoidMetaInfoloneSigs DataRecOrFunFunNameRecNameDataName NotInMutualInMutualcombineTermChecksgetSig checkLoneSigs parameters plusFixitiesfixitiesDeclKind OtherDeclLoneDefLoneSigNiceEnvfixsLoneSigsParams isFunNamesameKindterminationCheck initNiceEnv addLoneSig removeLoneSig noLoneSigsdeclKind$fShowDataRecOrFun$fShowDeclarationException$fErrorDeclarationException$fHasRangeNiceDeclaration$fHasRangeDeclarationException happyErrortakeOptionsPragmasfigureOutTopLevelModulemkQNameisNameforallPitLetaddTypeverifyImportDirective splitOnDotsvalidHaskellModuleName exprToLHS exprToPattern exprToName HappyAddrHappyA#HappyStk Happy_IntList HappyCons RHSOrTypeSigs TypeSigsRHSJustRHSHappyAny HappyAbsSynhappyIn6 happyOut6happyIn7 happyOut7happyIn8 happyOut8happyIn9 happyOut9 happyIn10 happyOut10 happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyIn85 happyOut85 happyIn86 happyOut86 happyIn87 happyOut87 happyIn88 happyOut88 happyIn89 happyOut89 happyIn90 happyOut90 happyIn91 happyOut91 happyIn92 happyOut92 happyIn93 happyOut93 happyIn94 happyOut94 happyIn95 happyOut95 happyIn96 happyOut96 happyIn97 happyOut97 happyIn98 happyOut98 happyIn99 happyOut99 happyIn100 happyOut100 happyIn101 happyOut101 happyIn102 happyOut102 happyIn103 happyOut103 happyIn104 happyOut104 happyIn105 happyOut105 happyIn106 happyOut106 happyIn107 happyOut107 happyIn108 happyOut108 happyIn109 happyOut109 happyIn110 happyOut110 happyIn111 happyOut111 happyIn112 happyOut112 happyIn113 happyOut113 happyIn114 happyOut114 happyIn115 happyOut115 happyIn116 happyOut116 happyIn117 happyOut117 happyIn118 happyOut118 happyIn119 happyOut119 happyIn120 happyOut120 happyIn121 happyOut121 happyIn122 happyOut122 happyIn123 happyOut123 happyIn124 happyOut124 happyIn125 happyOut125 happyIn126 happyOut126 happyIn127 happyOut127 happyIn128 happyOut128 happyIn129 happyOut129 happyIn130 happyOut130 happyIn131 happyOut131 happyIn132 happyOut132 happyIn133 happyOut133 happyIn134 happyOut134 happyIn135 happyOut135 happyIn136 happyOut136 happyIn137 happyOut137 happyIn138 happyOut138 happyIn139 happyOut139 happyIn140 happyOut140 happyIn141 happyOut141 happyIn142 happyOut142 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_3happyReduction_3 happyReduce_4happyReduction_4 happyReduce_5happyReduction_5 happyReduce_6happyReduction_6 happyReduce_7happyReduction_7 happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251happyReduce_252happyReduction_252happyReduce_253happyReduction_253happyReduce_254happyReduction_254happyReduce_255happyReduction_255happyReduce_256happyReduction_256happyReduce_257happyReduction_257happyReduce_258happyReduction_258happyReduce_259happyReduction_259happyReduce_260happyReduction_260happyReduce_261happyReduction_261happyReduce_262happyReduction_262happyReduce_263happyReduction_263happyReduce_264happyReduction_264happyReduce_265happyReduction_265happyReduce_266happyReduction_266happyReduce_267happyReduction_267happyReduce_268happyReduction_268happyReduce_269happyReduction_269happyReduce_270happyReduction_270happyReduce_271happyReduction_271happyReduce_272happyReduction_272happyReduce_273happyReduction_273happyReduce_274happyReduction_274happyReduce_275happyReduction_275happyReduce_276happyReduction_276happyReduce_277happyReduction_277happyReduce_278happyReduction_278happyReduce_279happyReduction_279happyReduce_280happyReduction_280happyReduce_281happyReduction_281happyReduce_282happyReduction_282happyReduce_283happyReduction_283happyReduce_284happyReduction_284happyReduce_285happyReduction_285happyReduce_286happyReduction_286happyReduce_287happyReduction_287happyReduce_288happyReduction_288happyReduce_289happyReduction_289happyReduce_290happyReduction_290happyReduce_291happyReduction_291happyReduce_292happyReduction_292happyReduce_293happyReduction_293happyReduce_294happyReduction_294happyReduce_295happyReduction_295happyReduce_296happyReduction_296happyReduce_297happyReduction_297happyReduce_298happyReduction_298happyReduce_299happyReduction_299happyReduce_300happyReduction_300happyReduce_301happyReduction_301happyReduce_302happyReduction_302happyReduce_303happyReduction_303happyReduce_304happyReduction_304happyReduce_305happyReduction_305happyReduce_306happyReduction_306happyReduce_307happyReduction_307happyReduce_308happyReduction_308happyReduce_309happyReduction_309happyReduce_310happyReduction_310happyReduce_311happyReduction_311happyReduce_312happyReduction_312happyReduce_313happyReduction_313happyReduce_314happyReduction_314happyReduce_315happyReduction_315happyReduce_316happyReduction_316happyReduce_317happyReduction_317happyReduce_318happyReduction_318happyReduce_319happyReduction_319happyReduce_320happyReduction_320happyReduce_321happyReduction_321happyReduce_322happyReduction_322happyReduce_323happyReduction_323happyReduce_324happyReduction_324happyReduce_325happyReduction_325happyReduce_326happyReduction_326happyReduce_327happyReduction_327happyReduce_328happyReduction_328happyReduce_329happyReduction_329happyReduce_330happyReduction_330happyReduce_331happyReduction_331happyReduce_332happyReduction_332happyReduce_333happyReduction_333happyReduce_334happyReduction_334happyReduce_335happyReduction_335happyReduce_336happyReduction_336happyReduce_337happyReduction_337happyReduce_338happyReduction_338happyReduce_339happyReduction_339happyReduce_340happyReduction_340happyReduce_341happyReduction_341happyReduce_342happyReduction_342happyReduce_343happyReduction_343happyReduce_344happyReduction_344happyReduce_345happyReduction_345happyReduce_346happyReduction_346happyReduce_347happyReduction_347happyReduce_348happyReduction_348happyReduce_349happyReduction_349happyReduce_350happyReduction_350happyReduce_351happyReduction_351happyReduce_352happyReduction_352happyReduce_353happyReduction_353happyReduce_354happyReduction_354happyReduce_355happyReduction_355happyReduce_356happyReduction_356happyReduce_357happyReduction_357happyReduce_358happyReduction_358happyReduce_359happyReduction_359happyReduce_360happyReduction_360happyReduce_361happyReduction_361happyReduce_362happyReduction_362happyReduce_363happyReduction_363happyReduce_364happyReduction_364happyReduce_365happyReduction_365happyReduce_366happyReduction_366happyReduce_367happyReduction_367happyReduce_368happyReduction_368happyReduce_369happyReduction_369happyReduce_370happyReduction_370happyReduce_371happyReduction_371happyReduce_372happyReduction_372happyReduce_373happyReduction_373happyReduce_374happyReduction_374happyReduce_375happyReduction_375happyReduce_376happyReduction_376happyReduce_377happyReduction_377happyReduce_378happyReduction_378happyReduce_379happyReduction_379happyReduce_380happyReduction_380happyReduce_381happyReduction_381happyReduce_382happyReduction_382happyReduce_383happyReduction_383happyReduce_384happyReduction_384happyReduce_385happyReduction_385happyReduce_386happyReduction_386happyReduce_387happyReduction_387happyReduce_388happyReduction_388happyReduce_389happyReduction_389happyReduce_390happyReduction_390happyReduce_391happyReduction_391happyReduce_392happyReduction_392happyReduce_393happyReduction_393happyReduce_394happyReduction_394happyReduce_395happyReduction_395happyReduce_396happyReduction_396happyReduce_397happyReduction_397happyReduce_398happyReduction_398happyReduce_399happyReduction_399happyReduce_400happyReduction_400happyReduce_401happyReduction_401happyReduce_402happyReduction_402happyReduce_403happyReduction_403happyReduce_404happyReduction_404happyReduce_405happyReduction_405happyReduce_406happyReduction_406happyReduce_407happyReduction_407happyReduce_408happyReduction_408happyReduce_409happyReduction_409happyReduce_410happyReduction_410happyReduce_411happyReduction_411happyReduce_412happyReduction_412happyReduce_413happyReduction_413happyReduce_414happyReduction_414happyReduce_415happyReduction_415happyReduce_416happyReduction_416 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'happySeq ensureUnqualmergeImportDirectivesprop_splitOnDotsopAppExprToPatternstripSingletonRawAppisEqual maybeNamedpatternSynArgs parsePanicnamesOfPatternfunClauseOrTypeSigs happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq withCommentswithoutCommentsparserwrapwrapMparseLiterateFile Data.Map.Base$fShowCallInfo $fMonadIOTCMT$fApplicativeTCMT $fFunctorTCMT $fMonadTCMT$fMonadTransTCMT$fMonadTCMWriterT$fMonadTCMErrorT$fMonadTCMMaybeT$fMonadTCMTCMT$fMonadErrorTCErrTCMT$fMonadStateTCStateTCMT$fMonadReaderTCEnvTCMT$fMonadReaderTCEnvReduceM$fExceptionTCErr$fHasRangeTCErr $fShowTCErr $fErrorTCErr$fErrorTypeError$fErrorSplitError$fPrettyCallInfo$fHasRangeCall$fIsProjElimMaybeReduced$fMonoidSimplification$fNFDataOccurrence$fEqInteractionPoint$fSetRangeMetaVariable$fSetRangeMetaInfo$fHasRangeMetaVariable$fShowNamedMeta$fShowMetaInstantiation $fOrdListener $fEqListener$fShowJudgement$fShowCompareDirection$fShowComparison$fHasRangeConstraint$fHasRangeProblemConstraint$fHasRangeClosure $fShowClosure$fHasFreshiTCState$fHasFreshProblemIdFreshThings$fShowProblemId$fHasFreshIntFreshThings$fHasFreshCtxIdFreshThings$fHasFreshNameIdFreshThings"$fHasFreshInteractionIdFreshThings$fHasFreshMutualIdFreshThings$fHasFreshMetaIdFreshThings$fEqTerm$fKillRangeSubstitution$fSizedSubstitution$fOrdAbs$fEqAbs $fOrdTerm $fEqLevelAtom$fOrdPlusLevel$fGetBodyClause$fGetBodyClauseBodyF$fTeleNoAbsTele $fTeleNoAbs[] $fSubstClause$fSubstClauseBodyF $fSubst(,,,) $fSubst(,,) $fSubst(,) $fSubst() $fSubst[] $fSubstMaybe $fSubstDom $fSubstNamed $fSubstArg $fSubstAbs $fSubstElim'$fSubstConstraint $fSubstTele$fSubstDisplayTerm$fSubstDisplayForm$fSubstBlocked$fSubstPattern $fSubstName $fSubstBool$fSubstLevelAtom$fSubstPlusLevel $fSubstLevel $fSubstSort $fSubstType' $fSubstPtr $fSubstTerm$fSubstSubstitution $fAbstractMap$fAbstractMaybe $fAbstract[]$fAbstractClauseBodyF$fAbstractFunctionInverse'$fAbstractCase$fAbstractWithArity$fAbstractCompiledClauses$fAbstractClause$fAbstractPrimFun$fAbstractDefn$fAbstractProjection $fAbstract[]0 $fAbstract[]1$fAbstractRewriteRule$fAbstractDefinition$fAbstractTele$fAbstractSort$fAbstractType'$fAbstractTerm$fAbstractPermutation$fApplyPermutation$fAbstractDrop $fApplyDrop $fApply(,,) $fApply(,) $fApplyMap $fApplyMaybe$fApplyBlocked $fApply[]$fApplyDisplayTerm$fApplyClauseBodyF$fApplyFunctionInverse' $fApplyCase$fApplyWithArity$fApplyCompiledClauses $fApplyClause$fApplyPrimFun $fApplyDefn$fApplyProjection $fApply[]0 $fApply[]1$fApplyRewriteRule$fApplyDefinition $fApplyTele $fApplyPtr $fApplySort $fApplyType' $fApplyTerm$fAbstractTerm(,)$fAbstractTermAbs$fAbstractTermMaybe$fAbstractTerm[]$fAbstractTermDom$fAbstractTermArg$fAbstractTermElim'$fAbstractTermLevelAtom$fAbstractTermPlusLevel$fAbstractTermLevel$fAbstractTermSort$fAbstractTermType'$fAbstractTermPtr$fAbstractTermTerm$fIsPrefixOfTerm$fIsPrefixOf[]$fIsPrefixOf[]0 $fKillVar(,)$fKillVarMaybe $fKillVar[] $fKillVarAbs $fKillVarDom $fKillVarArg$fKillVarElim' $fKillVarTele$fKillVarType' $fKillVarTerm$fShrinkCTermTerm$fShrinkCType'Type'$fShrinkCTeleTele$fShrinkCSortSort$fShrinkCElim'Elim'$fShrinkCBlockedBlocked$fShrinkCDomDom$fShrinkCArgArg$fShrinkCAbsAbs$fShrinkCHidingHiding$fShrinkCCharChar$fShrinkCLiteralLiteral$fShrinkCConNameConHead$fShrinkCDefNameQName$fShrinkCVarNameInt$fShrinkC(,)(,) $fShrinkC[][]$fShrinkCNoTypeb$fShrinkCYesTypeb$fArbitraryTermConfiguration $fGenCTerm $fGenCType' $fGenCTele $fGenCLiteral $fGenCInteger $fGenCDouble $fGenCChar $fGenCSort$fGenCProjName $fGenCDefName $fGenCElim' $fGenCAbs $fGenCDom $fGenCArg $fGenCHiding $fGenCRange' $fGenC(,)$fGenC[]$fGenCSizedList$fHasBuiltinsTCMTbillTo' addToAccount $fLensPersistentVerbosityTCState*$fLensPersistentVerbosityPersistentTCState+$fLensPersistentVerbosityCommandLineOptions&$fLensPersistentVerbosityPragmaOptions$fLensIncludeDirsTCState"$fLensIncludeDirsPersistentTCState#$fLensIncludeDirsCommandLineOptions$fLensSafeModeTCState$fLensSafeModePersistentTCState $fLensSafeModeCommandLineOptions$fLensCommandLineOptionsTCState)$fLensCommandLineOptionsPersistentTCState$fLensVerbosityTCState$fLensVerbosityPragmaOptions$fLensPragmaOptionsTCState%$fLensPragmaOptionsCommandLineOptions$fHasOptionsTCMTunsafeQNameToNamebracket' bracketP_ withInfixDeclbindToConcreteCtxHdHdDefHdConHdVar AsWhereDecls takenNames currentScope defaultEnvcurrentPrecedencewithPrecedence lookupName lookupQName lookupModulewithAbstractPrivatemakeDomainFreemergeSigAndDef openModule'declsToConcretenoImplicitArgsnoImplicitPats noImplicit appBrackets'cOpApptryToRecoverOpApptryToRecoverOpAppP recoverOpApp$fToConcretePattern'Pattern$fToConcreteLHSCore'Pattern$fToConcreteLHSLHS$fToConcreteSpineLHSLHS $fToConcreteRangeAndPragmaPragma$fToConcreteDeclaration[].$fToConcreteModuleApplicationModuleApplication$fToConcreteClause'[]$fToConcreteConstrDeclaration$fToConcreteMaybeMaybe$fToConcreteRHS(,,,)$$fToConcreteAsWhereDeclsWhereClause'$fToConcreteLetBinding[]%$fToConcreteTypedBindingTypedBinding'$fToConcreteTypedBindings[]$fToConcreteLamBinding[]$fToConcreteExprExpr$fToConcreteModuleNameQName$fToConcreteQNameQName$fToConcreteNameName$fToConcreteDontTouchMea$fToConcreteNamedNamed$fToConcreteArgArg$fToConcreteArgInfoArgInfo$fToConcrete(,,)(,,)$fToConcrete(,)(,)$fToConcrete[][]AlphapatsPEPaththePath groupClauses pathToRecord groupPathes $fEqPattern'alphaalpha'Renamerename'NameMapProjPath ProjEntryprojPE theContent mapContent clauseToPath lhsToPath pathHeads pathSplittell1$fEqLHS $fAlpha[] $fAlphaNamed $fAlphaArg $fAlphaLHS$fAlphaLHSCore'$fAlphaPattern' $fAlphaName $fRename[] $fRenameNamed $fRenameArg$fRenameDeclaration$fRenamePattern'$fRenameLHSCore' $fRenameLHS $fRenameRHS$fRenameClause'$fRenameTypedBinding$fRenameTypedBindings$fRenameLamBinding$fRenameLetBinding $fRenameExpr$fHasRangeProjEntry$fHasRangeExprViewPatternCheckConfigtopNameconNamesfldNamesParsers NotationStyle localNameslhsArgs'classifyPatternParseLHSpToppApppArgspNonfixpAtomNonfixPostfixInfixS FlatScope partsInScopefixStyle notationNameslhsArgs parseLHS'parsePatternOrSynparseModuleIdentifierparseRawModuleApplication fullParen'$fIsExprPattern $fIsExprExpr:=< inequalities$fMonadTCMExceptionT$fMonadIOExceptionT$fMonadErrorerr'ExceptionT$fMonadReaderrExceptionT$fMonadStatesExceptionT$fApplicativeExceptionT$fFunctorExceptionT$fMonadTransExceptionT$fMonadExceptionerrWriterT$fMonadExceptionerrReaderT$fMonadExceptionerrExceptionT$fMonadExceptionT$fKillRangeDrop$fKillRangeCompiledClauses$fKillRangeCase$fKillRangeWithArity$fKillRangeDisplayTerm$fKillRangePolarity$fKillRangeDisplayForm$fKillRangeOpen$fKillRangeOccurrence$fKillRangeProjection$fKillRangeTermHead$fKillRangeFunctionInverse'$fKillRangeMutualId$fKillRangeDefn!$fKillRangeCompiledRepresentation$fKillRangeRewriteRule$fKillRangeDefinition$fKillRangeSection$fKillRangeHashMap$fKillRangeMap$fKillRangeSignature$fAddContextTele$fAddContext[]$fAddContextName$fAddContextDom$fAddContext(,)$fAddContext(,)0$fAddContextDom0$fAddContext(,)1$fAddContext[]0$fIsInstantiatedMetaAbs$fUnFreezeMetaAbs$fUnFreezeMeta[]$fUnFreezeMetaLevelAtom$fUnFreezeMetaPlusLevel$fUnFreezeMetaLevel$fUnFreezeMetaSort$fUnFreezeMetaTerm$fUnFreezeMetaType'$fUnFreezeMetaMetaId$fIsInstantiatedMetaArg$fIsInstantiatedMetaMaybe$fIsInstantiatedMeta[]$fIsInstantiatedMetaLevelAtom$fIsInstantiatedMetaPlusLevel$fIsInstantiatedMetaLevel$fIsInstantiatedMetaTerm$fIsInstantiatedMetaMetaIdWithRHS' rhsRewriteEqn rhsWithExpr rhsSubclausescheckPatternLinearityrecordConstructorTypecheckModuleApplicationcheckModuleMacronotPublicWithoutOpen renamingRange toAbstractCtxlocalToAbstract' mkNamedArgmkArg'mkArg toAbstractDotscopeCheckNiceModuletelHasOpenStmsscopeCheckModule niceDeclstoAbstractOpApp RewriteRHS' AbsurdRHS'rhs rhsWhereDecls ConstrDecl IsRecordConNoRecYesRecunBlindEnsureNoLetStmsensureNoLetStmsPatternSynPatName ConPatName VarPatNamenotAModuleExprnotAnExpressionnotAValidLetBindingnothingAppliedToHiddenArgnothingAppliedToInstanceArg printLocals annotateDecl annotateDecls annotateExprexpandEllipsis setContextCPSlocalToAbstractCtxnameExpr freshQModulecheckForModuleClashtoAbstractOpArg toAbstractLammakeDomainFullbindConstructorNamewhereToAbstract qualifyName_withFunctionName$fToAbstractPatternPattern'$fToAbstractPattern'Pattern'$fToAbstractArgInfoArgInfo$fToAbstractArgArg$fToAbstractLHSCore'LHSCore'$fToAbstractNamedNamed$fToAbstractArgArg0$fToAbstractLHSCoreLHSCore'$fToAbstractLeftHandSideLHS$fToAbstractRHS'AbstractRHS$$fToAbstractRightHandSideAbstractRHS$fToAbstractAbstractRHSRHS$fToAbstractClauseClause'$fToAbstractPragma[]!$fToAbstractConstrDeclDeclaration&$fToAbstractNiceDeclarationDeclaration$fToAbstractBlindBlind$fToAbstractLetDef[]$fToAbstractLetDefs[]$fToAbstract[][] $fToAbstractTopLevelTopLevelInfo$fEnsureNoLetStms[]$fEnsureNoLetStmsTypedBindings'$fEnsureNoLetStmsLamBinding'$fEnsureNoLetStmsTypedBinding'%$fToAbstractTypedBinding'TypedBinding'$fToAbstractTypedBindings'TypedBindings!$fToAbstractLamBinding'LamBinding$fToAbstractExprExpr#$fToAbstractOldModuleNameModuleName$$fToAbstractNewModuleQNameModuleName#$fToAbstractNewModuleNameModuleName$fToAbstractOldNameQName$fToAbstractPatNameAPatName$fToAbstractOldQNameExpr$fToAbstractNewNameName$fToAbstractNewNameName0$fToAbstractMaybeMaybe$fToAbstract[][]0$fToAbstract(,,)(,,)$fToAbstract(,)(,)$fHasConstInfoTCMTmodifyStatistics modifyCounterdefaultCSSFile modToFile generatePagepagetoAtoms showMetaInfopositioncolumninCodedebugsLaTeXrunLaTeX nextToken'nonCodefixityspacestoLaTeXDebugOutputSpacesCodeNonCode MoveColumninfoTokensStatetokens indentPrev emptyState isInfixOf' isInfixOfRevisSpacesisActualSpaces nextToken resetColumn moveColumn setIndent resetIndent setIndentPrevresetIndentPrev setInCode unsetInCode logHelperloglog'nl beginCodeendCodeptOpenptOpen'ptCloseptClose'ptNL cmdPrefixcmdArg cmdIndentinfixl'infix'infixr'defaultStyFile processTokensStmodFileincludesMemoDict HashTablehashtables-1.1.2.1Data.HashTable.IOCuckooHashTableBasicHashTableLinearHashTable malformed runGetStatevcasenodeMemo emptyDicticodevaluenodeEstringEintegerEdoubleEnodeDstringDintegerDdoubleDtermDnodeCstringCintegerCdoubleC sharingStatsfileModcurrentInterfaceVersionicodeXicodeNicode0icode1icode2icode3icode4icode5icode6icode7icode8icode9icode10icode11icode12icode13icode14icode0'icode1'icode2'icode3'icode4'icode5'icode6'icode7'icode8'icode9'icode10'icode11'icode12'icode13'icode14'valu0valu1valu2valu3valu4valu5valu6valu7valu8valu9valu10valu11valu12valu13valu14 $fEmbPrjTag$fEmbPrjForced$fEmbPrjRelevance$fEmbPrjInjectiveFun$fEmbPrjEInterface$fEmbPrjInterface$fEmbPrjCompressedFile$fEmbPrjScopeInfo$fEmbPrjPrecedence$fEmbPrjMetaInfo$fEmbPrjOtherAspect$fEmbPrjAspect$fEmbPrjNameKind$fEmbPrjBuiltin$fEmbPrjPattern$fEmbPrjDelayed$fEmbPrjClauseBodyF$fEmbPrjClause$fEmbPrjIsAbstract$fEmbPrjTermHead$fEmbPrjFunctionInverse'$fEmbPrjCompiledClauses $fEmbPrjCase$fEmbPrjWithArity $fEmbPrjDefn$fEmbPrjCompiledRepresentation$fEmbPrjOccurrence$fEmbPrjPolarity$fEmbPrjMemberId$fEmbPrjGlobalId$fEmbPrjLocalId $fEmbPrjExp$fEmbPrjHaskellRepresentation$fEmbPrjHaskellExport$fEmbPrjProjection$fEmbPrjRewriteRule$fEmbPrjDefinition$fEmbPrjMutualId$fEmbPrjDisplayTerm $fEmbPrjCtxId $fEmbPrjOpen$fEmbPrjDisplayForm$fEmbPrjLiteral $fEmbPrjSort$fEmbPrjLevelAtom$fEmbPrjPlusLevel $fEmbPrjLevel $fEmbPrjTerm $fEmbPrjAbs $fEmbPrjType'$fEmbPrjConHead$fEmbPrjRelevance0$fEmbPrjHiding$fEmbPrjInduction $fEmbPrjDom $fEmbPrjArg $fEmbPrjElim' $fEmbPrjDrop$fEmbPrjPermutation $fEmbPrjTele$fEmbPrjSection$fEmbPrjHashMap$fEmbPrjSignature$fEmbPrjNameId$fEmbPrjArgInfo$fEmbPrjTypedBinding$fEmbPrjTypedBindings$fEmbPrjLetBinding$fEmbPrjLamBinding$fEmbPrjPattern' $fEmbPrjExpr$fEmbPrjRanged $fEmbPrjNamed $fEmbPrjName$fEmbPrjModuleName$fEmbPrjAmbiguousQName $fEmbPrjQName$fEmbPrjGenPart$fEmbPrjFixity'$fEmbPrjFixity$fEmbPrjKindOfName$fEmbPrjAbstractModule$fEmbPrjAbstractName$fEmbPrjWhyInScope$fEmbPrjNameSpace$fEmbPrjAccess$fEmbPrjNameSpaceId $fEmbPrjScope$fEmbPrjQName0$fEmbPrjNamePart $fEmbPrjName0 $fEmbPrjRange$fEmbPrjRange'$fEmbPrjInterval' $fEmbPrjSet $fEmbPrjMap $fEmbPrjBiMap $fEmbPrj[]$fEmbPrjTopLevelModuleName$fEmbPrjPosition'$fEmbPrjAbsolutePath $fEmbPrjBool $fEmbPrjMaybe $fEmbPrj(,,) $fEmbPrj(,) $fEmbPrj()$fEmbPrjDouble $fEmbPrjChar $fEmbPrjInt $fEmbPrjInt32$fEmbPrjWord64$fEmbPrjInteger $fEmbPrj[]0M isModCharprop_encodeModuleName_injectiveprop_encodeModuleName_OKprop_encodeModuleName_preserved $fArbitraryM$fTransformBiModuleNameWrap$fTransformBiModuleNameWrap0$fTransformBiModuleNameWrap1$fTransformBiModuleNameWrap2$fDropArgsCompiledClauses$fDropArgsClause$fDropArgsClauseBodyF$fDropArgsTele$fDropArgsFunctionInverse'$fDropArgsPermutation$fDropArgsMaybecyclicrecDefapplyWhenVerboseSgetsaskRlocalR withFreshR withFreshNamewithFreshName_$fHasConstInfoReduceM$fHasBuiltinsReduceM$fHasOptionsReduceM$fMentionsMetaConstraint$fMentionsMetaProblemConstraint$fMentionsMetaTele$fMentionsMetaElim'$fMentionsMetaClosure$fMentionsMeta(,,)$fMentionsMeta(,)$fMentionsMetaMaybe$fMentionsMeta[]$fMentionsMetaDom$fMentionsMetaArg$fMentionsMetaAbs$fMentionsMetaSort$fMentionsMetaType'$fMentionsMetaLevelAtom$fMentionsMetaPlusLevel$fMentionsMetaLevel$fMentionsMetaTerm$fExpandPatternSynonymsPattern'$fExpandPatternSynonymsNamed$fExpandPatternSynonymsArg$fExpandPatternSynonyms[]$fExpandPatternSynonymsMaybe$fInstantiateFullMaybe$fInstantiateFullQName$fInstantiateFullBuiltin$fInstantiateFullInterface$fInstantiateFullClause $fInstantiateFullCompiledClauses$fInstantiateFullCase$fInstantiateFullWithArity!$fInstantiateFullFunctionInverse'$fInstantiateFullDefn$fInstantiateFullDisplayTerm$fInstantiateFullDisplayForm$fInstantiateFullOpen$fInstantiateFullRewriteRule$fInstantiateFullDefinition$fInstantiateFullChar$fInstantiateFullTele$fInstantiateFullSection$fInstantiateFullSignature$fInstantiateFullScope$fInstantiateFullModuleName$fInstantiateFullHashMap$fInstantiateFullMap$fInstantiateFullElim'$fInstantiateFullConstraint"$fInstantiateFullProblemConstraint$fInstantiateFullClosure$fInstantiateFull(,,)$fInstantiateFull(,)$fInstantiateFull[]$fInstantiateFullDom$fInstantiateFullNamed$fInstantiateFullArg$fInstantiateFullAbs$fInstantiateFullClauseBodyF$fInstantiateFullPattern$fInstantiateFullBool$fInstantiateFullLevelAtom$fInstantiateFullPlusLevel$fInstantiateFullLevel$fInstantiateFullTerm$fInstantiateFullType'$fInstantiateFullSort$fInstantiateFullName$fNormaliseMaybe$fNormaliseMap$fNormaliseDisplayForm$fNormalisePattern$fNormaliseBool$fNormaliseConstraint$fNormaliseProblemConstraint$fNormaliseTele$fNormaliseClosure$fNormalise(,,)$fNormalise(,) $fNormalise[]$fNormaliseDom$fNormaliseNamed$fNormaliseArg$fNormaliseAbs$fNormaliseClauseBodyF$fNormaliseLevelAtom$fNormalisePlusLevel$fNormaliseLevel$fNormaliseElim'$fNormaliseTerm$fNormaliseType'$fNormaliseSort$fSimplifyDisplayForm$fSimplifyClauseBodyF$fSimplifyPattern$fSimplifyBool$fSimplifyConstraint$fSimplifyProblemConstraint$fSimplifyTele$fSimplifyClosure$fSimplify(,,) $fSimplify(,)$fSimplifyMaybe $fSimplifyMap $fSimplify[] $fSimplifyDom$fSimplifyNamed $fSimplifyArg $fSimplifyAbs$fSimplifyLevelAtom$fSimplifyPlusLevel$fSimplifyLevel$fSimplifySort$fSimplifyElim'$fSimplifyType'$fSimplifyTerm $fReduceMap$fReduceConstraint $fReduceTele$fReduceClosure $fReduceTerm $fReduce(,,) $fReduce(,) $fReduceDom $fReduceArg $fReduce[] $fReduceAbs$fReduceLevelAtom$fReducePlusLevel $fReduceLevel $fReduceElim' $fReduceSort $fReduceType'$fInstantiateMap$fInstantiateConstraint$fInstantiateTele$fInstantiateClosure$fInstantiate(,,)$fInstantiate(,)$fInstantiate[]$fInstantiateDom$fInstantiateArg$fInstantiateAbs$fInstantiateElim'$fInstantiateSort$fInstantiateType'$fInstantiateBlocked$fInstantiateLevelAtom$fInstantiatePlusLevel$fInstantiateLevel$fInstantiateTermmany'curly prettyEpicBr prettyEpicLittypVar $fMatchLevel $fMatchSort $fMatchTerm $fMatchElim' $fMatchArg $fMatch[]DotVarsreifyDisplayFormreifyDisplayFormPnameFirstIfHidden shuffleDotsstripImplicits $fDotVarsExpr $fReifyArgArgdotVarsisConPat MonoidMap unMonoidMapDoBind DontTouchNoBindYesBindDotBind AlreadyBoundBindFirstImplicitBindFirstExplicitnappsreifyApp reifyIArg reifyIArgs reifyIArg' reifyIArgs'exprInfo reifyWhenE reifyTerm$fReifyJudgementJudgement$fReify(,,,)(,,,)$fReify(,,)(,,) $fReify(,)(,) $fReify[][] $fReifyDomArg$fReifyArgInfoArgInfo $fReifyTele[] $fReifyAbs(,)$fReifyLevelExpr$fReifySortExpr$fReifyType'Expr$fReifyQNamedClause'$fDotVarsTypedBinding$fDotVarsTypedBindings $fDotVarsRHS$fDotVarsPattern'$fDotVarsClause' $fDotVars(,) $fDotVars[]$fDotVarsNamed $fDotVarsArg$fMonoidMonoidMap$fReifyClauseBodyFRHS$fReifyElim'Expr$fReifyNamedNamed$fReifyTermExpr$fReifyLiteralExpr$fReifyDisplayTermExpr$fReifyMetaIdExpr$fReifyExprExpr$fReifyNameName$fUnderscoreExpr$fPrettyTCMRewriteRule$fPrettyTCMPattern $fPrettyTCM[]$fPrettyTCMPrettyContext$fPrettyTCMTele$fPrettyTCMConHead$fPrettyTCMModuleName$fPrettyTCMQName$fPrettyTCMName$fPrettyTCMLiteral$fPrettyTCMTypeCheckingProblem$fPrettyTCMConstraint$fPrettyTCMProblemConstraint$fPrettyTCMComparison$fPrettyTCMRelevance$fPrettyTCMName0$fPrettyTCMExpr$fPrettyTCMMaybeReduced$fPrettyTCMElim'$fPrettyTCMDom$fPrettyTCMArg$fPrettyTCMNamed$fPrettyTCMBlocked$fPrettyTCMMetaId$fPrettyTCMJudgement$fPrettyTCMClauseBodyF$fPrettyTCMRange'$fPrettyTCMInterval'$fPrettyTCMPosition'$fPrettyTCMPermutation$fPrettyTCMLevel$fPrettyTCMQNamed$fPrettyTCMDisplayTerm$fPrettyTCMSort$fPrettyTCMType'$fPrettyTCMTerm$fPrettyTCMBool$fPrettyTCMInt$fPrettyTCM(,)$fPrettyTCM[]0$fPrettyTCMClosure IndefinitedropTopLevelModule prettyInEqual Verbalize verbalize PrettyUnequal prettyUnequalsayWheresayWhenpanicnameWithBinding errorStringnotCmp$fVerbalizeIndefinite$fVerbalizeRelevance$fVerbalizeHiding$fPrettyTCMCall$fPrettyTCMSplitError$fPrettyUnequalType'$fPrettyUnequalTerm$fPrettyTCMTypeError$fPrettyTCMCallInfo$fPrettyTCMTCErr$fInjectibleTerm$fInjectibleElim'$fInjectible[]$fInjectibleArg$fMonoidProblemRest$fMonoidProblem'$fPrettyTCMAsBinding$fPrettyTCMDotPatternInst$fSubstAsBinding$fSubstDotPatternInst$fSubstProblem'$fSubstProblemRest$fOrdFlexibleVar$fLensHidingFlexibleVarmappend$fPrettyCallPath$fUsableSizeVars[]$fUsableSizeVarsDeBruijnPat'$fPrettyTCMDeBruijnPat'$fIsProjPDeBruijnPat'$fMonadErrorTCErrTerM$fMonadTCMTerM $fMonadIOTerM$fMonadStateTCStateTerM$fMonadReaderTCEnvTerM$fMonadTerTerM$fEvaluateTerm$fEvaluateElim' $fEvaluateAbs $fEvaluateArg $fEvaluate[]withExprClausesinlinedClausesinline dtermToTerm$fShowSizeConstraintStripAllProjections ExtractCallsCalls termDecls termDecl' termSection termMutual termMutual' reportCalls termFunction typeEndsInDeftermDefsetMasks targetElem termToDBPstripCoConstructorsmaskNonDataArgs openClause termClauseintroHiddenLambdas constructorguardPresTyCon withFunction maskSizeLtannotatePatsWithUseSizeLt compareElim compareProjmakeCMaddGuardednesscomposeGuardednessoffsetFromConstructor subPatterns compareVarVar$fExtractCallsTerm$fExtractCallsType'$fExtractCallsSortstripAllProjectionsextractbillToTerGraph termClause' isSubTermcompareConArgs compareVar$fStripAllProjectionsTerm$fStripAllProjections[]$fStripAllProjections[]0$fStripAllProjectionsArg$fExtractCallsLevelAtom$fExtractCallsPlusLevel$fExtractCalls(,)$fExtractCalls[]$fExtractCallsElim'$fExtractCallsDom$fExtractCallsArg$fExtractCallsAbs RecordTreeRecConLeafChangesVarPatDotPatKindRecPatMDropFromRecordSplitTreeRecordSplitNodesplitCon splitAritysplitRecordPattern conjColumns insertColumn cutSublistreplaceByProjections isRecordCaserecordSplitTree runRecPatMnextVar projections removeTreetranslatePattern recordTree translateTel translateBody permToSubst dropBindsRecordSplitTreestranslatePatterns $fDropFrom[] $fDropFrom(,)$fDropFromSplitTree' $fOccurs[] $fOccurs(,) $fOccursDom $fOccursArg $fOccursAbs $fOccursElim' $fOccursSort $fOccursType'$fOccursLevelAtom$fOccursPlusLevel $fOccursLevel$fOccursClause $fOccursDefn $fOccursQName $fOccursTerm$fErrorInvertExcept$fNoProjectedVar[]$fNoProjectedVarArg$fNoProjectedVarTerm$fErrorProjVarExc NameKindstokenHighlighting nameKindsgenerateConstructorInfo nameToFile nameToFileA concreteBaseconcreteQualifier bindingSiteSynEqMinequalifEqual $fSynEqType' $fSynEqTermsynEqsynEq'<$$>pure2<**>$fSynEqArgInfo $fSynEqDom $fSynEqArg $fSynEqAbs $fSynEqElim' $fSynEq[] $fSynEqSort$fSynEqLevelAtom$fSynEqPlusLevel $fSynEqLevel$fHasPolarityLevelAtom$fHasPolarityPlusLevel$fHasPolarityLevel$fHasPolarityTerm$fHasPolarityElim'$fHasPolarityType'$fHasPolarity(,)$fHasPolarity[]$fHasPolarityAbs$fHasPolarityDom$fHasPolarityArg$fSemiRingEdge$fSemiRingOccurrence$fPrettyTCMGraph$fPrettyTCMWithNode$fPrettyTCMWithNode0$fPrettyTCMOccurrence$fPrettyTCMNode$fComputeOccurrences(,)$fComputeOccurrences[]$fComputeOccurrencesDom$fComputeOccurrencesArg$fComputeOccurrencesElim'$fComputeOccurrencesAbs$fComputeOccurrencesTele$fComputeOccurrencesType'$fComputeOccurrencesLevelAtom$fComputeOccurrencesPlusLevel$fComputeOccurrencesLevel$fComputeOccurrencesTerm$fComputeOccurrencesClause$fPrettyTCMOccursWhere$fUnquoteUnquotedFunDef$fUnquoteClause$fUnquotePattern $fUnquoteTerm$fUnquoteLiteral$fUnquoteType'$fUnquoteLevel $fUnquoteSort $fUnquoteAbs$fUnquoteConHead$fUnquoteQName$fUnquoteRelevance$fUnquoteHiding $fUnquote[] $fUnquoteStr $fUnquoteChar$fUnquoteDouble$fUnquoteInteger$fUnquoteElim' $fUnquoteArg$fUnquoteArgInfo $fFromTerm[]$fFromTermBool$fFromTermQName $fFromTermStr$fFromTermChar$fFromTermDouble $fFromTermLvl $fFromTermNat$fFromTermInteger $fToTerm[]$fToTermArgInfo $fToTermType' $fToTermTerm $fToTermBool $fToTermQName $fToTermStr $fToTermChar$fToTermDouble $fToTermLvl $fToTermNat$fToTermInteger $fPrimTermIO $fPrimTerm[]$fPrimTermType'$fPrimTermQName $fPrimTermLvl $fPrimTermNat $fPrimTermStr$fPrimTermDouble$fPrimTermChar$fPrimTermBool$fPrimTermInteger $fPrimTypea$fPrimTerm(->) $fShowNat $fShowLvl $fIntegralNat$fMonoidUnifiable$fSubstHHTeleTele$fSubstHH(,)(,)$fSubstHHAbsAbs$fSubstHHDomDom$fSubstHHArgArg$fSubstHHType'HomHet$fSubstHHTermHomHet$fSubstHHHomHetHomHet$fApplyHHType' $fApplyHHTerm$fPrettyTCMHomHet $fSubstHomHet $fUReduce[] $fUReduceArg $fUReduce(,,) $fUReduce(,)$fUReduceMaybe$fUReduceHomHet$fUReduceType' $fUReduceTerm$fSubstEquality$fErrorUnifyException$fHasConstInfoUnify$fMonadReaderTCEnvUnify$fMonadStateTCStateUnify$fMonadTCMUnify inferSpineshouldBeProjectible checkSort checkLevelmetaTypesubtype checkSpine checkArgs checkArgInfo checkHidingcheckRelevance checkColor shouldBePi shouldBeSortifIsSort$fPrettyTCMConstraint'$fSubstSizeExpr' $fOrdSizeMeta $fEqSizeMeta$fPrettyTCMHypSizeConstraint $fFlexsSizeMetaHypSizeConstraint$fSubstConstraint'$fSubstSizeMeta$fPrettyTCMSizeMeta$fPlusNamedRigidIntNamedRigid$fShowNamedRigid$fOrdNamedRigid$fEqNamedRigid$fConvColor[][]$fConvColorDomDom$fConvColorArgArg$fConvColorArgInfoArgInfo $fError(,,)builtinPostulate coreBuiltinsinductiveCheckbindBuiltinNatbindBuiltinInfoinitialAnalysis compileDefns setEpicDirrunEpic runEpicMaincallEpic callEpic'compilePreludereadEInterface compileModuleidPrint$fToConcreteNamedMetaExpr$fToConcreteInteractionIdExpr.$fToConcreteOutputConstraint'OutputConstraint'$fPrettyOutputConstraint',$fToConcreteOutputConstraintOutputConstraint $fToConcreteOutputFormOutputForm$fShowOutputConstraint$fShowOutputForm!$fReifyConstraintOutputConstraint$fReifyProblemConstraintClosure AutoHintMode AHMModuleAHMNoneMRefine MCaseSplitMNormalinsertAbsurdPatterngetNamedispmsg autohints insuffsols insuffcands parseargsControl.Monad.Trans.State.LazyStateTControl.Monad.Trans.ClassControl.Monad.IO.ClassliftIO Text.Readreads$fReadPosition'$fReadAbsolutePath$fReadInterval' $fReadRange'$fReadInteractionIdlispifyResponselastTag showNumIId