śĪ!± uč’§      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR S TUVW X Y Z [ \ ] ^ _ ` a b cdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘ ’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßą į ā ć ä å ę ē čéźėģķīļšńņóōõö÷ųłśūüżž’        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`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ū0ü0ż0ž0’0011111111 1 1 1 1 1222222222222222222 2!2"2#2$2%3&3'3(3)3*3+3,3-3.3/303132334445464748494:4;4<4=4>5?5@5A5B5C5D5E5F5G5H5I5J5K5L6M6N6O6P6Q6R6S6T6U6V6W6X6Y6Z6[6\6]6^7_7`7a7b7c7d7e7f7g7h7i8j8k8l8m8n8o8p8q8r8s8t8u8v8w9x9y9z9{9|9}9~99€99‚9ƒ9„9…9†9‡9ˆ9‰:Š:‹:Œ::Ž:::‘:’:“:”:•:–:—;˜;™;š;›;œ;;ž;Ÿ; ;”;¢;£;¤;„;¦;§;Ø<©<Ŗ<«<¬<­<®<Æ<°<±<²<³=“=µ=¶=·=ø=¹=ŗ=»=¼=½=¾=æ=Ą=Į>Ā>Ć>Ä>Å>Ę>Ē>Č>É>Ź>Ė>Ģ>Ķ>Ī>Ļ>Š>Ń>Ņ?Ó?Ō?Õ?Ö?×?Ų?Ł?Ś?Ū?Ü?Ż?Ž?ß?ą@į@ā@ć@ä@å@ę@ē@č@é@źAėAģAķAīAļAšAńAņAóAōAõAöA÷AųAłBśBūBüBżBžB’BBBBBBCCDD D D D D DDDDDDDDDDDDDDDDDDD D!D"D#D$D%D&D'D(D)D*D+D,D-D.D/D0D1D2D3D4D5D6D7D8D9D:D;D<D=D>D?D@DADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQDRDSDTDUDVDWDXEYEZE[E\E]E^E_E`EaEbEcEdEeEfEgFhFiFjFkFlFmFnFoFpFqFrFsFtFuFvFwFxFyFzF{F|F}F~FF€FF‚FƒF„F…F†F‡FˆF‰FŠF‹FŒFFŽFFF‘F’F“F”F•F–F—F˜F™FšF›FœFFžFŸF F”F¢F£F¤F„F¦F§FØF©FŖF«F¬F­F®FÆF°F±F²F³F“FµF¶F·FøF¹FŗF»F¼F½F¾FæFĄFĮFĀFĆFÄFÅFĘFĒFČFÉFŹFĖFĢFĶFĪFĻFŠFŃFŅFÓFŌFÕFÖF×FŲFŁFŚFŪFÜFŻFŽFßFąFįFāFćFäFåFęFēFčFéFźFėFģFķFīFļFšFńFņFóFōFõFöF÷FųFłFśFūFüFżFžF’FFFFFFFFFF F F F F FFFFFFFFFFFFFFFFFFF F!F"F#F$F%F&F'F(F)F*F+F,F-F.F/F0F1F2F3F4F5F6F7F8F9F:F;F<F=F>F?F@FAFBFCFDFEFFFGFHFIFJFKFLFMFNFOFPFQFRFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaFbFcFdFeFfFgFhFiFjFkFlFmFnFoFpFqFrFsFtFuFvFwFxFyFzF{F|F}F~FF€FF‚FƒF„F…F†F‡FˆF‰FŠF‹FŒFFŽFFF‘F’F“F”F•F–F—F˜F™FšF›FœFFžFŸF F”F¢F£F¤F„F¦F§FØF©FŖF«F¬F­F®FÆF°F±F²F³F“FµF¶F·FøF¹FŗF»F¼F½F¾FæFĄFĮFĀFĆFÄFÅFĘFĒFČFÉFŹFĖFĢFĶFĪFĻFŠFŃFŅFÓFŌFÕFÖF×FŲFŁFŚFŪFÜFŻFŽFßFąFįFāFćFäFåFęFēFčFéFźFėGģGķGīGļGšGńGņGóGōGõGöG÷GųGłGśGūGüGżGžG’GGGGGGGGGG G G G G GGGGGGGGGGGGGGGGGGG H!H"H#H$H%H&H'H(H)H*H+H,H-H.H/H0H1H2H3H4H5H6H7H8H9H:H;H<H=I>I?I@IAIBICIDIEIFIGIHIIIJJKJLJMJNJOJPJQJRKSKTKUKVKWKXKYKZK[K\K]K^K_K`KaKbKcKdKeKfKgKhKiKjKkKlLmLnLoLpLqLrLsLtLuLvLwLxLyLzL{L|L}M~MM€MM‚MƒM„M…M†M‡MˆM‰MŠM‹MŒMNŽNNN‘N’N“N”N•N–N—N˜N™NšN›OœOOžOŸO O”O¢O£O¤O„O¦O§OØO©PŖP«P¬P­P®PÆP°P±P²P³P“PµP¶P·PøP¹PŗP»P¼Q½Q¾QæQĄQĮQĀQĆQÄQÅQĘQĒQČQÉQŹQĖQĢQĶQĪQĻQŠQŃQŅQÓQŌQÕQÖQ×RŲRŁRŚRŪRÜRŻRŽRßRąRįRāRćRäRåRęRēRčRéRźRėRģRķRīRļRšRńRņRóRōRõRöR÷RųRłRśSūSüSżSžS’S S S T T T T T T T T T T T T T T U U U U U U U U U U U U U V V V V !V "V #V $V %V &V 'V (V )V *V +V ,W -W .W /W 0W 1W 2W 3W 4W 5W 6W 7W 8W 9W :W ;W <W =W >W ?W @W AW BW CW DW EW FW GW HW IW JX KX LX MX NX OX PX QX RX SX TX UX VY WY XY YY ZY [Y \Y ]Y ^Y _Y `Y aY bY cY dY eY fY gY hY iY jY kY lY mY nY oY pY qY rY sY tY uY vY wY xY yY zY {Y |Z }Z ~Z Z €Z Z ‚Z ƒZ „Z …Z †Z ‡Z ˆ[ ‰[ Š[ ‹[ Œ[ [ Ž[ [ \ ‘\ ’\ “\ ”\ •\ –\ —] ˜] ™] š^ ›^ œ_ _ ž_ Ÿ_  _ ”_ ¢_ £_ ¤_ „_ ¦_ §_ Ø_ ©_ Ŗ_ «` ¬` ­` ®` Æ` °` ±` ²` ³` “` µ` ¶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 Óc Ōc Õc Öc ×c Ųc Łc Śc Ūc Üc Żc Žc ßc ąd įd āe će äe åe ęe ēe če ée źf ėf ģf ķf īf ļf šf ńf ņf óf ōf õf öf ÷g ųg łg śg ūg üg żg žg ’g g g g h h h h h h h h h h h h h h i i i i i i i i i i j j j j j j !j "j #k $k %k &k 'k (k )k *k +k ,k -k .k /l 0l 1l 2l 3l 4l 5l 6l 7l 8l 9l :l ;l <l =l >l ?l @l Al Bl Cl Dl El Fl Gl Hl Il Jl Km Lm Mm Nm Om Pm Qm Rm Sm Tm Um Vm Wm Xm Ym Zm [m \m ]m ^m _m `m am bm cm dm em fm gm hm im jm km lm mm nm om pm qm rm sm tm um vm wm xm ym zm {m |m }m ~m m €m m ‚m ƒm „m …n †n ‡n ˆn ‰n Šn ‹n Œn n Žn n n ‘n ’n “n ”n •n –n —n ˜n ™n šn ›n œn n žn Ÿn  n ”n ¢n £n ¤n „n ¦n §n Øn ©n Ŗn «n ¬n ­n ®n Æ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 Č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 į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 ś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 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 ,o -o .o /o 0o 1o 2o 3o 4o 5o 6o 7o 8o 9o :o ;o <o =o >o ?o @o Ao Bo Co Do Eo Fo Go Ho Io Jo Ko Lo Mo No Oo Po Qo Ro So To Uo Vo Wo Xo Yo Zo [p \p ]p ^p _p `p ap bp cp dp ep fp gp hp ip jp kp lp mp np op pp qp rp sp tp up vp wp xp yp zp {p |p }p ~p p €p p ‚p ƒp „p …p †p ‡p ˆp ‰p Šp ‹p Œp p Žp p p ‘p ’p “p ”p •p –p —p ˜p ™p šp ›p œp p žp Ÿp  p ”p ¢p £p ¤p „p ¦q §q Øq ©q Ŗ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 ē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 t t t t t t t t t t !t "t #t $t %t &t 't (t )t *u +u ,u -v .v /v 0v 1v 2v 3v 4v 5v 6v 7v 8v 9v :v ;v <v =v >v ?v @v Av Bv Cw Dw Ew Fw Gw Hw Iw Jx Kx Lx Mx Nx Ox Px Qx Rx Sx Tx Ux Vx Wx Xx Yx Zx [x \x ]x ^x _x `x ax bx cx dx ex fx gx hx ix jx kx lx mx nx ox px qy ry sy ty uy vy wy xz yz zz {z |z }z ~z z €z z ‚z ƒz „z …z †z ‡z ˆz ‰z Š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’{’|’}’~’’€’’‚’ƒ’„’…’†’‡’ˆ’‰’Š’‹’Œ’’Ž’’’‘’’’“’”’•’–’—’˜’™’š’›’œ’’ž’Ÿ’ ’”’¢’£’¤’„’¦’§“ؓ©“Ŗ“«“¬“­“®“Ɠ°“±“²“³“““µ“¶“·“ø“¹“ŗ“»“¼“½“¾“æ“Ą“Į“Ā“ƔĔŔʔĒ”ȔɔŹ”Ė”Ģ”Ķ”Ī”Ļ”Š”єŅ”ӔŌ”Ք֔הŲ”Ł”Ś”Ū”ܔŻ”Ž”ߔą”į•ā•ć•ä•å–ę–ē—č—é—ź—ė—ģ—ķ—ī—ļ—š—ń—ņ—ó—ō—õ—ö—÷—ų—ł—ś—ū—ü—ż—ž—’—————————— — — — — ——————————————————— —!—"—#—$—%—&—'˜(˜)˜*˜+˜,˜-˜.˜/˜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ŗ{ŗ|ŗ}ŗ~ŗŗ€ŗŗ‚ŗƒŗ„»…»†»‡»ˆ»‰»Š¼‹¼Œ¼¼Ž¼¼¼‘¼’¼“¼”¼•¼–‘—‘˜‘™‘š‘›‘œ‘‘ž‘Ÿ‘ ‘”‘¢‘£‘¤‘„‘¦‘§‘ؑ©‘Ŗ‘«‘¬‘­‘®‘Ƒ°‘±‘²‘³‘“‘µ‘¶‘·‘ø‘¹‘ŗ‘»‘¼½½½¾½æ½Ą½Į½Ā½Ć½ĽŽĘ½Ē½Č½ɽŹ½Ė½Ģ½Ķ½Ī½Ļ½Š½Ń½Ņ½Ó½Ō¾ÕæÖĄץŲĄŁĄŚĄŪĄÜĄŻĄŽĄߥąĄįĮāĮćĮäĮåĮęĮēĮčĮéĮźĮėĀģĀķĀīĀļĀšĀńĀņĀóĀōĀõĀöĀ÷ĀųĀłĀśĀūĀüĀżĀžĆ’ĆĆĆĆĆĆĆĆĆĆ Ć Ć Ä Å ĘĘĘĘĘĘĘĘĘĘĘĘĘĘĒĒĒĒĒ Ē!Ē"Ē#Ē$Ē%Ē&Ē'Ē(Ē)Ē*Ē+Ē,Ē-Ē.Ē/Č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¹{¹|Ė}Ė~ĖĖ€ĖĖ‚ĖƒĖ„Ė…Ģ†Ģ‡ĢˆĢ‰ĢŠĢ‹ĢŒĢĶŽĶĶĶ‘Ķ’Ķ“Ķ”Ķ•Ķ–Ķ—Ķ˜Ķ™ĪšĪ›ĪœĪĪžĻŸĻ Ļ”Ļ¢Ļ£Ļ¤Ļ„Ļ¦Ļź Safeg ĻRCabal8Lazily reconstruct a value previously written to a file.KLMNO§Ø©Ŗ«¬­®Æ°±²³HFGE“µ¶·RSSRSafe…OPQPQOSafeŪuTUVUVTuŠSafe9ø¹ŗWŃSafeˆ»¼ None8=?@AC1XCabalThe FunctionalDependencies version of X type-class.ASince Cabal-3.0 class arguments are in a different order than in newtype. package. This change is to allow usage with DeriveAnyClass (and DerivingStrategies<, in GHC-8.2). Unfortunately one have to repeat inner type. 8newtype New = New Old deriving anyclass (Newtype Old) !Another approach would be to use  TypeFamilies) (and possibly compute inner type using  GHC.Generics), but we think FunctionalDependencies( version gives cleaner type signatures.[Cabal#ala Sum foldMap [1, 2, 3, 4 :: Int]10Note:/ the user supplied function for the newtype is ignored.,ala (Sum . (+1)) foldMap [1, 2, 3, 4 :: Int]10\Cabal,alaf Sum foldMap length ["cabal", "install"]12Note: as with [0, the user supplied function for the newtype is ignored.]Cabal Variant of Y, which takes a phantom type.^Cabal Variant of Y, which takes a phantom type.XYZ[\]^XYZ[\]^None7>MUV&ņcCabalA wrapper around H, providing the < and = instances implemented for H since  base-4.11.fCabal A copy of ½.iCabal A copy of ¾.lCabalGenerically generate a < (') operation for any type implementing ;. This operation will append two values by point-wise appending their component fields. It is only defined for product types. l a (l b c) = l (l a b) c mCabalGenerically generate a =  ) for any product-like type implementing ;.%It is only defined for product types. l m a = a = l a m <= !"ŽŒ‘cdefghijklm<= !"ŽŒ‘ijkfghcdelmSafeSX/“ˆCabal™Give the *parent* of the person who invoked this; so it's most suitable for being called from a utility function. You probably want to call this using n„; otherwise it's not very useful. We didn't implement this for base-4.8.1 because we cannot rely on freezing to have taken place.ŠCabaleThis function is for when you *really* want to add a call stack to raised IO, but you don't have a RŅ so you can't use  Ó. If you have a  Verbosity$, please use that function instead.Qnot‡ˆ‰Š‡QŠn‰otˆŌNone>SUVX6XæCabalHidden internal type-classCabal New name for ÕÖŽCabal GHC.Generics-based M implementation#This is needed in order to support  deepseq < 1.4 which didn't have a ;-based default M implementation yet.&In order to define instances, use e.g. -instance NFData MyType where rnf = genericRnf'The implementation has been taken from  deepseq-1.4.2 's default M implementation.’F &ęå' ēčźé(;)ŗ¹ø·¶µ“³²±°Æ®­¬«Ŗ©* ߎ+ŻÜŪŚŁŲ,-.+/  0DCBA=<1§¦23ČĒĘÅÄĆĀĮĄæ¾½¼»4äćāįą5óņń678$#%,9ˆ†‡Š‹‰‚„ƒ…:_`;<= !">RU?@ABCDEFGHSTIXYZJKLMNOPVW[\]^bcdefghijklmpqrsvwxyz{|}~€’“”•–—˜™š›œžŸ ”¢¤„ØÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ėģķīļšōõö÷ųłśūüżž’      !"#$%&'()*10/.-43265789:>?@HFGEINMlm‹ŒŽ×BSD3cabal-dev@haskell.org experimentalportableNoneSX<Ę‘‘None=’F &ęå' ēčźé(;)ŗ¹ø·¶µ“³²±°Æ®­¬«Ŗ©* ߎ+ŻÜŪŚŁŲ,-.+/  0DCBA=<1§¦23ČĒĘÅÄĆĀĮĄæ¾½¼»4äćāįą5óņń678$#%,9Š‹‡†‰ˆ‚„ƒ…:`_;<= !">RU?@ABCDEFGHSTIXYZJKLMNOPVW[\]^bcdefghijklmpqrsvwxyz{|}~€’“”•–—˜™š›œžŸ ”¢¤„ØÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ėģķīļšōõö÷ųłśūüżž’      !"#$%&'()*10/.-43265789:>?@HFGEINMlm‹ŒŽ’F &ęå' ēčźé(;)ŗ¹ø·¶µ“³²±°Æ®­¬«Ŗ©* ߎ+ŻÜŪŚŁŲ,.+/  0DCBA=<1§¦23ČĒĘÅÄĆĀĮĄæ¾½¼»4äćāįą5óņń8$#%,‰‚„ƒ…= !">RU?@ABGHSTIXYZJPVWbcdefghijklmpqrswz{|}~’“”•”¢¤„ØŃŅÓŌÕÖ×ģķīļšōõö÷ųłśūüżž’      !"#$*789:>?@<lm6-;NMŽHFGE10/.-4327Œ‹I–Ÿž™š˜—œ›659‹Š‡†vˆ€yx:`_^('[)&Š\]ĻĪĖĶĢė%ŹÉKLMNOCDEF (c) Edward Kmett 2011-2012BSD3ekmett@gmail.com experimental non-portableNone&'•’CabalNAdditional functionality needed to describe parsers independent of input type.“CabalzTake a parser that may consume input, and on failure, go back to where we started and fail as if we didn't consume input.”CabalGive a parser a name•CabaliA version of many that discards its input. Specialized because it can often be implemented more cheaply.–Cabal skipSome p applies the parser p one? or more times, skipping its result. (aka skipMany1 in parsec)—Cabal,Used to emit an error on an unexpected token˜CabalkThis parser only succeeds at the end of the input. This is not a primitive parser but it is defined using ™. 0 eof = notFollowedBy anyChar <?> "end of input"™CabalnotFollowedBy p only succeeds when parser p¦ fails. This parser does not consume any input. This parser can be used to implement the 'longest match' rule. For example, when recognizing keywords (for example let›), we want to make sure that a keyword is not followed by a legal identifier character, in which case the keyword is actually an identifier (for example lets-). We can program this behaviour as follows: ; keywordLet = try $ string "let" <* notFollowedBy alphaNumšCabal choice ps( tries to apply the parsers in the list psT in order, until one of them succeeds. Returns the value of the succeeding parser.›Cabal option x p tries to apply parser p. If p6 fails without consuming input, it returns the value x#, otherwise the value returned by p. + priority = option 0 (digitToInt <$> digit)œCabalskipOptional p tries to apply parser p. It will parse p or nothing. It only fails if p9 fails after consuming input. It discards the result of pT. (Plays the role of parsec's optional, which conflicts with Applicative's optional)Cabalbetween open close p parses open, followed by p and close!. Returns the value returned by p. , braces = between (symbol "{") (symbol "}")žCabal sepBy p sep parses zero or more occurrences of p, separated by sep'. Returns a list of values returned by p. % commaSep p = p `sepBy` (symbol ",")ŸCabal sepBy1 p sep parses one or more occurrences of p, separated by sep'. Returns a list of values returned by p. CabalsepByNonEmpty p sep parses one or more occurrences of p, separated by sep1. Returns a non-empty list of values returned by p.”CabalsepEndBy1 p sep parses one or more occurrences of p%, separated and optionally ended by sep(. Returns a list of values returned by p.¢CabalsepEndBy p sep parses zero or more occurrences of p%, separated and optionally ended by sepF, ie. haskell style statements. Returns a list of values returned by p. 6 haskellStatements = haskellStatement `sepEndBy` semi£Cabal endBy1 p sep parses one or more occurrences of p, separated and ended by sep'. Returns a list of values returned by p.¤Cabal endBy p sep parses zero or more occurrences of p, separated and ended by sep'. Returns a list of values returned by p. ( cStatements = cStatement `endBy` semi„Cabal count n p parses n occurrences of p. If n4 is smaller or equal to zero, the parser equals to  return []. Returns a list of n values returned by p.¦Cabal chainr p op x parses zero or more occurrences of p, separated by op Returns a value obtained by a right7 associative application of all functions returned by op to the values returned by p!. If there are no occurrences of p , the value x is returned.§Cabal chainl p op x parses zero or more occurrences of p, separated by op . Returns a value obtained by a left7 associative application of all functions returned by op to the values returned by p#. If there are zero occurrences of p , the value x is returned.ØCabalchainl1 p op x parses one or more occurrences of p, separated by op Returns a value obtained by a left7 associative application of all functions returned by op to the values returned by ps. . This parser can for example be used to eliminate left recursion which typically occurs in expression grammars. Õ expr = term `chainl1` addop term = factor `chainl1` mulop factor = parens expr <|> integer mulop = (*) <$ symbol "*" <|> div <$ symbol "/" addop = (+) <$ symbol "+" <|> (-) <$ symbol "-"©Cabalchainr1 p op x parses one or more occurrences of p, separated by op Returns a value obtained by a right7 associative application of all functions returned by op to the values returned by p.ŖCabalmanyTill p end applies parser p zero or more times until parser end2 succeeds. Returns the list of values returned by p,. This parser can be used to scan comments: x simpleComment = do{ string "<!--" ; manyTill anyChar (try (string "-->")) }Note the overlapping parsers anyChar and  string "-->"#, and therefore the use of the “ combinator.a-.’“˜•—”™–š›œžŸ ”¢£¤„¦§Ø©Ŗš›aœ.-žŸ ”¢£¤„§¦Ø©Ŗ’“˜•—”™–”0(c) Edward Z. Yang 2016BSD3cabal-dev@haskell.org experimentalportableNone 2>HVÅp“Cabal,A simple, trivial data type which admits an ¶ instance.¶CabalThe ¶T class is used for datatypes which represent directed graph nodes. A node of type a- is associated with some unique key of type · a); given a node we can determine its key (ø") and the keys of its neighbors (¹).ŗCabalA graph of nodes a5. The nodes are expected to have instance of class ¶.»CabalGet the value from a “.¼CabalO(1). Is the graph empty?½CabalO(1)#. The number of nodes in the graph.¾CabalO(log V)#. Check if the key is in the graph.æCabalO(log V)(. Lookup the node at a key in the graph.ĄCabalO(1). The empty graph.ĮCabalO(log V). Insert a node into a graph.ĀCabalO(log V)*. Delete the node at a key from the graph.ĆCabalO(log V)M. Lookup and delete. This function returns the deleted value if it existed.ÄCabal O(V + V')U. Right-biased union, preferring entries from the second map when conflicts occur. ø x = ø (f x).ÅCabal O(V + V')Q. Left-biased union, preferring entries from the first map when conflicts occur.ĘCabal©(V + E)b. Compute the strongly connected components of a graph. Requires amortized construction of graph.ĒCabal©(V + E)K. Compute the cycles of a graph. Requires amortized construction of graph.ČCabalO(1)š. Return a list of nodes paired with their broken neighbors (i.e., neighbor keys which are not in the graph). Requires amortized construction of graph.ÉCabalbLookup the immediate neighbors from a key in the graph. Requires amortized construction of graph.ŹCabaljLookup the immediate reverse neighbors from a key in the graph. Requires amortized construction of graph.ĖCabalHCompute the subgraph which is the closure of some set of keys. Returns Nothing` if one (or more) keys are not present in the graph. Requires amortized construction of graph.ĢCabalHCompute the reverse closure of a graph from some set of keys. Returns Nothing` if one (or more) keys are not present in the graph. Requires amortized construction of graph.ĶCabalSTopologically sort the nodes of a graph. Requires amortized construction of graph.ĪCabal[Reverse topologically sort the nodes of a graph. Requires amortized construction of graph.ĆCabalO(1)[. Convert a map from keys to nodes into a graph. The map must satisfy the invariant that Ć m == fromList (ŲŁ m)+; if you can't fulfill this invariant use fromList (ŲŁ m)E instead. The values of the map are assumed to already be in WHNF.ĻCabal O(V log V)<. Convert a list of nodes (with distinct keys) into a graph.ŠCabalO(V)'. Convert a graph into a list of nodes.ŃCabalO(V)&. Convert a graph into a list of keys.ŅCabalO(V)%. Convert a graph into a set of keys.ÓCabalO(1)D. Convert a graph into a map from keys to nodes. The resulting map m* is guaranteed to have the property that x ((k,n) -> k == ø n) (ŲŚ m).ŌCabalO(1). Convert a graph into a ŪÜ,. Requires amortized construction of graph.$LKJ“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌ$ŗ¶·ø¹¼½¾æĄĮĀĆÅÄĘLKJĒČÉŹĖĢĶĪÓĻŠŃŅŌ“µ»Żcabal-devel@haskell.org Windows-onlyNoneĒ\Ä (c) Ben Gamari 2015-2019BSD3cabal-dev@haskell.org experimentalportableNoneÉÉąCabalDifference list.āCabalMake ą with containing single element.ąįāćäåąįāćäåNoneSXĢ®čCaballens, variant is also parametrised by profunctor.ųCabal)(3 :: Int) ^. getting (+2) . getting show"5"Cabal" is a reverse application operator%čéźėģķīļšńņóōõö÷ųłśūüżž’    %óńņšõōļīķģėö÷ųłśūüż ž’   čéź 18444444 8 4 4ŽNoneÕ ÅCabal:Copies a file to a new destination. Often you should use Ę instead.ĘCabalLike Å©, but does not touch the target if source and destination are already byte-identical. This is recommended as it is useful for time-stamp based recompilation avoidance.ĒCabal~Checks if two files are byte-identical. Returns False if either of the files do not exist or if files are of different size.ČÉŹÅĘĒ(c) Edward Kmett 2011BSD3ekmett@gmail.com experimental non-portableNone&'>XųCabal;Additional functionality needed to parse character streams.Cabal:Parse a single character of the input, with UTF-8 decodingCabalchar c parses a single character c&. Returns the parsed character (i.e. c).e.g.  semiColon =  ';'Cabal notChar c( parses any single character other than c . Returns the parsed character.CabalEThis parser succeeds for any character. Returns the parsed character.Cabalstring s* parses a sequence of characters given by s#. Returns the parsed string (i.e. s). ; divOrMod = string "div" <|> string "mod"Cabaltext t8 parses a sequence of characters determined by the text t) Returns the parsed text fragment (i.e. t).Using OverloadedStrings: 7 divOrMod = text "div" <|> text "mod"CabaloneOf csJ succeeds if the current character is in the supplied list of characters cs*. Returns the parsed character. See also .  vowel = oneOf "aeiou"CabalAs the dual of ,  noneOf cs' succeeds if the current character is not$ in the supplied list of characters cs . Returns the parsed character.  consonant = noneOf "aeiou"CabalSkips zero* or more white space characters. See also •.Cabal>Parses a white space character (any character which satisfies Ļ ) Returns the parsed character.Cabal?Parses a newline character ('\n'). Returns a newline character.Cabal7Parses a tab character ('\t'). Returns a tab character.Cabal:Parses an upper case letter. Returns the parsed character.Cabal<Parses a lower case character. Returns the parsed character.Cabal7Parses a letter or digit. Returns the parsed character. CabalWParses a letter (an upper case or lower case character). Returns the parsed character.!Cabal-Parses a digit. Returns the parsed character."CabalsParses a hexadecimal digit (a digit or a letter between 'a' and 'f' or 'A' and 'F'). Returns the parsed character.#CabalWParses an octal digit (a character between '0' and '7'). Returns the parsed character.&CabalQGreedily munch characters while predicate holds. Require at least one character.'CabalBGreedely munch characters while predicate holds. Always succeeds.5a.-’“˜•—”™–š›œžŸ ”¢£¤„¦§Ø©Ŗ !"#$%&'( !"#$%&'(None27ż;Cabal"Different Cabal-the-spec versions./We branch based on this at least in the parser.<Cabalthis is older than ==Cabalnew syntax (sections)KCabal<Show cabal spec version, but not the way in the .cabal files2435768:9;JIHGFEDCBA@?>=<KLMNO;JIHGFEDCBA@?>=<KLMNO8:9576243ßNone>SXėĖCabalsetEnv name value, sets the specified environment variable to value.Throws ąį if either name or value1 is the empty string or contains an equals sign.ĢĶĪĖNone>SXR\\None456 ]Cabal A field name. Invariant: Ļ is lower-case ASCII.`Cabal+Section arguments, e.g. name of the libraryaCabalSidentifier, or omething which loos like number. Also many dot numbers, i.e. "7.6.3"bCabal quoted stringcCabal@everything else, mm. operators (e.g. in if-section conditionals)dCabalhA line of text representing the value of a field from a Cabal file. A field may contain multiple lines. Invariant: Ļ has no newlines.fCabal2A Cabal-like file consists of a series of fields (foo: bar) and sections ( library ...).iCabalSection of field namekCabalAll transitive descendands of f, including itself.Note:# the resulting list is never empty.lCabalmCabalnCabalExtract annotation from `.]^_`abcdefhgijklmnopqfhgijkdelm`abcn_]^opqā(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportableNone;ŠCabalReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.ŃCabalpProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see Ņ)The option descriptions (see Ó)9The actual command line arguments (presumably got from ćä).Ńj returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.ŌCabalThis is almost the same as Ń’, but returns a quadruple consisting of the option arguments, a list of non-options, a list of unrecognized options, and a list of error messages. ŅÕÖ×ÓŲŁŚŪÜŠŃŌåBen Gamari 2015-2019cabal-devel@haskell.orgportableNoneuŻNoneSX!W†Cabal Patch legacy .cabal@ file contents to allow parsec parser to accept all of Hackage.=Bool part of the result tells whether the output is modified.ŽCabalŽK contains first 256 bytes, pre- and post-fingerprints and a patch function.ßCabal#Helper to create entries in patchesąCabalneedleįCabalneedleCabal replacementāCabalneedle††cabal-devel@haskell.orgportableSafe"‡ˆˆ‡None7%-‰Cabal-1-indexed row and column positions in a file.‹Cabal)Shift position by n columns to the right.ŒCabal(Shift position to beginning of next row.CabalCabal‰Š‹ŒŽ‰Š‹ŒŽNone7%ż—Cabal Parser error.—˜™—˜™None73žCabalParser warning. Cabal0Type of parser warning. We do classify warnings.TDifferent application may decide not to show some, or have fatal behaviour on others”CabalUnclassified warning¢CabalInvalid UTF encoding£Cabaltrue or false, not True or False¤Cabalthere are version with tags„CabalNew syntax used, but no cabal-version: >= 1.2 specified¦CabalOld syntax used, and cabal-version >= 1.2 specified¬Cabalextra main-is field­Cabalextra test-module field®Cabalextra benchmark-module field²Cabal+legacy cabal file that we know how to patch³CabalBDouble dash token, most likely it's a mistake - it's not a comment“Cabal3e.g. name or version should be specified only once.µCabal>Workaround for derive-package having build-type: Default. See  ,https://github.com/haskell/cabal/issues/5020.žŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶žŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶BSD3cabal-devel@haskell.orgportableNone9ŸĘCabal"position at current input locationĒCabalthe current inputČCabal lexer codeĶCabalEncountered non breaking spaceĪCabal"BOM at the start of the cabal fileĻCabal Leading tagsÖCabal5Execute the given lexer on the supplied input stream.ŽCabal#Add warning at the current positionćCabalAn alex lexer start codeĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽĆÄÅĘĒČÉŠŃŅÓŌÖŲףŚŪÜŻŹĖĢĶĪĻŽÕBSD3cabal-devel@haskell.orgportableNoneF>ččCabalHTokens of outer cabal file structure. Field values are treated opaquely.éCabal+Haskell-like identifier, number or operatorźCabalString in quotesėCabalOperators and parensģCabalIndentation tokenķCabal Lines after :ęēčńéźėģķīļšņóōõö÷ųłōóčńéźėģķīļšņęēöłų÷õBSD3cabal-devel@haskell.orgportableNone@AE]äCabalThe ä+ (with a prime) is an instance of parsec's å wrapped around lexer's Ä (without a prime)ęCabal%Get lexer warnings accumulated so farēCabal0Set Alex code i.e. the mode "state" lexer is in.üCabalParse cabal style Ļ into list of fs, i.e. the cabal AST.żCabalLike ü but also return lexer warnings ]^`abcdefhgüż fhg]^de`abcüżNoneN§Cabal}The default rendering style used in Cabal for console output. It has a fixed page width and adds line breaks automatically.Cabal&A style for rendering all on one line.Cabal…Pretty-print free-format text, ensuring that it is vertically aligned, and with blank lines replaced by dots for correct re-parsing. Cabal&Pretty-print free-format text. Since cabal-version: 3.0( we don't replace blank lines with dots.čCabalčr breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines. ’  ’NoneP  CabalSPDX License List version Cabal is aware of.  2011, Dan Knappcabal-devel@haskell.orgportableNone\Cabal¢Represents a dialect of C. The Monoid instance expresses backward compatibility, in the sense that 'mappend a b' is the least inclusive dialect which both a and b! can be correctly interpreted as.Cabal¬A list of all file extensions which are recognized as possibly containing some dialect of C code. Note that this list is only for source files, not for header files.Cabal™Takes a dialect of C and whether code is intended to be passed through the preprocessor, and returns a filename extension for containing that code.Cabal‹Infers from a filename's extension the dialect of C which it contains, and whether it is intended to be passed through the preprocessor.8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone7>dĄ#Cabal#Types that represent boolean flags.%Cabal1All flags are monoids, they come in two flavours:  list flags eg !--ghc-option=foo --ghc-option=bar&gives us all the values ["foo", "bar"] singular value flags, eg: --enable-foo --disable-foo”gives us Just False So this Flag type is for the latter singular kind of flag. Its monoid instance gives us the behaviour where it starts out as '' and later flags override earlier ones. #$%&'()*+,-. %&'-()*+,.#$None7tx<CabalThe $prefix path variable=CabalThe $bindir path variable>CabalThe $libdir path variable?CabalThe  $libsubdir path variable@CabalThe  $dynlibdir path variableACabalThe $datadir path variableBCabalThe  $datasubdir path variableCCabalThe $docdir path variableDCabalThe $htmldir path variableECabalThe $pkg package name path variableFCabalThe $version package version path variableGCabalThe $pkgid package Id path variable, eg foo-1.0HCabalThe $libname path variableICabal"The compiler name and version, eg  ghc-6.6.1JCabalThe operating system name, eg windows or linuxKCabalThe CPU architecture name, eg i386 or x86_64LCabalThe compiler's ABI identifier,MCabal%The optional ABI tag for the compilerNCabal+The executable name; used in shell wrappersOCabal$The name of the test suite being runPCabal,The result of the test suite being run, eg pass, fail, or error.QCabal#The name of the benchmark being run;<=>?@ABCDEFGHIJKLMNOPQRSTRST;<=>?@ABCDEFGHIJKLMNOPQ ...cabal-devel@haskell.orgportableNonex›aCabalNo unliteration.bCabalb„ takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text.abba!cabal-devel@haskell.orgportableNone~“cCabal@Extract the version number from the output of 'strip --version'.ßInvoking "strip --version" gives very inconsistent results. We ignore everything in parentheses (see #2497), look for the first word that starts with a number, and try parsing out the first two components of it. Non-GNU strip' doesn't appear to have a version flag.ccęSafe~ņéźėģķīļš"Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone>SXŚqCabal’‘If true, then children of this group may be run in parallel. Note that this setting is not inherited by children. In particular, consider a group F with "concurrently = False" that has some children, including a group T with "concurrently = True". The children of group T may be run concurrently with each other, as long as none are run at the same time as any of the direct children of group F.„CabalIA human-readable description of the option to guide the user setting it.‰CabalPerform the test.ŠCabal1A name for the test, unique within a test suite.‹Cabal0Users can select groups of tests by their tags.ŒCabal5Descriptions of the options recognized by this test.Cabal£Try to set the named option to the given value. Returns an error message if the option is not supported or the value could not be correctly parsed; otherwise, a ‡5 with the option set to the given value is returned.ŽCabalPCreate a named group of tests, which are assumed to be safe to run in parallel.+dfgehijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ+‡ˆ‰Š‹Œ‚ƒ„…†stuvwxyz{|}~€lmnopqrkhijdfgeŽ#None27•ś˜Cabal?A boolean expression parameterized over the variable type used.žCabalBoolean negation of a ˜ value.ŸCabalBoolean AND of two Condtion values. CabalBoolean OR of two ˜ values.”Cabal5Simplify the condition and return its free variables.”Cabal(partial) variable assignment ˜™š›œžŸ ” ˜™š›œžŸ ”$None24567²4 ±CabalA ±( represents a conditional branch, e.g.,  if flag(foo) on some syntax a). It also has an optional false branch.¶CabalA ¶Ņ is used to represent the conditional structure of a Cabal file, reflecting a syntax element subject to constraints, and then any number of sub-elements which may be enabled subject to some condition. Both a and c are usually =s.:To be more concrete, consider the following fragment of a Cabal file: Ibuild-depends: base >= 4.0 if flag(extra) build-depends: base >= 4.2 %One way to represent this is to have ¶ ConfVar [ Dependency]  BuildInfo . Here, øL represents the actual fields which are not behind any conditional, while ŗJ recursively records any further fields which are behind a conditional. ¹) records the constraints (in this case,  base >= 4.0V) which would be applied if you use this syntax; in general, this is derived off of targetBuildInfoŠ (perhaps a good refactoring would be to convert this into an opaque type, with a smart constructor that pre-computes the dependencies.)ĮCabal@ Traversal@ for the variablesĀCabal@ Traversal@ for the variablesĆCabal@ Traversal @ for the aggregated constraintsÄCabal@ Traversal @ for the aggregated constraintsÅCabalFExtract the condition matched by the given predicate from a cond tree.wWe use this mainly for extracting buildable conditions (see the Note above), but the function is in fact more general.ĘCabalwFlattens a CondTree using a partial flag assignment. When a condition cannot be evaluated, both branches are ignored.ĒCabalĄFlatten a CondTree. This will resolve the CondTree by taking all possible paths into account. Note that since branches represent exclusive choices this may not result in a "sane" result.±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒ¶·ø¹ŗ±²³“µ»¼½¾æĄĮĀĆÄÅĘĒēSafeµńCabalwHash a string using GHC's fingerprinting algorithm (a 128-bit MD5 hash) and then encode the resulting hash in base 62.ń%None¾4ŻCabalaRepresents either textual or binary data passed via I/O functions which support binary/text modeŽCabal2How Text gets encoded is usually locale-dependent.ßCabal2Raw binary which gets read/written in binary mode.ąCabal Test whether Ż is emptyįCabalŻ Wrapper for ņNote$: This operation uses lazy I/O. Use NW to force all data to be read and consequently the internal file handle to be closed.āCabalŻ Wrapper for ó and ōThis is the dual operation ot ioDataHGetContents., and consequently the handle is closed with hClose. ŚŪÜŻŽßąįā ŻŽßŚŪÜąįā&NoneæSäCabalMonadic variant of  mapAccumL.ää'None4ĖēCabalüA type to represent the unfolding of an expensive long running calculation that may fail (or maybe not expensive, but complicated!) We may get intermediate steps before the final result which may be used to indicate progress and/or logging messages.@TODO: Apply Codensity to avoid left-associativity problem. See  4http://comonad.com/reader/2011/free-monads-for-less/ and Hhttp://blog.ezyang.com/2012/01/problem-set-the-codensity-transformation/čCabalEmit a step and then continue.éCabalFail the computation.źCabal Consume a ē calculation. Much like ŠP for lists but with two base cases, one for a final result and one for failure.Eg to convert into a simple P result use: $foldProgress (flip const) Left RightēčéźēčéźčSafeŃ3ļCabalDecode 7 from UTF8-encoded octets.;Invalid data in the UTF8 stream (this includes code-points U+D800 through U+DFFF0) will be decoded as the replacement character (U+FFFD). See also ššCabalEncode 7! to a list of UTF8-encoded octetsCode-points in the U+D800-U+DFFF; range will be encoded as the replacement character (i.e. U+FFFD). See also  decodeUtf8ļš(None27×nńCabal Compact representation of short Strings-The data is stored internally as UTF8 in an õ when compiled against bytestring >= 0.10.4F, and otherwise the fallback is to use plain old non-compat '[Char]'.3Note: This type is for internal uses (such as e.g.  PackageName*) and shall not be exposed in Cabal's APIņCabal Construct ń from 7óCabalConvert ń to 7ļšńņóńņóļš#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone7>SX$U’CabalFWraps text to the default line width. Existing newlines are preserved.CabalHWraps a list of words to a list of lines of words of a particular width.Cabal?Gets the contents of a file, but guarantee that it gets closed.„The file is read lazily but if it is not fully consumed by the action then the remaining input is truncated and the file is closed.CabalWrites a file atomically.nThe file is either written successfully or an IO exception is raised and the original file is left unchanged.—On windows it is not possible to delete a file that is open by a process. This case will give an IO exception but the atomic property is not affected.CabalDecode 7 from UTF8-encoded ö;Invalid data in the UTF8 stream (this includes code-points U+D800 through U+DFFF0) will be decoded as the replacement character (U+FFFD).Cabal Variant of  for lazy ösCabalEncode 7 to to UTF8-encoded ĻCode-points in the U+D800-U+DFFF; range will be encoded as the replacement character (i.e. U+FFFD).Cabal Variant of  for lazy ösCabalCheck that strict  ByteString2 is valid UTF8. Returns 'Just offset' if it's not.CabalDIgnore a Unicode byte order mark (BOM) at the beginning of the input Cabal2Reads a UTF8 encoded text file as a Unicode StringReads lazily using ordinary f. Cabal2Reads a UTF8 encoded text file as a Unicode StringSame behaviour as . Cabal4Writes a Unicode String as a UTF8 encoded text file.Uses ", so provides the same guarantees. Cabal3Fix different systems silly line ending conventions CabaldropWhileEndLE p is equivalent to reverse . dropWhile p . reversep, but quite a bit faster. The difference between "Data.List.dropWhileEnd" and this version is that the one in  Data.Listj is strict in elements, but spine-lazy, while this one is spine-strict but lazy in elements. That's what LE" stands for - "lazy in elements".Example:=tail $ Data.List.dropWhileEnd (<3) [undefined, 5, 4, 3, 2, 1] *** Exception: Prelude.undefined...5tail $ dropWhileEndLE (<3) [undefined, 5, 4, 3, 2, 1][5,4,3]?take 3 $ Data.List.dropWhileEnd (<3) [5, 4, 3, 2, 1, undefined][5,4,3]7take 3 $ dropWhileEndLE (<3) [5, 4, 3, 2, 1, undefined] *** Exception: Prelude.undefined...CabaltakeWhileEndLE p is equivalent to reverse . takeWhile p . reverse;, but is usually faster (as well as being easier to read).CabalLike éź , but has  O(n log n) complexity instead of O(n^2) . Code for  and  taken from Niklas Hambüchen's  $http://github.com/nh2/haskell-ordnubordnub package.CabalLike  and éėF. Selects a key for each element and takes the nub based on that key.Cabal Like "Data.List.union", but has  O(n log n) complexity instead of O(n^2).CabalA right-biased version of .Example:ordNub [1,2,1] :: [Int][1,2]ordNubRight [1,2,1] :: [Int][2,1]CabalA right-biased version of .Example:listUnion [1,2,3,4,3] [2,1,1] [1,2,3,4,3]"listUnionRight [1,2,3,4,3] [2,1,1] [4,3,2,1,1]CabalA total variant of  .CabalLower case stringlowercase "Foobar""foobar"CabalAscii charactersCabalAscii letters.CabalAscii letters and digits.isAsciiAlphaNum 'a'TrueisAsciiAlphaNum 'ä'FalseCabalLike ü , but with H predicateMbreakMaybe (readMaybe :: String -> Maybe Int) ["foo", "bar", "1", "2", "quu"]$(["foo","bar"],Just (1,["2","quu"]))<breakMaybe (readMaybe :: String -> Maybe Int) ["foo", "bar"](["foo","bar"],Nothing)CabalLike ż but with H predicate0spanMaybe listToMaybe [[1,2],[3],[],[4,5],[6,7]]([1,3],[[],[4,5],[6,7]])>spanMaybe (readMaybe :: String -> Maybe Int) ["1", "2", "foo"]([1,2],["foo"])Cabal– with monadic action.<take 5 $ unfoldrM (\b r -> Just (r + b, b + 1)) (1 :: Int) 2 [3,4,5,6,7]Cabal and  are like ģķ and ģī’K but have platform independent heuristics. The System.FilePath exists in two versions, Windows and Posix. The two versions don't agree on what is a relative path and we don't know if we're given Windows or Posix paths. This results in false positives when running on Posix and inspecting Windows paths, like the hackage server does. System.FilePath.Posix.isAbsolute "C:\hello" == False System.FilePath.Windows.isAbsolute "/hello" == False This means that we would treat paths that start with "/" to be absolute. On Posix they are indeed absolute, while on Windows they are not.’ˆThe portable versions should be used when we might deal with paths that are from another OS than the host OS. For example, the Hackage Server deals with both Windows and Posix paths while performing the PackageDescription checks. In contrast, when we run 'cabal configure' we do expect the paths to be correct for our OS and we should not have to use the platform independent heuristics.Cabal  isRelativeOnAnyPlatform = not . $™£’     $     £™’)None=?@AX'ō CabalIThis is essentially a lazy bytestring, but chunks are glued with newline '\n'.$CabalConvert 7 to  .Note: inefficient! !"#$% !"$%#*None&'>SX8h+CabalParsing class which!can report Cabal parser warnings.knows  cabal-version we work with/CabalClass for parsing with parsec. Mainly used for .cabal file fields. For parsing .cabal like file structure, see Distribution.Fields.1Cabal0 could( consume trailing spaces, this function will consume.2CabalParse a 7 with 1.3CabalParse a 7 with 1.4CabalParse a 7 with given (". Trailing whitespace is accepted.5CabalRun ( with L.6CabalLike 5 but lets specify ; used.7Cabal [^ ,]8Cabal [^ ]:Cabal#Parse a benchmark/test-suite types.<CabalLike ;& but accept leading or trailing comma. p (comma p)* -- p sepByF comma (comma p)* -- leading comma (p comma)* -- trailing comma >CabalLike = butrequire all or none commas!accept leading or trailing comma. p (comma p)* -- p sepByi comma (comma p)* -- leading comma (p comma)* -- trailing comma p* -- no commas: many p ?CabalContent isn't unquoted@CabalparsecMaybeQuoted p = ? p  | p.<‰Š‹ŒŽ—˜™žŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶()*+,-./0123456789:;<=>?@A</0()*562134+,-. ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µžŸ¶—˜™‰Š‹ŒŽ789?@;<=>:A+None27NMCabalA M- represents the version of a software entity. Instances of ( and 0Ž are provided, which gives exact equality and lexicographic ordering of the version number components (i.e. 2.1 > 2.0, 1.2.3 > 1.2.2, etc.).*This type is opaque and distinct from the ÷ type in  Data.Version since  Cabal-2.0!. The difference extends to the H8 instance using a different (and more compact) encoding.NCabal#An integral without leading zeroes.OCabal Construct M( from list of version number components.For instance, mkVersion [3,2,1] constructs a M representing the version 3.2.1.-All version components must be non-negative.  mkVersion []# currently represents the special null version; see also S.PCabalVersion 0. A lower bound of M.QCabal Variant of O which converts a  Data.Version ÷ into Cabal's M type.RCabalUnpack M( into list of version number components.This is the inverse to O, so the following holds: %(versionNumbers . mkVersion) vs == vsSCabal"Constant representing the special null MThe S compares (via 0) as less than every proper M value.TCabal3Apply function to list of version number components 0alterVersion f == mkVersion . f . versionNumbers MNOPQRSTU MOQRSTPUN,None24567>Xmv`Cabal F-Algebra of l. See ….xCabalThe version range -any4. That is, a version range containing all versions. withinRange v anyVersion = TrueyCabalHThe empty version range, that is a version range containing no versions.WThis can be constructed using any unsatisfiable version range expression, for example  > 1 && < 1. withinRange v noVersion = FalsezCabalThe version range == v (withinRange v' (thisVersion v) = v' == v{CabalThe version range  v|| v +withinRange v' (notThisVersion v) = v' /= v|CabalThe version range > v (withinRange v' (laterVersion v) = v' > v}CabalThe version range >= v +withinRange v' (orLaterVersion v) = v' >= v~CabalThe version range < v *withinRange v' (earlierVersion v) = v' < vCabalThe version range <= v -withinRange v' (orEarlierVersion v) = v' <= v€CabalThe version range  vr1 || vr2 X withinRange v' (unionVersionRanges vr1 vr2) = withinRange v' vr1 || withinRange v' vr2CabalThe version range  vr1 && vr2 \ withinRange v' (intersectVersionRanges vr1 vr2) = withinRange v' vr1 && withinRange v' vr2‚CabalThe version range == v.*.For example, for version 1.2, the version range == 1.2.* is the same as >= 1.2 && < 1.3 ŠwithinRange v' (laterVersion v) = v' >= v && v' < upper v where upper (Version lower t) = Version (init lower ++ [last lower + 1]) tƒCabalThe version range ^>= v.For example, for version 1.2.3.4, the version range  ^>= 1.2.3.4 is the same as >= 1.2.3.4 && < 1.3. Note that ^>= 1 is equivalent to  >= 1 && < 1.1.„Cabal…CabalFold l.†Cabal‡CabalUnfold l.ˆCabalRefold l‰Caball, parser parametrised by version digit parserN is used for all l.% is used for backward-compat pkgconfig-depends versions, PkgConfigVersionRange.ŠCabal<Compute next greater major version to be used as upper bound Example: 0.4.1 produces the version 0.5. which then can be used to construct a range >= 0.4.1 && < 0.5+`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š+lmnopqrstuvwxyz{|~}€‚ƒ`abcdefghijk„†…‡ˆ‰Š-None|—œCabal-Fold over the basic syntactic structure of a l.bThis provides a syntactic view of the expression defining the version range. The syntactic sugar ">= v", "<= v" and "== v.*"2 is presented in terms of the other basic syntax.For a semantic view use asVersionIntervals.Cabal Normalise l.In particular collapse  (== v || > v) into >= v , and so on.žCabalRemove w constructors.ŸCabal.Does this version fall within the given range?(This is the evaluation function for the l type. Cabal¢Cabal+Does the version range have an upper bound?£Cabal4Does the version range have an explicit lower bound?jNote: this function only considers the user-specified lower bounds, but not the implicit >=0 lower bound.œCabal"-any" versionCabal "== v"Cabal "> v"Cabal "< v"Cabal"_ || _" unionCabal"_ && _" intersection(`abcdefghijklxyz{|}~€‚ƒ„…†‡ˆ‰ŠœžŸ ”¢£(lxyz{|~}€‚ƒŸœž¢£`abcdefghijk…‡ˆ„† Š”‰.None2 4­Cabal$A complementary representation of a lr. Instead of a boolean version predicate it uses an increasing sequence of non-overlapping, non-empty intervals.aThe key point is that this representation gives a canonical representation for the semantics of l’xs. This makes it easier to check things like whether a version range is empty, covers all versions, or requires a certain minimum or maximum version. It also makes it easy to check equality or containment. It also makes it easier to identify 'simple' version predicates for translation into foreign packaging systems that do not support complex version range expressions.®CabalView a l as a union of intervals.5This provides a canonical view of the semantics of a l\ as opposed to the syntax of the expression used to define it. For the syntactic view use œ.čEach interval is non-empty. The sequence is in increasing order and no intervals overlap or touch. Therefore only the first and last can be unbounded. The sequence can be empty if the range is empty (e.g. a range expression like  1&& 2).COther checks are trivial to implement using this view. For example: hisNoVersion vr | [] <- asVersionIntervals vr = True | otherwise = False ØisSpecificVersion vr | [(LowerBound v InclusiveBound ,UpperBound v' InclusiveBound)] <- asVersionIntervals vr , v == v' = Just v | otherwise = NothingÆCabal&Inspect the list of version intervals.°CabalDirectly construct a ­ from a list of intervals.In  Cabal-2.2 the H! is dropped from the result type.ųCabal6Check an upper bound does not intersect a lower bound:‚--| or ---) or ---] or ---) but not ---] |--- (--- (--- [--- [---±Cabal5Test if a version falls within the version intervals.VIt exists mostly for completeness and testing. It satisfies the following properties: }withinIntervals v (toVersionIntervals vr) = withinRange v vr withinIntervals v ivs = withinRange v (fromVersionIntervals ivs)²Cabal Convert a l$ to a sequence of version intervals.³Cabal Convert a ­ value back into a l0 expression representing the version intervals.¤„¦§©ØŖ«¬­®Æ°±²³“µ¶·ø­²³±Æ°“µ¶·ø®¬Ŗ«§©Ø¤„¦/None27ĢÖ ĆCabalIAn enumeration of common source control systems. The fields used in the Ńn depend on the type of repo. The tools and methods used to obtain and track the repo depend on the repo type.ĶCabal/What this repo info is for, what it represents.ĪCabalÄThe repository for the "head" or development version of the project. This repo is where we should track the latest development activity or the usual repo people should get to contribute patches.ĻCabal¹The repository containing the sources for this exact package version or release. For this kind of repo a tag should be given to give enough information to re-create the exact sources.ŃCabalCInformation about the source revision control system for a package.’When specifying a repo it is useful to know the meaning or intention of the information as doing so enables automation. There are two obvious common purposes: one is to find the repo for the latest development version, the other is to find the repo for this specific release. The ReopKind6 specifies which one we mean (or another custom one).²A package can specify one or the other kind or both. Most will specify just a head repo but some may want to specify a repo to reconstruct the sources for this package release. The required information is the Ć which tells us if it's using Ä, Å for example. The Õ? and other details are interpreted according to the repo type.ÓCabal)The kind of repo. This field is required.ŌCabal;The type of the source repository system for this repo, eg Ä or Å. This field is required.ÕCabal)The location of the repository. For most Ć)s this is a URL. This field is required.ÖCabalĒū can put multiple "modules" on one server and requires a module name in addition to the location to identify a particular repo. Logically this is part of the location but unfortunately has to be specified separately. This field is required for the Ē Ć$ and should not be given otherwise.×CabalØThe name or identifier of the branch, if any. Many source control systems have the notion of multiple branches in a repo that exist in the same location. For example Å and Ē use this while systems like Ä– use different locations for different branches. This field is optional but should be used if necessary to identify the sources, especially for the Ļ repo kind.ŲCabalUThe tag identify a particular state of the repository. This should be given for the Ļ repo kind and not for Ī kind.ŁCabal½Some repositories contain multiple projects in different subdirectories This field specifies the subdirectory where this packages sources can be found, eg the subdirectory containing the .cabalŽ file. It is interpreted relative to the root of the repository. This field is optional. If not given the default is "." ie no subdirectory.ĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŃŅÓŌÕÖ×ŲŁĶĪĻŠĆÄÅĘĒČÉŹĖĢŪŚŻÜ0NoneĶäŃśūüżž’Ńśūüżž’1None27Ń=Cabal pkg-config versions.In fact, this can be arbitrary Ļ, but / instance is a little pickier.CabalCompare two version strings as  pkg-config would compare them.2None27ŅÖCabalCabal<TODO: this is not precise, but used only to prettify output.3None27MŲ&%CabalA pkg-config library name?This is parsed as any valid argument to the pkg-config utility.&CabalConvert % to 7'Cabal Construct a % from a 7' is the inverse to &ANote: No validations are performed to ensure that the resulting % is valid,Cabal'%&'%&'4None27Ł{3Cabal.Describes a dependency on a pkg-config library34345None27MŽY>CabalA package name.Use @ and ? to convert from/to a 7.This type is opaque since  Cabal-2.0?CabalConvert > to 7@Cabal Construct a > from a 7@ is the inverse to ?ANote: No validations are performed to ensure that the resulting > is validECabal@>?@>?@6None27Mļ6LCabal9An unqualified component name, for any kind of component.This is distinguished from a  ComponentName and  ComponentId. The former also states which of a library, executable, etc the name refers too. The later uniquely identifiers a component and its closure.MCabalConvert L to 7NCabal Construct a L from a 7N is the inverse to MANote: No validations are performed to ensure that the resulting L is validOCabal8Converts a package name to an unqualified component namewUseful in legacy situations where a package name may refer to an internal component, if one is defined with that name.>2018-12-21: These "legacy" situations are not legacy. We can  build-depends; on the internal library. However Now dependency contains Set LibraryName, and we should use that.PCabal8Converts an unqualified component name to a package nameO is the inverse of P.wUseful in legacy situations where a package name may refer to an internal component, if one is defined with that name.UCabalNLMNOPLMNOP7None27ō^Cabal2A version constraint on a package. Different from  ExeDependency and  Dependency since it does not specify the need for a component, not even the main library. There are a few places in the codebase where  Dependency is used where ^ should be used instead (#5570).^_^_8None27öiCabalMulti-lib visibilityjCabal&Can be depenendent from other packageskCabalInternal library, defaultijkijk9None27ł–zCabal Pretty print w in build-target-ish syntax.Note: there are no  or // instances, as there's other way to represent w, namely as bare L. €Cabal Convert the L of a library into a w. wxyz{|}~€ wxy|€}~z{:None27&~‰CabaltA combination of a package and component name used in various legacy interfaces, chiefly bundled with a version as MungedPackageId". It's generally better to use a UnitId” to opaquely refer to some compilation/packing unit, but that doesn't always work, e.g. where a "name" is needed, in which case this can be used as a fallback.Use mkMungedPackageName and unMungedPackageName to convert from/to a 7.In 3.0.0.0L representation was changed from opaque (string) to semantic representation.‹CabalIntended for internal use only,decodeCompatPackageName "z-servant-z-lackey"VMungedPackageName (PackageName "servant") (LSubLibName (UnqualComponentName "lackey"))ŒCabalIntended for internal use onlyLencodeCompatPackageName $ MungedPackageName "servant" (LSubLibName "lackey") PackageName "z-servant-z-lackey"This is used in  cabal-installN in the Solver. May become obsolete as solver moves to per-component solving.Cabal1simpleParsec "servant" :: Maybe MungedPackageName=Just (MungedPackageName (PackageName "servant") LMainLibName)<simpleParsec "z-servant-z-lackey" :: Maybe MungedPackageName]Just (MungedPackageName (PackageName "servant") (LSubLibName (UnqualComponentName "lackey")))6simpleParsec "z-servant-zz" :: Maybe MungedPackageNameBJust (MungedPackageName (PackageName "z-servant-zz") LMainLibName)ŽCabalóComputes the package name for a library. If this is the public library, it will just be the original package name; otherwise, it will be a munged package name recording the original package name as well as the name of the internal library.€A lot of tooling in the Haskell ecosystem assumes that if something is installed to the package database with the package name fooJ, then it actually is an entry for the (only public) library in package foo’ß. With internal packages, this is not necessarily true: a public library as well as arbitrarily many internal libraries may come from the same package. To prevent tools from getting confused in this case, the package name of these internal libraries is munged so that they do not conflict the public library proper. A particular case where this matters is ghc-pkg: if we don't munge the package name, the inplace registration will OVERRIDE a different internal library.–We munge into a reserved namespace, "z-", and encode both the component name and the package name of an internal library using the following format:8compat-pkg-name ::= "z-" package-name "-z-" library-namedwhere package-name and library-name have "-" ( "z" + ) "-" segments encoded by adding an extra "z".cWhen we have the public library, the compat-pkg-name is just the package-name, no surprises there!5prettyShow $ MungedPackageName "servant" LMainLibName "servant"?prettyShow $ MungedPackageName "servant" (LSubLibName "lackey")"z-servant-z-lackey"‰Š‹Œ‰Š‹Œ;None27)÷—Cabal,What kind of foreign library is to be built?˜CabalA native shared library (.so on Linux, .dylib on OSX, or .dll on Windows).™Cabal2A native static library (not currently supported.)—˜™š›œ—˜™š›œ<None27-Ż©Cabal-Merge in all dependent libraries (i.e., use ghc -shared -static0 rather than just record the dependencies, ala ghc -shared -dynamicM). This option is compulsory on Windows and unsupported on other platforms.ةة=None27/4¶Cabal  = “·CabalAny like semigroup, where µ is 'Any True'³“µ³“µ>None272dÉCabal}This gets the underlying unqualified component name. In fact, it is guaranteed to uniquely identify a component, returning Nothing if the Į was for the public library. ĮĀĆÄÅĘĒČÉ ĮĀĆÄÅĘĒČÉ?None27M;GŅCabalA Ņf uniquely identifies the transitive source code closure of a component (i.e. libraries, executables).CFor non-Backpack components, this corresponds one to one with the UnitIdD, which serves as the basis for install paths, linker symbols, etc.Use Ó and Ō to convert from/to a 7.This type is opaque since  Cabal-2.0ÓCabal Construct a Ņ from a 7Ó is the inverse to ŌANote: No validations are performed to ensure that the resulting Ņ is validŌCabalConvert Ņ to 7ŁCabalÓŅÓŌŅŌÓ@None27>rąCabalA ąT represents a library depended on and explicitly specified by the user/client with  --dependencyIt enables Cabal to know which Ņ to associate with a libraryąįāćäąįāćäANone27DžźCabal.The type of build system used by this package.ėCabalcalls Distribution.Simple.defaultMainģCabalcalls 9Distribution.Simple.defaultMainWithHooks defaultUserHooks, which invokes  configure@ to generate additional build information used by later phases.ķCabalcalls Distribution.Make.defaultMainīCabaluses user-supplied Setup.hs or  Setup.lhs (default)źģķėīļźģķėīļBNone27MI©łCabal ABI HashesUse ū and ś to convert from/to a 7.This type is opaque since  Cabal-2.0śCabal Construct a ł from a 7ū is the inverse to śANote: No validations are performed to ensure that the resulting ł is validūCabalConvert ł to 7CabalūłśūłśūCNoneI÷DDuncan Coutts 2007-2008cabal-devel@haskell.orgportableNone27>er Cabal‘These are the known Arches: I386, X86_64, PPC, PPC64, Sparc, Arm, AArch64, Mips, SH, IA64, S39, Alpha, Hppa, Rs6000, M68k, Vax, and JavaScript.īThe following aliases can also be used: * PPC alias: powerpc * PPC64 alias : powerpc64, powerpc64le * Sparc aliases: sparc64, sun4 * Mips aliases: mipsel, mipseb * Arm aliases: armeb, armel * AArch64 aliases: arm64Cabal—These are the known OS names: Linux, Windows, OSX ,FreeBSD, OpenBSD, NetBSD, DragonFly ,Solaris, AIX, HPUX, IRIX ,HaLVM ,Hurd ,IOS, Android,GhcjsÅThe following aliases can also be used:, * Windows aliases: mingw32, win32, cygwin32 * OSX alias: darwin * Hurd alias: gnu * FreeBSD alias: kfreebsdgnu * Solaris alias: solaris2.Cabal3How strict to be when classifying strings into the  and   enums.vThe reason we have multiple ways to do the classification is because there are two situations where we need to do it.ĒFor parsing OS and arch names in .cabal files we really want everyone to be referring to the same or or arch by the same name. Variety is not a virtue in this case. We don't mind about case though.¾For the System.Info.os/arch different Haskell implementations use different names for the same or/arch. Also they tend to distinguish versions of an OS/arch which we just don't care about.The 0Ä classification allows us to recognise aliases that are already in common use but it allows us to distinguish them from the canonical name which enables us to warn about such deprecated aliases.8Cabal4The platform Cabal was compiled on. In most cases, LocalBuildInfo.hostPlatform8 should be used instead (the platform we're targeting).3      !"#$%&'()*+,-.1/0234567893 !"#$%&'()*+,-4     78925.1/036ENone27k¶XCabal,A user defined license reference denoted by LicenseRef-[idstring]. (for a license not on the SPDX License List)~YCabalLicense reference.ZCabalDocument reference.[CabalCreate X% from optional document ref and name.\CabalLike [% but convert invalid characters into -.XYZ[\XYZ[\FNone27¹ė’xgCabalSPDX License identifierhCabal0BSD, BSD Zero Clause LicenseiCabalAAL, Attribution Assurance LicensejCabalAbstyles, Abstyles LicensekCabal Adobe-2006:, Adobe Systems Incorporated Source Code License AgreementlCabal Adobe-Glyph, Adobe Glyph List LicensemCabalADSL!, Amazon Digital Services LicensenCabalAFL-1.1, Academic Free License v1.1oCabalAFL-1.2, Academic Free License v1.2pCabalAFL-2.0, Academic Free License v2.0qCabalAFL-2.1, Academic Free License v2.1rCabalAFL-3.0, Academic Free License v3.0sCabalAfmparse, Afmparse LicensetCabalAGPL-1.0;, Affero General Public License v1.0, SPDX License List 3.0uCabal AGPL-1.0-onlyW, Affero General Public License v1.0 only, SPDX License List 3.2, SPDX License List 3.6vCabalAGPL-1.0-or-later[, Affero General Public License v1.0 or later, SPDX License List 3.2, SPDX License List 3.6wCabal AGPL-3.0-only-, GNU Affero General Public License v3.0 onlyxCabalAGPL-3.0-or-later1, GNU Affero General Public License v3.0 or lateryCabalAladdin, Aladdin Free Public LicensezCabalAMDPLPA, AMD's plpa_map.c License{CabalAML, Apple MIT License|CabalAMPAS1, Academy of Motion Picture Arts and Sciences BSD}CabalANTLR-PD, ANTLR Software Rights Notice~Cabal Apache-1.0, Apache License 1.0Cabal Apache-1.1, Apache License 1.1€Cabal Apache-2.0, Apache License 2.0CabalAPAFML, Adobe Postscript AFM License‚CabalAPL-1.0, Adaptive Public License 1.0ƒCabalAPSL-1.0!, Apple Public Source License 1.0„CabalAPSL-1.1!, Apple Public Source License 1.1…CabalAPSL-1.2!, Apple Public Source License 1.2†CabalAPSL-2.0!, Apple Public Source License 2.0‡CabalArtistic-1.0-cl8!, Artistic License 1.0 w/clause 8ˆCabalArtistic-1.0-Perl, Artistic License 1.0 (Perl)‰Cabal Artistic-1.0, Artistic License 1.0ŠCabal Artistic-2.0, Artistic License 2.0‹CabalBahyph, Bahyph LicenseŒCabalBarr, Barr LicenseCabalBeerware, Beerware LicenseŽCabalBitTorrent-1.0%, BitTorrent Open Source License v1.0CabalBitTorrent-1.1%, BitTorrent Open Source License v1.1Cabalblessing(, SQLite Blessing, SPDX License List 3.6‘Cabal BlueOak-1.0.05, Blue Oak Model License 1.0.0, SPDX License List 3.6’CabalBorceux, Borceux license“Cabal BSD-1-Clause, BSD 1-Clause License”CabalBSD-2-Clause-FreeBSD, BSD 2-Clause FreeBSD License•CabalBSD-2-Clause-NetBSD, BSD 2-Clause NetBSD License–CabalBSD-2-Clause-Patent", BSD-2-Clause Plus Patent License—Cabal BSD-2-Clause, BSD 2-Clause  Simplified License˜CabalBSD-3-Clause-Attribution, BSD with attribution™CabalBSD-3-Clause-Clear, BSD 3-Clause Clear LicensešCabalBSD-3-Clause-LBNL5, Lawrence Berkeley National Labs BSD variant license›Cabal$BSD-3-Clause-No-Nuclear-License-2014&, BSD 3-Clause No Nuclear License 2014œCabalBSD-3-Clause-No-Nuclear-License!, BSD 3-Clause No Nuclear LicenseCabal BSD-3-Clause-No-Nuclear-Warranty", BSD 3-Clause No Nuclear WarrantyžCabalBSD-3-Clause-Open-MPI6, BSD 3-Clause Open MPI variant, SPDX License List 3.6ŸCabal BSD-3-Clause, BSD 3-Clause New or Revised License CabalBSD-4-Clause-UC2, BSD-4-Clause (University of California-Specific)”Cabal BSD-4-Clause, BSD 4-Clause Original or Old License¢CabalBSD-Protection, BSD Protection License£CabalBSD-Source-Code, BSD Source Code Attribution¤CabalBSL-1.0, Boost Software License 1.0„Cabal bzip2-1.0.5#, bzip2 and libbzip2 License v1.0.5¦Cabal bzip2-1.0.6#, bzip2 and libbzip2 License v1.0.6§CabalCaldera, Caldera LicenseØCabal CATOSL-1.15, Computer Associates Trusted Open Source License 1.1©Cabal CC-BY-1.0*, Creative Commons Attribution 1.0 GenericŖCabal CC-BY-2.0*, Creative Commons Attribution 2.0 Generic«Cabal CC-BY-2.5*, Creative Commons Attribution 2.5 Generic¬Cabal CC-BY-3.0+, Creative Commons Attribution 3.0 Unported­Cabal CC-BY-4.00, Creative Commons Attribution 4.0 International®Cabal CC-BY-NC-1.09, Creative Commons Attribution Non Commercial 1.0 GenericÆCabal CC-BY-NC-2.09, Creative Commons Attribution Non Commercial 2.0 Generic°Cabal CC-BY-NC-2.59, Creative Commons Attribution Non Commercial 2.5 Generic±Cabal CC-BY-NC-3.0:, Creative Commons Attribution Non Commercial 3.0 Unported²Cabal CC-BY-NC-4.0?, Creative Commons Attribution Non Commercial 4.0 International³CabalCC-BY-NC-ND-1.0H, Creative Commons Attribution Non Commercial No Derivatives 1.0 Generic“CabalCC-BY-NC-ND-2.0H, Creative Commons Attribution Non Commercial No Derivatives 2.0 GenericµCabalCC-BY-NC-ND-2.5H, Creative Commons Attribution Non Commercial No Derivatives 2.5 Generic¶CabalCC-BY-NC-ND-3.0I, Creative Commons Attribution Non Commercial No Derivatives 3.0 Unported·CabalCC-BY-NC-ND-4.0N, Creative Commons Attribution Non Commercial No Derivatives 4.0 InternationaløCabalCC-BY-NC-SA-1.0E, Creative Commons Attribution Non Commercial Share Alike 1.0 Generic¹CabalCC-BY-NC-SA-2.0E, Creative Commons Attribution Non Commercial Share Alike 2.0 GenericŗCabalCC-BY-NC-SA-2.5E, Creative Commons Attribution Non Commercial Share Alike 2.5 Generic»CabalCC-BY-NC-SA-3.0F, Creative Commons Attribution Non Commercial Share Alike 3.0 Unported¼CabalCC-BY-NC-SA-4.0K, Creative Commons Attribution Non Commercial Share Alike 4.0 International½Cabal CC-BY-ND-1.09, Creative Commons Attribution No Derivatives 1.0 Generic¾Cabal CC-BY-ND-2.09, Creative Commons Attribution No Derivatives 2.0 GenericæCabal CC-BY-ND-2.59, Creative Commons Attribution No Derivatives 2.5 GenericĄCabal CC-BY-ND-3.0:, Creative Commons Attribution No Derivatives 3.0 UnportedĮCabal CC-BY-ND-4.0?, Creative Commons Attribution No Derivatives 4.0 InternationalĀCabal CC-BY-SA-1.06, Creative Commons Attribution Share Alike 1.0 GenericĆCabal CC-BY-SA-2.06, Creative Commons Attribution Share Alike 2.0 GenericÄCabal CC-BY-SA-2.56, Creative Commons Attribution Share Alike 2.5 GenericÅCabal CC-BY-SA-3.07, Creative Commons Attribution Share Alike 3.0 UnportedĘCabal CC-BY-SA-4.0<, Creative Commons Attribution Share Alike 4.0 InternationalĒCabalCC-PDDCT, Creative Commons Public Domain Dedication and Certification, SPDX License List 3.6ČCabalCC0-1.0&, Creative Commons Zero v1.0 UniversalÉCabalCDDL-1.01, Common Development and Distribution License 1.0ŹCabalCDDL-1.11, Common Development and Distribution License 1.1ĖCabalCDLA-Permissive-1.01, Community Data License Agreement Permissive 1.0ĢCabalCDLA-Sharing-1.0., Community Data License Agreement Sharing 1.0ĶCabal CECILL-1.0-, CeCILL Free Software License Agreement v1.0ĪCabal CECILL-1.1-, CeCILL Free Software License Agreement v1.1ĻCabal CECILL-2.0-, CeCILL Free Software License Agreement v2.0ŠCabal CECILL-2.1-, CeCILL Free Software License Agreement v2.1ŃCabalCECILL-B*, CeCILL-B Free Software License AgreementŅCabalCECILL-C*, CeCILL-C Free Software License AgreementÓCabal CERN-OHL-1.18, CERN Open Hardware License v1.1, SPDX License List 3.6ŌCabal CERN-OHL-1.28, CERN Open Hardware Licence v1.2, SPDX License List 3.6ÕCabal ClArtistic, Clarified Artistic LicenseÖCabal CNRI-Jython, CNRI Jython License×CabalCNRI-Python-GPL-Compatible:, CNRI Python Open Source GPL Compatible License AgreementŲCabal CNRI-Python, CNRI Python LicenseŁCabal Condor-1.1, Condor Public License v1.1ŚCabalcopyleft-next-0.3.0,, copyleft-next 0.3.0, SPDX License List 3.6ŪCabalcopyleft-next-0.3.1,, copyleft-next 0.3.1, SPDX License List 3.6ÜCabalCPAL-1.0', Common Public Attribution License 1.0ŻCabalCPL-1.0, Common Public License 1.0ŽCabal CPOL-1.02 , Code Project Open License 1.02ßCabal Crossword, Crossword LicenseąCabalCrystalStacker, CrystalStacker LicenseįCabal CUA-OPL-1.0 , CUA Office Public License v1.0āCabalCube, Cube LicensećCabalcurl, curl LicenseäCabal D-FSL-1.0 , Deutsche Freie Software LizenzåCabaldiffmark, diffmark licenseęCabalDOC , DOC LicenseēCabalDotseqn, Dotseqn LicensečCabalDSDP, DSDP LicenseéCabaldvipdfm, dvipdfm LicenseźCabalECL-1.0$, Educational Community License v1.0ėCabalECL-2.0$, Educational Community License v2.0ģCabalEFL-1.0, Eiffel Forum License v1.0ķCabalEFL-2.0, Eiffel Forum License v2.0īCabaleGenix!, eGenix.com Public License 1.1.0ļCabalEntessa, Entessa Public License v1.0šCabalEPL-1.0, Eclipse Public License 1.0ńCabalEPL-2.0, Eclipse Public License 2.0ņCabal ErlPL-1.1, Erlang Public License v1.1óCabal EUDatagrid, EU DataGrid Software LicenseōCabalEUPL-1.0#, European Union Public License 1.0õCabalEUPL-1.1#, European Union Public License 1.1öCabalEUPL-1.2#, European Union Public License 1.2÷CabalEurosym, Eurosym LicenseųCabalFair, Fair LicensełCabal Frameworx-1.0, Frameworx Open License 1.0śCabal FreeImage, FreeImage Public License v1.0ūCabalFSFAP, FSF All Permissive LicenseüCabalFSFULLR0, FSF Unlimited License (with License Retention)żCabalFSFUL, FSF Unlimited LicensežCabalFTL, Freetype Project License’Cabal GFDL-1.1-only*, GNU Free Documentation License v1.1 onlyCabalGFDL-1.1-or-later., GNU Free Documentation License v1.1 or laterCabal GFDL-1.2-only*, GNU Free Documentation License v1.2 onlyCabalGFDL-1.2-or-later., GNU Free Documentation License v1.2 or laterCabal GFDL-1.3-only*, GNU Free Documentation License v1.3 onlyCabalGFDL-1.3-or-later., GNU Free Documentation License v1.3 or laterCabalGiftware, Giftware LicenseCabalGL2PS, GL2PS LicenseCabalGlide, 3dfx Glide LicenseCabalGlulxe, Glulxe License Cabalgnuplot, gnuplot License Cabal GPL-1.0-only&, GNU General Public License v1.0 only CabalGPL-1.0-or-later*, GNU General Public License v1.0 or later Cabal GPL-2.0-only&, GNU General Public License v2.0 only CabalGPL-2.0-or-later*, GNU General Public License v2.0 or laterCabal GPL-3.0-only&, GNU General Public License v3.0 onlyCabalGPL-3.0-or-later*, GNU General Public License v3.0 or laterCabal gSOAP-1.3b, gSOAP Public License v1.3bCabal HaskellReport!, Haskell Language Report LicenseCabalHPND-sell-variantS, Historical Permission Notice and Disclaimer - sell variant, SPDX License List 3.6CabalHPND-, Historical Permission Notice and DisclaimerCabalIBM-pibs., IBM PowerPC Initialization and Boot SoftwareCabalICU , ICU LicenseCabalIJG , Independent JPEG Group LicenseCabal ImageMagick, ImageMagick LicenseCabaliMatix,, iMatix Standard Function Library AgreementCabalImlib2, Imlib2 LicenseCabalInfo-ZIP, Info-ZIP LicenseCabal Intel-ACPI', Intel ACPI Software License AgreementCabalIntel, Intel Open Source LicenseCabal Interbase-1.0, Interbase Public License v1.0CabalIPA, IPA Font LicenseCabalIPL-1.0, IBM Public License v1.0 CabalISC , ISC License!Cabal JasPer-2.0, JasPer License"CabalJPNICA, Japan Network Information Center License, SPDX License List 3.6#CabalJSON, JSON License$CabalLAL-1.2, Licence Art Libre 1.2%CabalLAL-1.3, Licence Art Libre 1.3&CabalLatex2e, Latex2e License'Cabal Leptonica, Leptonica License(Cabal LGPL-2.0-only,, GNU Library General Public License v2 only)CabalLGPL-2.0-or-later0, GNU Library General Public License v2 or later*Cabal LGPL-2.1-only-, GNU Lesser General Public License v2.1 only+CabalLGPL-2.1-or-later1, GNU Lesser General Public License v2.1 or later,Cabal LGPL-3.0-only-, GNU Lesser General Public License v3.0 only-CabalLGPL-3.0-or-later1, GNU Lesser General Public License v3.0 or later.CabalLGPLLR8, Lesser General Public License For Linguistic Resources/Cabal libpng-2.08, PNG Reference Library version 2, SPDX License List 3.60CabalLibpng, libpng License1Caballibtiff, libtiff License2Cabal LiLiQ-P-1.12, Licence Libre du Québec  Permissive version 1.13Cabal LiLiQ-R-1.13, Licence Libre du Québec  Réciprocité version 1.14CabalLiLiQ-Rplus-1.19, Licence Libre du Québec  Réciprocité forte version 1.15Cabal Linux-OpenIBZ, Linux Kernel Variant of OpenIB.org license, SPDX License List 3.2, SPDX License List 3.66CabalLPL-1.02, Lucent Public License v1.027CabalLPL-1.0#, Lucent Public License Version 1.08CabalLPPL-1.0#, LaTeX Project Public License v1.09CabalLPPL-1.1#, LaTeX Project Public License v1.1:CabalLPPL-1.2#, LaTeX Project Public License v1.2;Cabal LPPL-1.3a$, LaTeX Project Public License v1.3a<Cabal LPPL-1.3c$, LaTeX Project Public License v1.3c=Cabal MakeIndex, MakeIndex License>CabalMirOS, MirOS License?CabalMIT-0B, MIT No Attribution, SPDX License List 3.2, SPDX License List 3.6@CabalMIT-advertising, Enlightenment License (e16)ACabalMIT-CMU , CMU LicenseBCabalMIT-enna, enna LicenseCCabalMIT-feh , feh LicenseDCabalMITNFA, MIT +no-false-attribs licenseECabalMIT , MIT LicenseFCabalMotosoto, Motosoto LicenseGCabalmpich2, mpich2 LicenseHCabalMPL-1.0, Mozilla Public License 1.0ICabalMPL-1.1, Mozilla Public License 1.1JCabalMPL-2.0-no-copyleft-exception4, Mozilla Public License 2.0 (no copyleft exception)KCabalMPL-2.0, Mozilla Public License 2.0LCabalMS-PL, Microsoft Public LicenseMCabalMS-RL, Microsoft Reciprocal LicenseNCabalMTLL!, Matrix Template Library LicenseOCabalMultics, Multics LicensePCabalMup , Mup LicenseQCabalNASA-1.3 , NASA Open Source Agreement 1.3RCabalNaumen, Naumen Public LicenseSCabalNBPL-1.0, Net Boolean Public License v1TCabalNCSA1, University of Illinois/NCSA Open Source LicenseUCabalNet-SNMP, Net-SNMP LicenseVCabalNetCDF, NetCDF licenseWCabalNewsletr, Newsletr LicenseXCabalNGPL , Nethack General Public LicenseYCabalNLOD-1.0,, Norwegian Licence for Open Government DataZCabalNLPL, No Limit Public License[CabalNokia, Nokia Open Source License\CabalNOSL, Netizen Open Source License]CabalNoweb, Noweb License^CabalNPL-1.0, Netscape Public License v1.0_CabalNPL-1.1, Netscape Public License v1.1`Cabal NPOSL-3.0&, Non-Profit Open Software License 3.0aCabalNRL , NRL LicensebCabalNTP , NTP LicensecCabalOCCT-PL(, Open CASCADE Technology Public LicensedCabalOCLC-2.0", OCLC Research Public License 2.0eCabalODbL-1.0 , ODC Open Database License v1.0fCabal ODC-By-1.0Z, Open Data Commons Attribution License v1.0, SPDX License List 3.2, SPDX License List 3.6gCabalOFL-1.0, SIL Open Font License 1.0hCabalOFL-1.1, SIL Open Font License 1.1iCabal OGL-UK-1.05, Open Government Licence v1.0, SPDX License List 3.6jCabal OGL-UK-2.05, Open Government Licence v2.0, SPDX License List 3.6kCabal OGL-UK-3.05, Open Government Licence v3.0, SPDX License List 3.6lCabalOGTSL, Open Group Test Suite LicensemCabal OLDAP-1.1, Open LDAP Public License v1.1nCabal OLDAP-1.2, Open LDAP Public License v1.2oCabal OLDAP-1.3, Open LDAP Public License v1.3pCabal OLDAP-1.4, Open LDAP Public License v1.4qCabal OLDAP-2.0.1!, Open LDAP Public License v2.0.1rCabal OLDAP-2.0;, Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B)sCabal OLDAP-2.1, Open LDAP Public License v2.1tCabal OLDAP-2.2.1!, Open LDAP Public License v2.2.1uCabal OLDAP-2.2.2 , Open LDAP Public License 2.2.2vCabal OLDAP-2.2, Open LDAP Public License v2.2wCabal OLDAP-2.3, Open LDAP Public License v2.3xCabal OLDAP-2.4, Open LDAP Public License v2.4yCabal OLDAP-2.5, Open LDAP Public License v2.5zCabal OLDAP-2.6, Open LDAP Public License v2.6{Cabal OLDAP-2.7, Open LDAP Public License v2.7|Cabal OLDAP-2.8, Open LDAP Public License v2.8}CabalOML, Open Market License~CabalOpenSSL, OpenSSL LicenseCabalOPL-1.0, Open Public License v1.0€Cabal OSET-PL-2.1!, OSET Public License version 2.1CabalOSL-1.0, Open Software License 1.0‚CabalOSL-1.1, Open Software License 1.1ƒCabalOSL-2.0, Open Software License 2.0„CabalOSL-2.1, Open Software License 2.1…CabalOSL-3.0, Open Software License 3.0†Cabal Parity-6.0.08, The Parity Public License 6.0.0, SPDX License List 3.6‡CabalPDDL-1.0,, ODC Public Domain Dedication & License 1.0ˆCabalPHP-3.01, PHP License v3.01‰CabalPHP-3.0, PHP License v3.0ŠCabalPlexus, Plexus Classworlds License‹Cabal PostgreSQL, PostgreSQL LicenseŒCabalpsfrag, psfrag LicenseCabalpsutils, psutils LicenseŽCabal Python-2.0, Python License 2.0CabalQhull, Qhull LicenseCabalQPL-1.0, Q Public License 1.0‘CabalRdisc, Rdisc License’Cabal RHeCos-1.1", Red Hat eCos Public License v1.1“CabalRPL-1.1, Reciprocal Public License 1.1”CabalRPL-1.5, Reciprocal Public License 1.5•CabalRPSL-1.0), RealNetworks Public Source License v1.0–CabalRSA-MD, RSA Message-Digest License —CabalRSCPL", Ricoh Source Code Public License˜CabalRuby, Ruby License™CabalSAX-PD, Sax Public Domain NoticešCabalSaxpath, Saxpath License›CabalSCEA, SCEA Shared Source LicenseœCabal Sendmail-8.23., Sendmail License 8.23, SPDX License List 3.6CabalSendmail, Sendmail LicensežCabal SGI-B-1.0", SGI Free Software License B v1.0ŸCabal SGI-B-1.1", SGI Free Software License B v1.1 Cabal SGI-B-2.0", SGI Free Software License B v2.0”CabalSHL-0.51A, Solderpad Hardware License, Version 0.51, SPDX License List 3.6¢CabalSHL-0.58, Solderpad Hardware License v0.5, SPDX License List 3.6£Cabal SimPL-2.0, Simple Public License 2.0¤Cabal SISSL-1.2,, Sun Industry Standards Source License v1.2„CabalSISSL,, Sun Industry Standards Source License v1.1¦Cabal Sleepycat, Sleepycat License§CabalSMLNJ#, Standard ML of New Jersey LicenseØCabalSMPPL*, Secure Messaging Protocol Public License©CabalSNIA, SNIA Public License 1.1ŖCabal Spencer-86, Spencer License 86«Cabal Spencer-94, Spencer License 94¬Cabal Spencer-99, Spencer License 99­CabalSPL-1.0, Sun Public License v1.0®CabalSSPL-1.08, Server Side Public License, v 1, SPDX License List 3.6ÆCabalSugarCRM-1.1.3 , SugarCRM Public License v1.1.3°CabalSWL8, Scheme Widget Library (SWL) Software License Agreement±Cabal TAPR-OHL-1.08, TAPR Open Hardware License v1.0, SPDX License List 3.6²CabalTCL, TCL/TK License³Cabal TCP-wrappers, TCP Wrappers License“CabalTMate, TMate Open Source LicenseµCabal TORQUE-1.1$, TORQUE v2.5+ Software License v1.1¶CabalTOSL, Trusster Open Source License·Cabal TU-Berlin-1.0Z, Technische Universitaet Berlin License 1.0, SPDX License List 3.2, SPDX License List 3.6øCabal TU-Berlin-2.0Z, Technische Universitaet Berlin License 2.0, SPDX License List 3.2, SPDX License List 3.6¹CabalUnicode-DFS-2015<, Unicode License Agreement - Data Files and Software (2015)ŗCabalUnicode-DFS-2016<, Unicode License Agreement - Data Files and Software (2016)»Cabal Unicode-TOU, Unicode Terms of Use¼Cabal Unlicense, The Unlicense½CabalUPL-1.0#, Universal Permissive License v1.0¾CabalVim , Vim LicenseæCabalVOSTROM(, VOSTROM Public License for Open SourceĄCabalVSL-1.0, Vovida Software License v1.0ĮCabal W3C-19980720., W3C Software Notice and License (1998-07-20)ĀCabal W3C-201505137, W3C Software Notice and Document License (2015-05-13)ĆCabalW3C., W3C Software Notice and License (2002-12-31)ÄCabal Watcom-1.0', Sybase Open Watcom Public License 1.0ÅCabalWsuipa, Wsuipa LicenseĘCabalWTFPL-, Do What The F*ck You Want To Public LicenseĒCabalX11 , X11 LicenseČCabalXerox, Xerox LicenseÉCabal XFree86-1.1, XFree86 License 1.1ŹCabalxinetd, xinetd LicenseĖCabalXnet, X.Net LicenseĢCabalxpp , XPP LicenseĶCabalXSkat, XSkat LicenseĪCabalYPL-1.0, Yahoo! Public License v1.0ĻCabalYPL-1.1, Yahoo! Public License v1.1ŠCabalZed , Zed LicenseŃCabalZend-2.0, Zend License v2.0ŅCabal Zimbra-1.3, Zimbra Public License v1.3ÓCabal Zimbra-1.4, Zimbra Public License v1.4ŌCabalzlib-acknowledgement*, zlib/libpng License with AcknowledgementÕCabalZlib, zlib LicenseÖCabalZPL-1.1, Zope Public License 1.1×CabalZPL-2.0, Zope Public License 2.0ŲCabalZPL-2.1, Zope Public License 2.1ŁCabal=Help message for migrating from non-SPDX license identifiers.Old License is almost SPDX, except for BSD2, BSD3'. This function suggests SPDX variant: licenseIdMigrationMessage "BSD3""Do you mean BSD-3-Clause?"Also  OtherLicense, AllRightsReserved, and  PublicDomain aren't valid SPDX identifiersetraverse_ (print . licenseIdMigrationMessage) [ "OtherLicense", "AllRightsReserved", "PublicDomain" ]”"SPDX license list contains plenty of licenses. See https://spdx.org/licenses/. Also they can be combined into complex expressions with AND and OR."/"You can use NONE as a value of license field."§"Public Domain is a complex matter. See https://wiki.spdx.org/view/Legal_Team/Decisions/Dealing_with_Public_Domain_within_SPDX_Files. Consider using a proper license."kSPDX License list version 3.0 introduced "-only" and "-or-later" variants for GNU family of licenses. See  ;https://spdx.org/news/news/2018/01/license-list-30-released¢ >>> licenseIdMigrationMessage "GPL-2.0" "SPDX license list 3.0 deprecated suffixless variants of GNU family of licenses. Use GPL-2.0-only or GPL-2.0-or-later."WFor other common licenses their old license format coincides with the SPDX identifiers:‹traverse eitherParsec ["GPL-2.0-only", "GPL-3.0-only", "LGPL-2.1-only", "MIT", "ISC", "MPL-2.0", "Apache-2.0"] :: Either String [LicenseId]JRight [GPL_2_0_only,GPL_3_0_only,LGPL_2_1_only,MIT,ISC,MPL_2_0,Apache_2_0]ŚCabalLicense SPDX identifier, e.g. "BSD-3-Clause".ŪCabalLicense name, e.g. &"GNU General Public License v2.0 only"ÜCabal@Whether the license is approved by Open Source Initiative (OSI).See  ,https://opensource.org/licenses/alphabetical.ŽCabal Create a g from a 7.ąCabal6eitherParsec "BSD-3-Clause" :: Either String LicenseIdRight BSD_3_Clause.eitherParsec "BSD3" :: Either String LicenseIdKLeft "...Unknown SPDX license identifier: 'BSD3' Do you mean BSD-3-Clause?"’xghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽ’xghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŚŪÜŽŻŁGNone27ķ>(ėCabalSPDX License identifierģCabal 389-exception , 389 Directory Server ExceptionķCabalAutoconf-exception-2.0, Autoconf exception 2.0īCabalAutoconf-exception-3.0, Autoconf exception 3.0ļCabalBison-exception-2.2, Bison exception 2.2šCabalBootloader-exception#, Bootloader Distribution ExceptionńCabalClasspath-exception-2.0, Classpath exception 2.0ņCabalCLISP-exception-2.0, CLISP exception 2.0óCabalDigiRule-FOSS-exception!, DigiRule FOSS License ExceptionōCabaleCos-exception-2.0, eCos exception 2.0õCabalFawkes-Runtime-exception, Fawkes Runtime ExceptionöCabalFLTK-exception, FLTK exception÷CabalFont-exception-2.0, Font exception 2.0ųCabalfreertos-exception-2.0, FreeRTOS Exception 2.0łCabalGCC-exception-2.0#, GCC Runtime Library exception 2.0śCabalGCC-exception-3.1#, GCC Runtime Library exception 3.1ūCabalgnu-javamail-exception, GNU JavaMail exceptionüCabal GPL-CC-1.07, GPL Cooperation Commitment 1.0, SPDX License List 3.6żCabali2p-gpl-java-exception, i2p GPL+Java ExceptionžCabalLibtool-exception, Libtool Exception’CabalLinux-syscall-note, Linux Syscall NoteCabalLLVM-exception>, LLVM Exception, SPDX License List 3.2, SPDX License List 3.6CabalLZMA-exception, LZMA exceptionCabal mif-exception', Macros and Inline Functions ExceptionCabalNokia-Qt-exception-1.1K, Nokia Qt LGPL exception 1.1, SPDX License List 3.0, SPDX License List 3.2CabalOCaml-LGPL-linking-exception5, OCaml LGPL Linking Exception, SPDX License List 3.6CabalOCCT-exception-1.0, Open CASCADE Exception 1.0CabalOpenJDK-assembly-exception-1.0N, OpenJDK Assembly exception 1.0, SPDX License List 3.2, SPDX License List 3.6Cabalopenvpn-openssl-exception, OpenVPN OpenSSL ExceptionCabal!PS-or-PDF-font-exception-20170817R, PS/PDF font exception (2017-08-17), SPDX License List 3.2, SPDX License List 3.6 CabalQt-GPL-exception-1.0D, Qt GPL exception 1.0, SPDX License List 3.2, SPDX License List 3.6 CabalQt-LGPL-exception-1.1E, Qt LGPL exception 1.1, SPDX License List 3.2, SPDX License List 3.6 CabalQwt-exception-1.0, Qwt exception 1.0 CabalSwift-exception(, Swift Exception, SPDX License List 3.6 Cabalu-boot-exception-2.0, U-Boot exception 2.0CabalUniversal-FOSS-exception-1.0>, Universal FOSS Exception, Version 1.0, SPDX License List 3.6CabalWxWindows-exception-3.1!, WxWindows Library Exception 3.1CabalLicense SPDX identifier, e.g. "BSD-3-Clause".CabalLicense name, e.g. &"GNU General Public License v2.0 only"Cabal Create a ė from a 7.)ėģķīļšńņóōõö÷ųłśūüżž’     )ėģķīļšńņóōõö÷ųłśūüżž’     HNone27Ų CabalSimple License Expressions.!Cabal9An SPDX License List Short Form Identifier. For example:  GPL-2.0-only"CabalŸAn SPDX License List Short Form Identifier with a unary"+" operator suffix to represent the current version of the license or any later version. For example: GPL-2.0+#Cabal4A SPDX user defined license reference: For example:  LicenseRef-23, LicenseRef-MIT-Style-1, or 0DocumentRef-spdx-tool-1.2:LicenseRef-MIT-Style-2$CabalSPDX License Expression. ’čidstring = 1*(ALPHA / DIGIT / "-" / "." ) license id = <short form license identifier inAppendix I.1> license exception id = <short form license exception identifier inAppendix I.2> license ref = ["DocumentRef-"1*(idstring)":"]"LicenseRef-"1*(idstring) simple expression = license id / license id"+" / license ref compound expression = 1*1(simple expression / simple expression "WITH" license exception id / compound expression "AND" compound expression / compound expression "OR" compound expression ) / "(" compound expression ")" ) license expression = 1*1(simple expression / compound expression)  !"#$%&'( $%&' !"#(INone27ö=CabalDeclared license. See <https://spdx.org/spdx-specification-21-web-version#h.1hmsyys&section 3.15 of SPDX Specification 2.1Note:! the NOASSERTION case is omitted.Old =' can be migrated using following rules:AllRightsReserved and UnspecifiedLicense to >4. No license specified which legally defaults to All Rights Reserved`. The package may not be legally modified or redistributed by anyone but the rightsholder. OtherLicense can be converted to  LicenseRef( pointing to the file in the package.UnknownLicense! i.e. other licenses of the form name-x.y;, should be covered by SPDX license list, otherwise use  LicenseRef. PublicDomain+ isn't covered. Consider using CC0. See  \https://wiki.spdx.org/view/Legal_Team/Decisions/Dealing_with_Public_Domain_within_SPDX_Files for more information.>Cabal=if the package contains no license information whatsoever; or?Cabal:A valid SPDX License Expression as defined in Appendix IV.@Cabal<eitherParsec "BSD-3-Clause AND MIT" :: Either String LicensegRight (License (EAnd (ELicense (ELicenseId BSD_3_Clause) Nothing) (ELicense (ELicenseId MIT) Nothing))),eitherParsec "NONE" :: Either String License Right NONE=?>=?>ļNoneD’¶ XYZ[\ghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŚŪÜŻŽėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'(=?>’¶=?>$%&' !"#(ghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŚŪÜŽŻėģķīļšńņóōõö÷ųłśūüżž’     XYZ[\ JJose Iborra 2008BSD3cabal-devel@haskell.orgportableNone$ØJCabal"Parser with simple error reportingJKLMNOPJKLMNOPKDuncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone271 łCabal"Strict/unpacked representation of  [ShortText]RCabalA valid Haskell module name.UCabal Construct a R= from valid module components, i.e. parts separated by dots.VCabalThe module name Main.WCabalDThe individual components of a hierarchical module name. For example 1components (fromString "A.B.C") = ["A", "B", "C"]XCabalSConvert a module name to a file path, but without any file extension. For example: )toFilePath (fromString "A.B.C") = "A/B/C"]Cabal Construct a R from a valid module name 7.¼This is just a convenience function intended for valid module strings. It is an error if it is used with a string that is not a valid module name. If you are parsing user input then use Cš instead.RSTUVWXRSUWXVTLNone27SXBklCabal›Renaming applied to the modules provided by a package. The boolean indicates whether or not to also include all of the original names of modules. Thus, ModuleRenaming False []$ is "don't expose any modules, and ModuleRenaming True [( Data.Bool, Bool)]+ is, "expose all modules, but also expose  Data.Bool as Bool)". If a renaming is omitted you get the n.=(NB: This is a list not a map so that we can preserve order.)mCabal"A module renaming/thinning; e.g., (A as B, C as C) brings B and C into scope.nCabal@The default renaming, bringing all exported modules into scope.oCabalHiding renaming, e.g.,  hiding (A, B)C, bringing all exported modules into scope except the hidden ones.pCabal Interpret a l as a partial map from R to R7. For efficiency, you should partially apply it with l and then reuse it.qCabal3The default renaming, if something is specified in  build-depends only.rCabalHTests if its the default renaming; we can use a more compact syntax in Mń in this case.śCabalbetween parensCabalmodule name parserlmnopqrlmnopqrMNone27E”}Cabal@A renaming on an include: (provides renaming, requires renaming)CabalThe  applied when you only  build-depends on a package.‚CabalIs an } the default one?}~€‚}~€‚NNone27F ŽŽONone27Fp›œžŸ›œžŸPNonect©Cabal© is parametrised bysZ which is a structure we are parsing. We need this to provide prettyprinter functionalitya type of the field.Note: We'd like to have forall s. Applicative (f s) context.ŖCabalUnfocus, zoom out, blur ©.«Cabal,Field which should be defined, exactly once.¬Cabal#Boolean field with a default value.­CabalOptional field.®Cabal"Optional field with default value.±CabalMonoidal field.Values are combined with !.Note: ­ is a  monoidalField with Last monoid.²Cabal>Parser matching all fields with a name starting with a prefix.³Cabal8Known field, which we don't parse, neither pretty print.“Cabal-Field which is parsed but not pretty printed.µCabalDeprecated since¶Cabal5Removed in. If we occur removed field, parsing fails.·Cabal'Annotate field with since spec-version.øCabal(Field which can be defined at most once.¹Cabal(Field which can be defined at most once.ŗCabal"Optional field with default value.»Cabal>Field which can be define multiple times, and the results are mappended.«Cabal field nameCabalX packCaballens into the field¬Cabal field nameCaballens into the fieldCabaldefault­Cabal field nameCabalpackCaballens into the field®Cabal field nameCabalX packCabalń s a: lens into the fieldCabal default valueÆCaballens into the field°Caballens into the field±Cabal field nameCabalpackCaballens into the field²Cabalfield name prefixCaballens into the fieldµCabalversionCabaldeprecation message¶CabalversionCabalremoval message·Cabal spec versionCabal default valueøCabal field nameCaballens into the field¹Cabal field nameCaballens into the fieldŗCabal field nameCabalń s a: lens into the fieldCabal default value»Cabal field nameCaballens into the field©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»ņSafe\p› ūCabal"The internal data structure for a ü^, which either records the representative element of an equivalence class, or a link to the ü. that actually stores the representative type.üCabal‚A variable which can be unified; alternately, this can be thought of as an equivalence class with a distinguished representative.żCabalMutable write to a üžCabalRead the current value of ü.’Cabal2Create a fresh equivalence class with one element.Cabal)Flatten any chains of links, returning a ü8 which points directly to the canonical representation.Cabal6Return the canonical element of an equivalence class ü.CabalgUnify two equivalence classes, so that they share a canonical element. Keeps the descriptor of point2.Cabal5Test if two points are in the same equivalence class.ü’QNone7pī ¼½¾æĄĮĀĆÄÅĘ ĀĆÄÅĘ¼½¾æĄĮRIan Lynagh 2007BSD3cabal-devel@haskell.orgportableNone7“[ŽCabalWCombinator for transforming verbosity level while retaining the original hidden state.*For instance, the following property holdsFisVerboseNoWrap (modifyVerbosity (max verbose) v) == isVerboseNoWrap vNote: you can use modifyVerbosity (const v1) v0 to overwrite v1's flags with v0 's flags.CabalParser verbosity-explicitEitherParsec parsecVerbosity "normal"QRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [], vQuiet = False}))6explicitEitherParsec parsecVerbosity "normal+nowrap "XRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap], vQuiet = False}))@explicitEitherParsec parsecVerbosity "normal+nowrap +markoutput"dRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False}))AexplicitEitherParsec parsecVerbosity "normal +nowrap +markoutput"dRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False}))?explicitEitherParsec parsecVerbosity "normal+nowrap+markoutput"dRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False}))Note:& this parser will eat trailing spaces.ćCabal/Turn on verbose call-site printing when we log.äCabal0Turn on verbose call-stack printing when we log.åCabalTurn on -----BEGIN CABAL OUTPUT-----I markers for output from Cabal (as opposed to GHC, or system dependent).ęCabalATurn off marking; useful for suppressing nondeterministic output.ēCabal'Disable line-wrapping for log messages.CabalMark the verbosity as quietčCabal$Turn on timestamps for log messages.éCabal%Turn off timestamps for log messages.Cabal+Helper function for flag enabling functionsCabal,Helper function for flag disabling functionsźCabalTurn off all flagsģCabal0Test if we should output call sites when we log.ķCabal1Test if we should output call stacks when we log.īCabal!Test if we should output markets.ļCabal3Test if line-wrapping is disabled for log messages.šCabalTest if we had called Ż on the verbosityńCabal3Test if if we should output timestamps when we log.Cabal+Helper function for flag testing functions.×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšń×ŲŁŚŪÜŻšßąįāźėŽćäģķåīęēļčńéSFIsaac Jones, Simon Marlow 2003-2004 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone°ėśCabal Does this l place any restriction on the M! or is it in fact equivalent to  AnyVersion.^Note this is a semantic check, not simply a syntactic check. So for example the following is True (for all v). EisAnyVersion (EarlierVersion v `UnionVersionRanges` orLaterVersion v)ūCabalThis is the converse of śl. It check if the version range is empty, if there is no possible version that satisfies the version range.For example this is True (for all v): FisNoVersion (EarlierVersion v `IntersectVersionRanges` LaterVersion v)üCabal6Is this version range in fact just a specific version?For example the version range ">= 3 && <= 3" contains only the version 3.żCabal Simplify a l§ expression. For non-empty version ranges this produces a canonical form. Empty or inconsistent version ranges are left as-is because that provides more information."If you need a canonical form use )fromVersionIntervals . toVersionIntervals&It satisfies the following properties: 8withinRange v (simplifyVersionRange r) = withinRange v r € withinRange v r = withinRange v r' ==> simplifyVersionRange r = simplifyVersionRange r' || isNoVersion r || isNoVersion r'žCabal$The difference of two version ranges c withinRange v' (differenceVersionRanges vr1 vr2) = withinRange v' vr1 && not (withinRange v' vr2)’CabalThe inverse of a version range B withinRange v' (invertVersionRange vr) = not (withinRange v' vr) Cabal@Given a version range, remove the highest upper bound. Example: (>= 1 && < 3) || (>= 4 && < 5) is converted to  (>= 1 &&  3)|| (= 4). Cabal@Given a version range, remove the lowest lower bound. Example:  (>= 1 &&  3)|| ( = 4 && < 5) is converted to  (>= 0 &&  3)|| ( = 4 && < 5).HMOPQRST`abcdefghijklxyz{|}~€‚ƒ„…†‡ˆŠœžŸ ¢£¤„¦§©ØŖ«¬­®Æ°±²³“µ¶śūüżž’ HMPOQRSTlxyz{|~}€ž’‚ƒŸśūüżœž¢£`abcdefghijk…‡ˆ„† Š ®¬Ŗ«§©Ø¤„¦­²³±Æ°“µ¶TNone27µł Cabal/The "test-type" field in the test suite stanza. Cabal"type: exitcode-stdio-x.y" Cabal"type: detailed-x.y" Cabal'Some unknown test type e.g. "type: foo"          UNone27Įė CabalpThe test suite interfaces that are currently defined. Each test suite must specify which interface it supports.ZMore interfaces may be defined in future, either new revisions or totally new interfaces. CabalžTest interface "exitcode-stdio-1.0". The test-suite takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin. Cabal‰Test interface "detailed-0.9". The test-suite takes the form of a library containing a designated module that exports "tests :: [Test]". CabalqA test suite that does not conform to one of the above interfaces for the given reason (e.g. unknown test type).        VNone27ĶŽ Cabal"The name and version of a package. Cabal!The name of this package, eg. foo Cabal#the version of this package, eg 1.2 !Cabal4Type alias so we can use the shorter name PackageId. #Cabal3simpleParsec "foo-bar-0" :: Maybe PackageIdentifierVJust (PackageIdentifier {pkgName = PackageName "foo-bar", pkgVersion = mkVersion [0]})1simpleParsec "foo-bar" :: Maybe PackageIdentifierUJust (PackageIdentifier {pkgName = PackageName "foo-bar", pkgVersion = mkVersion []})Note: Stricter than Text instance5simpleParsec "foo-bar-0-0" :: Maybe PackageIdentifierNothing3simpleParsec "foo-bar.0" :: Maybe PackageIdentifierNothing5simpleParsec "foo-bar.4-2" :: Maybe PackageIdentifierNothing/simpleParsec "1.2.3" :: Maybe PackageIdentifierNothing    !    !WNone27>MóĄ ,CabalA  . for a definite package. The  , invariant says that a  .B identified this way is definite; i.e., it has no unfilled holes. .CabalæA unit identifier identifies a (possibly instantiated) package/component that can be installed the installed package database. There are several types of components that can be installed:-A traditional library with no holes, so that  unitIdHash is Nothing. In the absence of Backpack,  . is the same as a Ņ.?An indefinite, Backpack library with holes. In this case,  unitIdHash is still NothingI, but in the install, there are only interfaces, no compiled objects.DAn instantiated Backpack library with all the holes filled in.  unitIdHash is a Just) a hash of the instantiating mapping.’A unit is a component plus the additional information on how the holes are filled in. Thus there is a one to many relationship: for a particular component there are many different ways of filling in the holes, and each different combination is a unit (and has a separate  .). . is distinct from  OpenUnitId+, in that it is always installed, whereas  OpenUnitIdø are intermediate unit identities that arise during mixin linking, and don't necessarily correspond to any actually installed unit. Since the mapping is not actually recorded in a  .H, you can't actually substitute over them (but you can substitute over  OpenUnitId). See also  Distribution.Backpack.FullUnitId0 for a mechanism for expanding an instantiated  . to retrieve its mapping.lBackwards compatibility note: if you need to get the string representation of a UnitId to pass, e.g., as a  -package-id flag, use the display5 function, which will work on all versions of Cabal. /Cabal4If you need backwards compatibility, consider using display7 instead, which is supported by all versions of Cabal. 1Cabal@Create a unit identity with no associated hash directly from a Ņ. 2CabalYMake an old-style UnitId from a package identifier. Assumed to be for the public library 3Cabal=Returns library name prefixed with HS, suitable for filenames 4CabalUnsafely create a  , from a  ... Your responsibility is to ensure that the  , invariant holds. 5Cabal 0 6CabalThe textual format for  ., coincides with the format GHC accepts for  -package-id. 7CabalThe textual format for  ., coincides with the format GHC accepts for  -package-id. , - . / 0 1 2 3 4 . / 0 , 4 - 1 2 3XNone27Mśż JCabalHA module identity uniquely identifies a Haskell module by qualifying a R with the  .’4 which defined it. This type distinguishes between two packages which provide a module with the same name, or a module from the same package compiled with different dependencies. There are a few cases where Cabal needs to know about module identities, e.g., when writing out reexported modules in the InstalledPackageInfo. J K J KYNone27=?MSX0ą VCabal$An explicit substitution on modules.cNB: These substitutions are NOT idempotent, for example, a valid substitution is (A -> B, B -> A). WCabal Unlike a  J, an  W5 is either an ordinary module from some unit, OR an  Y], representing a hole that needs to be filled in. Substitutions are over module variables. ZCabalAn  Z€ describes a (possibly partially) instantiated Backpack component, with a description of how the holes are filled in. Unlike  Z, the  ModuleSubst is kept in a structured form that allows for substitution (which fills in holes.) This form of unit cannot be installed. It must first be converted to a  ..°In the absence of Backpack, there are no holes to fill, so any such component always has an empty module substitution; thus we can lossly represent it as an 'OpenUnitId uid'.¶For a source component using Backpack, however, there is more structure as components may be parametrized over some signatures, and these "holes" may be partially or wholly filled.ŁOpenUnitId plays an important role when we are mix-in linking, and is recorded to the installed packaged database for indefinite packages; however, for compiled packages that are fully instantiated, we instantiate  Z into  ..(For more details see the Backpack spec Qhttps://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rst [CabalKIdentifies a component which may have some unfilled holes; specifying its Ņ and its  V. TODO: Invariant that  V+ is non-empty? See also the Text instance. \CabalmIdentifies a fully instantiated component, which has been compiled and abbreviated as a hash. The embedded  .. MUST NOT be for an indefinite component; an  Z& is guaranteed not to have any holes. ]CabalGet the set of holes ( ModuleVar) embedded in a  .. ^CabaleSafe constructor from a UnitId. The only way to do this safely is if the instantiation is provided. _Cabal Create a  , from a Ņ% and an instantiation with no holes. `CabalGet the set of holes ( ModuleVar) embedded in a  J. aCabalRPretty-print the entries of a module substitution, suitable for embedding into a  Z or passing to GHC via --instantiate-with. bCabal5Pretty-print a single entry of a module substitution. cCabal Inverse to  dispModSubst. dCabal Inverse to dispModSubstEntry. eCabalGet the set of holes ( ModuleVar) embedded in a  V.. This is NOT the domain of the substitution. fCabal@When typechecking, we don't demand that a freshly instantiated  [Y be compiled; instead, we just depend on the installed indefinite unit installed at the Ņ. gCabalCTake a module substitution and hash it into a string suitable for  .. Note that since this takes  J, not  W2, you are responsible for recursively converting  W into  J . See also $Distribution.Backpack.ReadyComponent. hCabalYeitherParsec "Includes2-0.1.0.0-inplace-mysql:Database.MySQL" :: Either String OpenModuleŠRight (OpenModule (DefiniteUnitId (DefUnitId {unDefUnitId = UnitId "Includes2-0.1.0.0-inplace-mysql"})) (ModuleName ["Database","MySQL"])) lCabal1eitherParsec "foobar" :: Either String OpenUnitIdBRight (DefiniteUnitId (DefUnitId {unDefUnitId = UnitId "foobar"}))MeitherParsec "foo[Str=text-1.2.3:Data.Text.Text]" :: Either String OpenUnitId½Right (IndefFullUnitId (ComponentId "foo") (fromList [(ModuleName ["Str"],OpenModule (DefiniteUnitId (DefUnitId {unDefUnitId = UnitId "text-1.2.3"})) (ModuleName ["Data","Text","Text"]))])) , - V W X Y Z [ \ ] ^ _ ` a b c d e f g Z [ \ ] ^ , - _ W X Y ` V a b c d e f gZNone71¾ | }  ~ | }  ~[None=?3  ˆCabal2Applying module substitutions to semantic objects. ˆ ‰ ˆ ‰óNone456=Œ CabalAn  W4, annotated with where it came from in a Cabal file. CabalHDescription of where a module participating in mixin linking came from. CabalHINVARIANT: entries for ModuleName m, have msrc_module is OpenModuleVar m CabalEvery Module in scope at a R is annotated with the > it comes from. CabalA  l describes the modules and requirements that are in-scope as we are processing a Cabal package. Unlike a  ModuleShape6, there may be multiple modules in scope at the same RV; this is only an error if we attempt to use those modules to fill a requirement. A   can influence the  ModuleShape via a reexport.Cabal An empty  .     \None7>  ‘ ’ “ ” ‘ ’  “ ”]None@œ —CabalUsed as a placeholder in $Distribution.Backpack.ReadyComponent ˜CabalUsed by cabal new-repl and  cabal new-run ™Cabal ˜ with P. — ˜ ™ — ˜ ™^None@ź  š ›  š ›_None27T0 œCabalA simple pair of a ‰ and M. ‰ is to  œ as  PackageName is to  !. See ‰ for more info. žCabal@The combined package and component name. see documentation for ‰. ŸCabal/The version of this package / component, eg 1.2 ¢Cabal1simpleParsec "foo-bar-0" :: Maybe MungedPackageId{Just (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") LMainLibName, mungedVersion = mkVersion [0]})/simpleParsec "foo-bar" :: Maybe MungedPackageIdzJust (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") LMainLibName, mungedVersion = mkVersion []})9simpleParsec "z-foo-bar-z-baz-0" :: Maybe MungedPackageId˜Just (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") (LSubLibName (UnqualComponentName "baz")), mungedVersion = mkVersion [0]})3simpleParsec "foo-bar-0-0" :: Maybe MungedPackageIdNothing1simpleParsec "foo-bar.0" :: Maybe MungedPackageIdNothing3simpleParsec "foo-bar.4-2" :: Maybe MungedPackageIdNothing £Cabal[prettyShow $ MungedPackageId (MungedPackageName "servant" LMainLibName) (mkVersion [1,2,3])"servant-1.2.3"eprettyShow $ MungedPackageId (MungedPackageName "servant" (LSubLibName "lackey")) (mkVersion [0,1,2])"z-servant-z-lackey-0.1.2" œ  ž Ÿ   œ  ž Ÿ  `None27YC «CabalDescribes a legacy  `build-tools`"-style dependency on an executableÕIt is "legacy" because we do not know what the build-tool referred to. It could refer to a pkg-config executable (PkgconfigName), or an internal executable (UnqualComponentName). Thus the name is stringly typed. « ¬ « ¬aNone27Z ¶Cabal6Describes a dependency on an executable from a package ¶ · ø ¶ · øbNone27^ī ĀCabal0Describes a dependency on a source package (API) ĆCabalThe set of libraries required from the package. Only the selected libraries will be built. It does not affect the cabal-install solver yet. ÉCabal Simplify the l expression in a  Ā. See ż. Ā Ć Ä Å Ę Ē Č É Ā Ć Ä Å Ę Ē Č ÉcNone27bŲ ÖCabalIs this a default 'custom-setup'° section added by the cabal-install code (as opposed to user-provided)? This field is only used internally, and doesn't correspond to anything in the .cabal file. See #3199. Ó Ō Õ Ö Ó Ō Õ ÖdNonec. Ó ą į Ó ą įeNonef( āCabaltA map of dependencies. Newtyped since the default monoid instance is not appropriate. The monoid instance uses . åCabal Input mapCabalExtra constraints ā ć ä å ā ć ä åfNone27hĢ źCabal3The "benchmark-type" field in the benchmark stanza. ėCabal"type: exitcode-stdio-x.y" ģCabal,Some unknown benchmark type e.g. "type: foo" ź ė ģ ķ ź ė ģ ķgNone27r” ÷CabalnThe benchmark interfaces that are currently defined. Each benchmark must specify which interface it supports.ZMore interfaces may be defined in future, either new revisions or totally new interfaces. ųCabal’Benchmark interface "exitcode-stdio-1.0". The benchmark takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin. łCabaluA benchmark that does not conform to one of the above interfaces for the given reason (e.g. unknown benchmark type). ÷ ų ł ÷ ų łhIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone27Mū CabalClass of installed packages.?The primary data type which is an instance of this package is InstalledPackageInfo², but when we are doing install plans in Cabal install we may have other, installed package-like things which contain more metadata. Installed packages have exact dependencies  . Cabal'Packages that have an installed unit ID CabalClass of things that have a  ŲTypes in this class are all notions of a package. This allows us to have different types for the different phases that packages go though, from simple name/id, package description, configured or installed packages.;Not all kinds of packages can be uniquely identified by a  n. In particular, installed packages cannot, there may be many installed instances of the same source package.0%&'>?@ŅÓŌłśū    ! , - . / 0 1 2 3 4 J K Ā Ć Ä Å Ę Ē Č É              iNone„Ŗ CabalAn   is a Ņ,  .i, etc. which is annotated with some other useful information that is useful for printing to users, etc._Invariant: if ann_id x == ann_id y, then ann_pid x == ann_pid y and ann_cname x == ann_cname y          jNone‡W CabalDid this come from an entry in mixins", or was implicitly generated by  build-depends? "CabalThis should always return Ā or  CSubLibName      ! "      ! "kNone7. #CabalQAn ABI dependency is a dependency on a library which also records the ABI hash (abiHash ) of the library it depends on.’SThe primary utility of this is to enable an extra sanity when GHC loads libraries: it can check if the dependency has a matching ABI and if not, refuse to load this library. This information is critical if we are shadowing libraries; differences in the ABI hash let us know what packages get shadowed by the new version of a package. # $ & % # $ & %lThe License data type.8Isaac Jones 2003-2005 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone27¼+ /Cabal˜Indicates the license under which a package's source code is released. Versions of the licenses not listed here will be rejected by Hackage and cause  cabal check to issue a warning. 0CabalGNU General Public License,  6https://www.gnu.org/licenses/old-licenses/gpl-2.0.html version 2 or  %https://www.gnu.org/licenses/gpl.html version 3. 1Cabal &https://www.gnu.org/licenses/agpl.html,GNU Affero General Public License, version 3. 2Cabal$GNU Lesser General Public License,  7https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html version 2.1 or  &https://www.gnu.org/licenses/lgpl.html version 3. 3Cabal .http://www.opensource.org/licenses/bsd-license2-clause BSD license. 4Cabal /http://www.opensource.org/licenses/bsd-3-clause3-clause BSD license. 5Cabal 1http://directory.fsf.org/wiki/License:BSD_4Clause4-clause BSD license”. This license has not been approved by the OSI and is incompatible with the GNU GPL. It is provided for historical reasons and should be avoided. 6Cabal &http://www.opensource.org/licenses/MIT MIT license. 7Cabal Ahttp://www.isc.org/downloads/software-support-policy/isc-license/ ISC license 8Cabal https://www.mozilla.org/MPL/#Mozilla Public License, version 2.0. 9Cabal https://www.apache.org/licenses/Apache License, version 2.0. :Cabal’ZThe author of a package disclaims any copyright to its source code and dedicates it to the public domain. This is not a software license. Please note that it is not possible to dedicate works to the public domain in every jurisdiction, nor is a work that is in the public domain in one jurisdiction necessarily in the public domain elsewhere. ;Cabal™Explicitly 'All Rights Reserved', eg for proprietary software. The package may not be legally modified or redistributed by anyone but the rightsholder. <Cabal No license specified which legally defaults to 'All Rights Reserved'. The package may not be legally modified or redistributed by anyone but the rightsholder. =CabalAny other software license. >Cabal$Indicates an erroneous license name. ?Cabal.The list of all currently recognised licenses. @Cabal Convert old  / to SPDX =&. Non-SPDX licenses are converted to X. ACabalConvert = to  /,*This is lossy conversion. We try our best.&licenseFromSPDX . licenseToSPDX $ BSD3BSD3<licenseFromSPDX . licenseToSPDX $ GPL (Just (mkVersion [3]))GPL (Just (mkVersion [3])).licenseFromSPDX . licenseToSPDX $ PublicDomain'UnknownLicense "LicenseRefPublicDomain"KlicenseFromSPDX $ SPDX.License $ SPDX.simpleLicenseExpression SPDX.EUPL_1_1UnknownLicense "EUPL-1.1"3licenseFromSPDX . licenseToSPDX $ AllRightsReservedAllRightsReserved?licenseFromSPDX <$> simpleParsec "BSD-3-Clause OR GPL-3.0-only"-Just (UnknownLicense "BSD3ClauseORGPL30only") / 7 6 4 3 ; = : 0 1 2 5 8 9 < > ? @ A / 7 6 4 3 ; = : 0 1 2 5 8 9 < > ? @ AmNone27HVæ2 fCabal overrides  e xCabal5Returns the munged package name, which we write into name- for compatibility with old versions of GHC.7 | } ~  # $ % & K L Q T v k ^ M N O P R S U V W X Y Z [ \ ] _ ` a b c d e f g h i j l m n o p q r s t u w x y7 K L Q T v k ^ M N O P R S U V W X Y Z [ \ ] _ ` a b c d e f g h i j l m n o p q r s t u y w x # $ % & | } ~ nNoneĮ + K … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ®+ K … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ®oIsaac Jones 2003-2004BSD3libraries@haskell.orgportableNone27 =PŠ °CabalcAllow overlapping class instances, provided there is a unique most specific instance for each use. jhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XOverlappingInstances ±CabalĘIgnore structural rules guaranteeing the termination of class instance resolution. Termination is guaranteed by a fixed-depth recursion stack, and compilation may fail if this depth is exceeded. jhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XUndecidableInstances ²CabalImplies  °©. Allow the implementation to choose an instance even when it is possible that further instantiation of types will lead to a more specific instance being applicable. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XIncoherentInstances ³Cabal (deprecated) Deprecated in favour of  “.-Old description: Allow recursive bindings in do blocks, using the rec keyword. See also  “. “CabalAllow recursive bindings in do blocks, using the rec keyword, or mdo, a variant of do. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRecursiveDo µCabaldProvide syntax for writing list comprehensions which iterate over several lists together, like the ÷ family of functions. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XParallelListComp ¶Cabal*Allow multiple parameters in a type class. khttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMultiParamTypeClasses ·Cabal,Enable the dreaded monomorphism restriction. ohttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNoMonomorphismRestriction øCabal’$Allow a specification attached to a multi-parameter type class which indicates that some parameters are entirely determined by others. The implementation will check that this property holds for the declared instances, and will use this property to reduce ambiguity in instance resolution. lhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XFunctionalDependencies ¹Cabal (deprecated) A synonym for  ŗ.Old description: Like  ŗZ but does not allow a higher-rank type to itself appear on the left of a function arrow. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRank2Types ŗCabalNAllow a universally-quantified type to occur on the left of a function arrow. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRankNTypes »Cabal (deprecated) A synonym for  ŗ.QOld description: Allow data constructors to have polymorphic arguments. Unlike  ŗ., does not allow this for ordinary functions. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#arbitrary-rank-polymorphism ¼Cabal1Allow existentially-quantified data constructors. ohttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XExistentialQuantification ½Cabal=Cause a type variable in a signature, which has an explicit forallQ quantifier, to scope over the definition of the accompanying value declaration. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XScopedTypeVariables ¾CabalDeprecated, use  ½ instead. æCabal7Enable implicit function parameters with dynamic scope. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XImplicitParams ĄCabalHRelax some restrictions on the form of the context of a type signature. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XFlexibleContexts ĮCabalORelax some restrictions on the form of the context of an instance declaration. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XFlexibleInstances ĀCabal2Allow data type declarations with no constructors. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XEmptyDataDecls ĆCabal.Run the C preprocessor on Haskell source code. Zhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#language-pragma ÄCabal]Allow an explicit kind signature giving the kind of types over which a type variable ranges. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XKindSignatures ÅCabalbEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XBangPatterns ĘCabal&Allow type synonyms in instance heads. jhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTypeSynonymInstances ĒCabalDEnable Template Haskell, a system for compile-time metaprogramming. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTemplateHaskell ČCabalœEnable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions. Zhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#language-pragma ÉCabalEnable arrow notation. \https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XArrows ŹCabal (deprecated)l Enable generic type classes, with default instances defined in terms of the algebraic structure of a type. Vhttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#generic-classes ĖCabal,Enable the implicit importing of the module Prelude€. When disabled, when desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the Prelude -- version. xhttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#rebindable-syntax-and-the-implicit-prelude-import ĢCabalƒEnable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike  Ü. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNamedFieldPuns ĶCabalDEnable a form of guard which matches a pattern and binds variables. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPatternGuards ĪCabalAllow a type declared with newtype to use deriving9 for any class with an instance for the underlying type. phttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XGeneralizedNewtypeDeriving ŠCabal,Enable the "Trex" extensible records system. =http://haskell.org/hugs/pages/users_guide/hugs-only.html#TREX ŃCabalƒEnable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes. Bhttp://haskell.org/hugs/pages/users_guide/restricted-synonyms.html ŅCabalHEnable an alternate syntax for string literals, with string templating. =http://haskell.org/hugs/pages/users_guide/here-documents.html ÓCabalAllow the character #W as a postfix modifier on identifiers. Also enables literal syntax for unboxed values. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMagicHash ŌCabalcAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTypeFamilies ÕCabal=Allow a standalone declaration which invokes the type class deriving mechanism. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XStandaloneDeriving ÖCabalpAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XUnicodeSyntax ×Cabal:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export. [https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#language-options ŲCabalEnable interruptible FFI. ^https://haskell.org/ghc/docs/latest/html/users_guide/ffi-chap.html#interruptible-foreign-calls ŁCabal*Allow use of CAPI FFI calling convention (foreign import capi). ^https://haskell.org/ghc/docs/latest/html/users_guide/ffi-chap.html#the-capi-calling-convention ŚCabal|Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XLiberalTypeSynonyms ŪCabal`Allow the name of a type constructor, type class, or type variable to be an infix operator. * chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTypeOperators ÜCabal‘Enable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike  Ģ. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRecordWildCards ŻCabalDeprecated, use  Ģ instead. ŽCabalQAllow a record field name to be disambiguated by the type of the record it's in. nhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDisambiguateRecordFields ßCabal=Enable traditional record syntax (as supported by Haskell 98) `https://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#traditional-record-syntax ąCabalVEnable overloading of string literals using a type class, much like integer literals. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XOverloadedStrings įCabal{Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies  ā. mhttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#generalised-algebraic-data-types-gadts āCabal>Enable GADT syntax for declaring ordinary algebraic datatypes. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XGADTSyntax ćCabal (deprecated) Has no effect.3Old description: Make pattern bindings monomorphic. Phttps://downloads.haskell.org/~ghc/7.6.3/docs/html/users_guide/monomorphism.html äCabalDRelax the requirements on mutually-recursive polymorphic functions. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRelaxedPolyRec åCabalEAllow default instantiation of polymorphic types in more situations. `http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html#type-defaulting-in-ghci ęCabalEnable unboxed tuples. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XUnboxedTuples ēCabalEnable deriving for classes ōõ and ö÷. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveDataTypeable čCabalEnable deriving for ųł and ųś. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveGeneric éCabal&Enable support for default signatures. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDefaultSignatures źCabal?Allow type signatures to be specified in instance declarations. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XInstanceSigs ėCabalVAllow a class method's type to place additional constraints on a class type variable. mhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XConstrainedClassMethods ģCabalcAllow imports to be qualified by the package name the module is intended to be imported from, e.g. import "network" Network.Socket dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPackageImports ķCabal (deprecated)A Allow a type variable to be instantiated at a polymorphic type. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XImpredicativeTypes īCabal (deprecated)1 Change the syntax for qualified infix operators. ahttp://www.haskell.org/ghc/docs/6.12.3/html/users_guide/syntax-extns.html#new-qualified-operators ļCabalURelax the interpretation of left operator sections to allow unary postfix operators. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPostfixOperators šCabalcEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XQuasiQuotes ńCabal\Enable generalized list comprehensions, supporting operations such as sorting and grouping. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTransformListComp ņCabalcEnable monad comprehensions, which generalise the list comprehension syntax to work for any monad. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMonadComprehensions óCabal]Enable view patterns, which match a value by applying a function and matching on the result. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XViewPatterns ōCabalxAllow concrete XML syntax to be used in expressions and patterns, as per the Haskell Server Pages extension language:  &http://www.haskell.org/haskellwiki/HSP. The ideas behind it are discussed in the paper "Haskell Server Pages through Dynamic Loading" by Niklas Broberg, from Haskell Workshop '05. õCabal¬Allow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04. öCabal'Enable the use of tuple sections, e.g. (, True) desugars into x -> (x, True). chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTupleSections ÷CabalGAllow GHC primops, written in C--, to be imported into a Haskell file. ųCabal!Support for patterns of the form n + k, where k is an integer literal. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNPlusKPatterns łCabalImprove the layout rule when if expressions are used in a do block. śCabalEnable support for multi-way if -expressions. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMultiWayIf ūCabalEnable support lambda-case expressions. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XLambdaCase üCabalqMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRebindableSyntax żCabalMake forallN a keyword in types, which can be used to give the generalisation explicitly. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XExplicitForAll žCabal0Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a). fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDatatypeContexts ’CabalLocal (let and where) bindings are monomorphic. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMonoLocalBinds CabalEnable deriving for the ūü class. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveFunctor CabalEnable deriving for the żž class. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveTraversable CabalEnable deriving for the ’ class. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveFoldable Cabal&Enable non-decreasing indentation for do blocks. Rhttps://haskell.org/ghc/docs/latest/html/users_guide/bugs.html#context-free-syntax Cabal–Allow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust. import safe Network.Socket Shttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#safe-imports CabaltCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety. Zhttps://www.haskell.org/ghc/docs/latest/html/users_guide/safe_haskell.html#ghc-flag--XSafe Cabal®Compile a module in the Trustworthy, Safe Haskell mode -- no restrictions apply but the module is marked as trusted as long as the package the module resides in is trusted. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/safe_haskell.html#ghc-flag--XTrustworthy CabalzCompile a module in the Unsafe, Safe Haskell mode so that modules compiled using Safe, Safe Haskell mode can't import it. \https://www.haskell.org/ghc/docs/latest/html/users_guide/safe_haskell.html#ghc-flag--XUnsafe CabalAllow type classimplicit parameterbequality constraints to be used as types with the special kind constraint. Also generalise the  (ctxt => ty)H syntax so that any type of kind constraint can occur before the arrow. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XConstraintKinds CabalEnable kind polymorphism. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPolyKinds CabalEnable datatype promotion. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDataKinds CabalEnable parallel arrays syntax ([:, :]) for Data Parallel Haskell. <http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell Cabal+Enable explicit role annotations, like in (/type role Foo representational representational). ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRoleAnnotations CabalWEnable overloading of list literals, arithmetic sequences and list patterns using the IsList type class. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XOverloadedLists CabaloEnable case expressions that have no alternatives. Also applies to lambda-case expressions if they are enabled. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XEmptyCase Cabal (deprecated) Deprecated in favour of  ē.4Old description: Triggers the generation of derived 6: instances for every datatype and type class declaration. Vhttps://haskell.org/ghc/docs/7.8.4/html/users_guide/deriving.html#auto-derive-typeable Cabal;Desugars negative literals directly (without using negate). fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNegativeLiterals Cabal5Allow the use of binary integer literal syntax (e.g.  0b11001001 to denote 201). dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XBinaryLiterals Cabal>Allow the use of floating literal syntax for all instances of / , including B and G. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNumDecimals Cabal7Enable support for type classes with no type parameter. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNullaryTypeClasses Cabal9Enable explicit namespaces in module import/export lists. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XExplicitNamespaces CabalUAllow the user to write ambiguous types, and the type inference engine to infer them. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XAllowAmbiguousTypes CabalEnable foreign import javascript. Cabal4Allow giving names to and abstracting over patterns. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPatternSynonyms Cabal«Allow anonymous placeholders (underscore) inside type signatures. The type inference engine will generate a message describing the type inferred at the hole's location. khttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPartialTypeSignatures Cabal‰Allow named placeholders written with a leading underscore inside type signatures. Wildcards with the same name unify to the same type. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNamedWildCards CabalEnable deriving for any class. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveAnyClass CabalEnable deriving for the  class. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveLift Cabal.Enable support for 'static pointers' (and the staticN keyword) to refer to globally stable names, even across different programs. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XStaticPointers CabalVSwitches data type declarations to be strict by default (as if they had a bang using  BangPatterns*), and allow opt-in field laziness using ~. ghttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#ghc-flag--XStrictData CabalTSwitches all pattern bindings to be strict by default (as if they had a bang using  BangPatterns*), ordinary patterns are recovered using ~ . Implies  StrictData. chttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#ghc-flag--XStrict CabalAllows do-notation for types that are 8 as well as ,. When enabled, desugaring do notation tries to use ( *) and  and join as far as possible. Cabal;Allow records to use duplicated field labels for accessors. !Cabal2Enable explicit type applications with the syntax id @Int. "Cabal¦Dissolve the distinction between types and kinds, allowing the compiler to reason about kind equality and therefore enabling GADTs to be promoted to the type-level. #CabalGAllow recursive (and therefore undecideable) super-class relationships. $CabalxA temporary extension to help library authors check if their code will compile with the new planned desugaring of fail. %Cabal A subset of TemplateHaskell including only quoting. &CabalAllows use of the #label syntax. 'CabalWAllow functional dependency annotations on type families to declare them as injective. (CabalAllow multiple deriving, clauses, each optionally qualified with a strategy. )CabalQEnable deriving instances via types of the same runtime representation. Implies  (. *Cabal%Enable the use of unboxed sum syntax. +CabalDAllow use of hexadecimal literal notation for floating-point values. ,CabalAllow do" blocks etc. in argument position. -Cabal-Allow use of underscores in numeric literals. .CabalAllow forall in constraints. /CabalHave * refer to Type. 0Cabal?Liberalises deriving to provide instances for empty data types. yhttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#deriving-instances-for-empty-data-types 1Cabal2This represents language extensions beyond a base  5 definition (such as  6L) that are supported by some implementations, usually in some special mode.VWhere applicable, references are given to an implementation's official documentation. 2CabalEnable a known extension 3CabalDisable a known extension 4Cabal4An unknown extension, identified by the name of its LANGUAGE pragma. 5Cabal+This represents a Haskell language dialect. Language  1;s are interpreted relative to one of these base languages. 6Cabal>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/ 7CabalBThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010 8Cabal,An unknown language, identified by its name. ;Cabal_Extensions that have been deprecated, possibly paired with another extension that replaces it.Cabalread for  Æ·s is really really slow so for the Text instance what we do is make a simple table indexed off the first letter in the extension name. The extension names actually cover the range 'A'-'Z'q pretty densely and the biggest bucket is 7 so it's not too bad. We just do a linear search within each bucket.ŽThis gives an order of magnitude improvement in parsing speed, and it'll also allow us to do case insensitive matches in future if we prefer.Ž Æ  ē č Į Ī Ķ ŗ ą Ü ½ Ō  Ą ¹ Ć ± Å é ø Ū Ź æ ¶ ū ¼ ś ö     į Ę Ó ° ² ³ “ µ · » ¾ Ā Ä Ē Č É Ė Ģ Ļ Š Ń Ņ Õ Ö × Ų Ł Ś Ż Ž ß ā ć ä å ę ź ė ģ ķ ī ļ š ń ņ ó ō õ ÷ ų ł ü ż ž ’                     ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <Ž 5 6 7 8 9 : 1 2 3 4 Æ  ē č Į Ī Ķ ŗ ą Ü ½ Ō  Ą ¹ Ć ± Å é ø Ū Ź æ ¶ ū ¼ ś ö     į Ę Ó ° ² ³ “ µ · » ¾ Ā Ä Ē Č É Ė Ģ Ļ Š Ń Ņ Õ Ö × Ų Ł Ś Ż Ž ß ā ć ä å ę ź ė ģ ķ ī ļ š ń ņ ó ō õ ÷ ų ł ü ż ž ’                     ! " # $ % & ' ( ) * + , - . / 0 ; <pIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone27 Qł ^CabalŒCompiler information used for resolving configurations. Some fields can be set to Nothing to indicate that the information is unknown. `CabalCompiler flavour and version. aCabalGTag for distinguishing incompatible ABI's on the same architecture/os. bCabalQOther implementations that this compiler claims to be compatible with, if known. cCabal'Supported language standards, if known. dCabalSupported extensions, if known. gCabal g$ carries only info per GHC and GHCJSCabal parses only  ghc-options and  ghcjs-options, others are omitted. {CabalvThe default compiler flavour to pick when compiling stuff. This defaults to the compiler used to build the Cabal lib.4However if it's not a recognised compiler then it's S= and the user will have to specify which compiler they want. ~Cabal”Make a CompilerInfo of which only the known information is its CompilerId, its AbiTag and that it does not claim to be compatible with other compiler id's.$ [ ] \ ^ _ ` a b c d e f g h i j k s u l m n o p q r t v w x y z { | } ~$ i j k s u l m n o p q r t v z y { x w g h | e f ^ _ ` a b c d ~ [ ] \ }qNone27 †b' ØCabalcomponent is buildable here ©CabalTools needed to build this bit.This is a legacy field that  Ŗ largely supersedes.CUnless use are very sure what you are doing, use the functions in $Distribution.Simple.BuildToolDepends, rather than accessing this field directly. ŖCabal&Haskell tools needed to build this bitThis field is better than  ©H because it allows one to precisely specify an executable in a package.CUnless use are very sure what you are doing, use the functions in $Distribution.Simple.BuildToolDepends, rather than accessing this field directly. «Cabal'options for pre-processing Haskell code ¬Cabaloptions for assmebler ­Cabaloptions for C-- compiler ®Cabaloptions for C compiler ÆCabaloptions for C++ compiler °Cabaloptions for linker ±Cabal!pkg-config packages that are used ²Cabalsupport frameworks for Mac OS X ³Cabal#extra locations to find frameworks. “CabalAssembly files. µCabal C-- files. ¹Cabal.where to look for the Haskell module hierarchy ŗCabalnon-exposed or non-main modules »Cabal5exposed modules that do not have a source file (e.g. GHC.Prim from ghc-prim package) ¼CabalFnot present on sdist, Paths_* or user-generated with a custom Setup.hs ½Cabal+language used when not explicitly specified ¾Cabal'other languages used within the package æCabal'language extensions used by all modules ĄCabal1other language extensions used within the package ĮCabal*the old extensions field, treated same as  æ ĀCabalKwhat libraries to link with when compiling a program that uses your package ĆCabalAif present, overrides extraLibs when package is loaded with GHCi. ÄCabal’śif present, adds libs to hs-libraries, which become part of the package. Example: the Cffi library shipping with the rts, alognside the HSrts-1.0.a,.o,... Example 2: a library that is being built by a foreing tool (e.g. rust) and copied and registered together with this library. The logic on how this library is built will have to be encoded in a custom Setup for now. Oherwise cabal would need to lear how to call arbitary library builders. ÅCabalaHidden Flag. This set of strings, will be appended to all libraries when copying. E.g. [libHS name_ flavour` | flavour <- extraLibFlavours]. This should only be needed in very specific cases, e.g. the rtsP package, where there are multiple copies of slightly differently built libs. ĘCabal<Hidden Flag. This set of strings will be be appended to all dynamicA libraries when copying. This is particularly useful with the rtsY package, where we want different dynamic flavours of the RTS library to be installed. ČCabaldirectories to find .h files ÉCabal'The .h files to be found in includeDirs ŹCabal&The .h files to be generated (e.g. by autoconf) ĖCabal$.h files to install with the package ŠCabal@Custom fields starting with x-, stored in a simple assoc-list. ŃCabal7Dependencies specific to a library or executable target ŌCabalThe  5s used by this component ÕCabalThe  1+s that are used somewhere by this component ÖCabalThe  Extensions/ that are used by all modules in this component ×CabalKWhether any modules in this component use Template Haskell or Quasi Quotes ŲCabal1Select options for a particular Haskell compiler.6 ¦ § Č Ģ É ® Æ ° ² Ø © Ŗ « ¬ ­ ± ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Ź Ė Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū6 ¦ § Č Ģ É ® Æ ° ² Ø © Ŗ « ¬ ­ ± ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Ź Ė Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś ŪrNone27 Æs åCabal å2 is mechanism that hooks can use to override the  ¦īs inside packages. One example use-case (which is used in core libraries today) is as a way of passing flags which are computed by a configure script into Cabal. In this case, the autoconf build type adds hooks to read in a textual  å' format prior to doing any operations.TQuite honestly, this mechanism is a massive hack since we shouldn't be editing the PackageDescription’ data structure (it's easy to assume that this data structure shouldn't change and run into bugs, see for example 1c20a6328579af9e37677d507e2e9836ef70ab9d). But it's a bit convenient, because there isn't another data structure that allows adding extra  ¦ style things.=In any case, a lot of care has to be taken to make sure the  å is applied to the PackageDescription&. In general this process occurs in Distribution.SimpleV, which is responsible for orchestrating the hooks mechanism. The general strategy: &We run the pre-hook, which produces a  åD (e.g., in the Autoconf case, it reads it out from a file).4We sanity-check the hooked build info with sanityCheckHookedBuildInfo.We update our PackageDescription. (either freshly read or cached from LocalBuildInfo) with updatePackageDescription.FIn principle, we are also supposed to update the copy of the PackageDescription stored in LocalBuildInfo at  localPkgDescrm. Unfortunately, in practice, there are lots of Custom setup scripts which fail to update  localPkgDescrž so you really shouldn't rely on it. It's not DEPRECATED because there are legitimate uses for it, but... yeah. Sharp knife. See  ,https://github.com/haskell/cabal/issues/3606, for more information on the issue.*It is not well-specified whether or not a  å1 applied at configure time is persistent to the LocalBuildInfo. The fact that  å is passed to confHook MIGHT SUGGEST that the  åā is applied at this time, but actually since 9317b67e6122ab14e53f81b573bd0ecb388eca5a it has been ONLY used to create a modified package description that we check for problems: it is never actually saved to the LBI. Since  å¦ is applied monoidally to the existing build infos (and it is not an idempotent monoid), it could break things to save it, since we are obligated to apply any new  åy and then we'd get the effect twice. But this does mean we have to re-apply it every time. Hey, it's more flexibility. å ę å ęsNone °, éCabalClassy lenses for  ¦.0 ¦ ē č é  ń ņ ó õ ė ģ ķ ī ļ š ō ö ÷ ų ł ś ū ü ż ž ’                ź0 ¦ é  ń ņ ó õ ė ģ ķ ī ļ š ō ö ÷ ų ł ś ū ü ż ž ’                ź ē čtNone27 “į Cabal&A "test-suite" stanza in a cabal file. Cabal+Get all the module names from a test suite. CabalQGet all the auto generated module names from a test suite. This are a subset of  .                  uNone µ_  * + ,  * + ,vNone27 Åī 2CabalWhat sigs need implementations? 3Cabal]Is the lib to be exposed by default? (i.e. whether its modules available in GHCi for example) 4Cabal4Whether this multilib can be dependent from outside. 7Cabal’NGet all the module names from the library (exposed and internal modules) which are explicitly listed in the package description which would need to be compiled. (This does not include reexports, which do not need to be compiled.) This may not include all modules for which GHC generated interface files (i.e., implicit modules.) 8Cabal`Get all the auto generated module names from the library, exposed or not. This are a subset of  libModules.CabalCombine w1. in parsing we prefer value coming from munged name field over the lib-name.Should be irrelevant. :CabalThis instance is not good.We need it for B. More correct method would be some kind of "create empty clone".More concretely, addBuildableCondition_ will make `libVisibility = False` libraries when `buildable: false`. This may cause problems. - . / 5 4 0 1 2 3 6 7 8 - . / 5 4 0 1 2 3 6 7 8wNone ʄ - C D E F G H I - C D E F G H IxNone27 ąĪ KCabalƒA foreign library stanza is like a library stanza, except that the built code is intended for consumption by a non-Haskell client. MCabalName of the foreign library NCabal9What kind of foreign library is this (static or dynamic). OCabal_What options apply to this foreign library (e.g., are we merging in all foreign dependencies.) PCabal+Build information for this foreign library. QCabalLibtool-style version-info data to compute library version. Refer to the libtool documentation on the current:revision:age versioning scheme. RCabalLinux library version SCabal*(Windows-specific) module definition files{This is a list rather than a maybe field so that we can flatten the condition trees (for instance, when creating an sdist) TCabal Construct  J from (current, revision, age) numbers.For instance, mkLibVersionInfo (3,0,0) constructs a  J representing the version-info 3:0:0.,All version components must be non-negative. UCabal From a given  J, extract the (current, revision, age) numbers. VCabal&Given a version-info field, produce a major.minor.build version WCabal#Given a version-info field, return "major.minor.build" as a 7 XCabal Return the major! version of a version-info field. YCabalAn empty foreign library. ZCabal%Modules defined by a foreign library. [CabalIs the foreign library shared? \Cabal’1Get a version number for a foreign library. If we're on Linux, and a Linux version is specified, use that. If we're on Linux, and libtool-style version-info is specified, translate that field into appropriate version numbers. Otherwise, this feature is unsupported so we don't return any version data. J K L M P N O Q R S T U V W X Y Z [ \ K L M P N O Q R S Y Z [ \ J T U V W XyNone įœ K q r s t u v w K q r s t u v wzNone27 ä# Cabal$Get all the module names from an exe €CabalJGet all the auto generated module names from an exe This are a subset of  . x y z } { | ~  € x y z } { | ~  €{None ä” x ‹ Œ  Ž x ‹ Œ  Ž|None27 ēņ Cabal%A "benchmark" stanza in a cabal file. –Cabal*Get all the module names from a benchmark. —CabalPGet all the auto generated module names from a benchmark. This are a subset of  –.   ‘ “ ’ ” • – —   ‘ “ ’ ” • – —}None7 ėX ŖCabal0Is a component buildable (i.e., not marked with buildable: False)? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. ¢ £ ¤ „ ¦ § Ø © Ŗ « ¬ ¢ £ ¤ „ ¦ § Ø © Ŗ « ¬~None7 ÷ķ ²Cabal0A reason explaining why a component is disabled. ·CabalSDescribes what components are enabled by user-interaction. See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. ¼CabalfThe default set of enabled components. Historically tests and benchmarks are NOT enabled by default. ½Cabal3Is this component enabled? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. ¾Cabal8Is this component name enabled? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. æCabal+Is this component disabled, and if so, why?Cabal0Is this component name disabled, and if so, why? ² ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ · ø ¹ ŗ » ² ³ “ µ ¶ ¼ ¾ ½ æIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone27>SX 7ź ÅCabal:This data type is the internal representation of the file  pkg.cabal’. It contains two kinds of information about the package: information which is needed for all packages, such as the package name and version, and information which is needed for the simple build system only, such as the compiler options and library name. ĒCabalžThe version of the Cabal spec that this package description uses. For historical reasons this is specified with a version range but only ranges of the form >= vq make sense. We are in the process of transitioning to specifying just a single version, not a range. See also  å. ŌCabal"A one-line summary of this package ÕCabal*A more verbose description of this package ×Cabal@Custom fields starting with x-, stored in a simple assoc-list. ŲCabal The original  build-type value as parsed from the .cabal# file without defaulting. See also  é. åCabalOThe version of the Cabal spec that this package should be interpreted against.ĪHistorically we used a version range but we are switching to using a single version. Currently we accept either. This function converts into a single version by ignoring upper bounds in the version range. ęCabal ēCabal The SPDX LicenseExpression of the package. čCabalSee  ē. éCabalThe effective  build-type! after applying defaulting rules. The original  build-type value parsed is stored in the  Ų field. However, the  build-typeU field is optional and can therefore be empty in which case we need to compute the  effective  build-type;. This function implements the following defaulting rules:For cabal-version:2.0 and below, default to the Custom build-type unconditionally.Otherwise, if a  custom-setup' stanza is defined, default to the Custom build-type; else default to Simple build-type. ėCabal2Does this package have a buildable PUBLIC library? ģCabal%Does this package have any libraries? īCabal‘If the package description has a buildable library section, call the given function with the library build info as argument. You probably want  withLibLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. ļCabal'does this package have any executables? šCabal%Perform the action on each buildable  x1 in the package description. You probably want  withExeLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. ńCabal'Does this package have any test suites? ņCabal$Perform an action on each buildable  " in a package. You probably want  withTestLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. óCabal&Does this package have any benchmarks? ōCabal$Perform an action on each buildable  " in a package. You probably want  withBenchLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. õCabal-Does this package have any foreign libraries? öCabal%Perform the action on each buildable  K in the package description. ÷CabalAll  ¦ in the  Å6: libraries, executables, test-suites and benchmarks.'Useful for implementing package checks. ųCabalReturn all of the  ¦Os of enabled components, i.e., all of the ones that would be built if you run  ./Setup build. łCabal9Get the combined build-depends entries of all components. śCabal^Get the combined build-depends entries of all enabled components, per the given request spec. üCabal"All the components in the package. żCabalXA list of all components in the package that are buildable, i.e., were not marked with buildable: FalseQ. This does NOT indicate if we are actually going to build the component, see  ž instead. žCabal9A list of all components in the package that are enabled.< Å Ę Č Ś Ė Ģ Ķ Ī Š Ń Ō Õ Ö į Ē É Ź Ļ Ņ Ó × Ų Ł Ū Ü Ż Ž ß ą ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’ < Å Ę Č Ś Ė Ģ Ķ Ī Š Ń Ō Õ Ö į Ē É Ź Ļ Ņ Ó × Ų Ł Ū Ü Ż Ž ß ą ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’ €None27>M \ CabalA ConfVar# represents the variable type used. CabalA  " is a total or partial mapping of  s to >j flag values. It represents the flags chosen by the user or discovered during configuration. For example --flags=foo --flags=-bar becomes [("foo", True), ("bar", False)] CabalA  1 is the name of a user-defined configuration flagUse  # and  $ to convert from/to a 7.This type is opaque since  Cabal-2.0 CabalŽA flag can represent a feature to be included, or a way of linking a target against its dependencies, or in fact whatever you can think of. "CabalA  % initialized with default parameters. #Cabal Construct a   from a 7 # is the inverse to  $ANote: No validations are performed to ensure that the resulting   is valid $CabalConvert   to 7Cabal*Combines pairs of values contained in the   Map.cThe last flag specified takes precedence, and we record the number of times we have seen the flag. %Cabal Construct a  ! from a list of flag/value pairs.`If duplicate flags occur in the input list, the later entries in the list will take precedence. &CabalDeconstruct a  ! into a list of flag/value pairs.  ‡ ( + fa) ==> ( % .  & ) fa == fa 'Cabal Test whether   is empty. (CabalLookup the value for a flagReturns S$ if the flag isn't contained in the  . )Cabal-Insert or update the boolean value of a flag.&If the flag is already present in the  FlagAssigmentŸ, the value will be updated and the fact that multiple values have been provided for that flag will be recorded so that a warning can be generated later on. *Cabal+Remove all flag-assignments from the first  # that are contained in the second  ėNB/TODO: This currently only removes flag assignments which also match the value assignment! We should review the code which uses this operation to figure out if this it's not enough to only compare the flagnames without the values. +Cabal Find the  's that have been listed more than once. ,Cabal+String representation of a flag-value pair. -Cabal Pretty-prints a flag assignment. .CabalParses a flag assignment. 2Cabal # 5Cabal 6Cabal%                   ! " # $ % & ' ( ) * + , - .%          !       "  # $  % & ( ) * + ' , - . NoneSX ]Š     W X Y Z [ \ ] ^ _ ` a b c d e f g     W X Y Z [ \ ] ^ _ ` a b c d e f g‚None ^ˆ  h i j  h i jƒNoneSX _ ‰Cabal ŠCabal ‹Cabal" Å k l m n o p q r s t u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹" Å k l m n o p q r s t u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹None `ӖŃśūüżž’  š › Ó ą į ¦ ē č é  ń ņ ó õ ė ģ ķ ī ļ š ō ö ÷ ų ł ś ū ü ż ž ’                ź  * + , - C D E F G H I K q r s t u v w x ‹ Œ  Ž  Å     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 { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone dE’ ˜™š›œžŸ ¶·ø¹ŗĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪwxy|ĮĀĆÄÅĘźģķėīļlmnoq›œžŸ          Ó Ō Õ Ö ź ė ģ ķ ÷ ų ł ¦ § Č Ģ É ® Æ ° ² Ø © Ŗ « ¬ ­ ± ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Ź Ė Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū å ę          - . / 5 4 0 1 2 3 6 7 8 x y z } { | ~  €   ‘ “ ’ ” • – — Å Ę Č Ś Ė Ģ Ķ Ī Š Ń Ō Õ Ö į Ē É Ź Ļ Ņ Ó × Ų Ł Ū Ü Ż Ž ß ą ā ć ä å ē é ź ė ģ ķ ī ļ š ń ņ ó ō ÷ ł ś ū                   " # $ % & ' ( ) * + , - .’ Å Ę Č Ś Ė Ģ Ķ Ī Š Ń Ō Õ Ö į Ē É Ź Ļ Ņ Ó × Ų Ł Ū Ü Ż Ž ß ą ā ć ä ź å é ēźģķėīļ ķlmnoq - . / 5 4 0 1 2 3›œžŸ 6 ī ė ģ 7 8 x y z } { | ~ š ļ  €                 ń ņ     ‘ “ ’ ÷ ų ł ź ė ģ • ķ ” ó ō – — ¦ § Č Ģ É ® Æ ° ² Ø © Ŗ « ¬ ­ ± ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Ź Ė Ķ Ī Ļ Š Ń Ņ Ó ÷ Ō Õ Ö × Ų Ł Ś Ū ł śĮĀĆÄÅĘwxy| å ę ū                "  # $  % & ' , * ( ) - . +¶·ø¹ŗ ˜™š›œžŸ ŃŅÓŌÕÖ×ŲŁĶĪĻŠĆÄÅĘĒČÉŹĖĢŪŚ Ó Ō Õ Ö„None ‹i ŒCabalODesugar a "build-tools" entry into proper a executable dependency if possible.*An entry can be so desguared in two cases: ŒThe name in build-tools matches a locally defined executable. The executable dependency produced is on that exe in the current package.×The name in build-tools matches a hard-coded set of known tools. For now, the executable dependency produced is one an executable in a package of the same, but the hard-coding could just as well be per-key.The first cases matches first. CabalmGet everything from "build-tool-depends", along with entries from "build-tools" that we know how to desugar.AThis should almost always be used instead of just accessing the  Ŗ field directly. ŽCabalADoes the given executable dependency map to this current package?8This is a tiny function, but used in a number of places.'This function is only sound to call on  ¦’s from the given package description. This is because it just filters the package names of each dependency, and does not check whether version bounds in fact exclude the current package, or the referenced components in fact exist in the current package.@This is OK because when a package is loaded, it is checked (in h’}) that dependencies matching internal components do indeed have version bounds accepting the current package, and any depended-on component in the current package actually exists. In fact this check is performed by gathering the internal tool dependencies of each component of the package according to this module, and ensuring those properties on each so-gathered dependency.œversion bounds and components of the package are unchecked. This is because we sanitize exe deps so that the matching name implies these other conditions. CabalDGet internal "build-tool-depends", along with internal "build-tools"^This is a tiny function, but used in a number of places. The same restrictions that apply to  Ž also apply to this function. Œ  Ž  Œ  Ž …Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone47>SX ŗÆ ‘Cabal_An abstract path, possibly containing variables that need to be substituted for to get a real q. ’CabalThe location prefix for the copy command. •Cabal˜when using the ${pkgroot} as prefix. The CopyToDb will adjust the paths to be relative to the provided package database when copying / installing. –Cabal)The installation directories in terms of  ‘s that contain variables.’The defaults for most of the directories are relative to each other, in particular they are all relative to a single prefix. This makes it convenient for the user to override the default installation directory by only having to specify --prefix=... rather than overriding each individually. This is done by allowing $-style variables in the dirs. These are expanded by textual substitution (see  ²).„A few of these installation directories are split into two components, the dir and subdir. The full installation path is formed by combining the two together with /Y. The reason for this is compatibility with other Unix build systems which also support --libdir and  --datadir/. We would like users to be able to configure --libdir=/usr/lib64ø for example but because by default we want to support installing multiple versions of packages and building the same package for multiple compilers we append the libsubdir to get: /usr/lib64/$libname/$compiler.{An additional complication is the need to support relocatable packages on systems which support such things, like Windows. —Cabal9The directories where we will install files for packages.ōWe have several different directories for different types of files since many systems have conventions whereby different types of files in a package are installed in different directories. This is particularly the case on Unix style systems. žCabalforeign libraries ¬Cabal5Substitute the install dir templates into each other.õTo prevent cyclic substitutions, only some variables are allowed in particular dir templates. If out of scope vars are present, they are not substituted for. Checking for any remaining unsubstituted vars can be done as a subsequent operation.-The reason it is done this way is so that in  ® we can replace  ™ with the < and get resulting  ‘s that still have the <U in them. Doing this makes it each to check which paths are relative to the $prefix. ­Cabal›Convert from abstract install directories to actual absolute ones by substituting for all the variables in the abstract paths, to get real absolute path. ®CabalBCheck which of the paths are relative to the installation $prefix.©If any of the paths are not relative, ie they are absolute paths, then it prevents us from making a relocatable package (also known as a "prefix independent" package). ÆCabal Convert a q to a  ‘ including any template vars. °Cabal7Convert back to a path, any remaining vars are included ³Cabal=The initial environment has all the static stuff but no paths@;<=>?@ABCDEFGHIJKLMNOPQ  ‘ ’ ” • “ – — ˜ ™ š › œ  ¢ £ ¤ ¦ ž Ÿ   ” „ § Ø © Ŗ « ¬ ­ ® Æ ° ± ² ³ “ µ ¶ · ø@ — ˜ ™ š › œ  ¢ £ ¤ ¦ ž Ÿ   ” „ § Ø – Ŗ « © ­ ’ ” • “ ® ¬ ‘;<=>?@ABCDEFGHIJKLMNOPQ  Æ ° ± ² ³ ¶ µ “ · ø†None =>?@ACSX Ń9 ĖCabalFilepath are parsed as  Ż. ĪCabalVersion range or just version ŃCabal)SPDX License expression or legacy license ŌCabal$Version range or just version, i.e.  cabal-version field.!There are few things to consider:“Starting with 2.2 the cabal-version field should be the first field in the file and only exact version is accepted. Therefore if we get e.g. >= 2.2, we fail. See ,https://github.com/haskell/cabal/issues/4899 ×CabalEither "quoted" or  un-quoted. ŚCabalHaskell string or [^ ]+ ŻCabalHaskell string or [^ ,]+ ąCabal4List separated with optional commas. Displayed with sep, arguments of type a" are parsed and pretty-printed as b. CabalProxy, internal to this module. äCabal3Paragraph fill list without commas. Displayed with !. ęCabal9Paragraph fill list with optional commas. Displayed with !. čCabal3Vertical list with optional commas. Displayed with ". źCabal0Paragraph fill list with commas. Displayed with ! ģCabal*Vertical list with commas. Displayed with " īCabal ī and  ļ are simply  ąE, with additional phantom arguments to constraint the resulting type:t alaList VCat/alaList VCat :: [a] -> List VCat (Identity a) a:t alaList' FSep Token9alaList' FSep Token :: [String] -> List FSep Token String ļCabalMore general version of  ī.% Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ% ī ļ ģ ķ ź ė č é ę ē ä å į ā ć ą Ō Õ Ö Ī Ļ Š Ń Ņ Ó Ż Ž ß Ś Ū Ü × Ų Ł Ė Ģ ĶSafe ŅŸ#$%&'()* #Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone7>SX x«A CabalAdvanced options for M and O.CabalKeep temporary files?+Cabal/When should we output the marker? Things like die always get marked, but a ,5 will only be output if we're not a quiet verbosity.-CabalĄWhen should we emit the call stack? We always emit for internal errors, emit the trace for errors when we are in verbose mode, and otherwise only emit it if explicitly asked for using the  +callstack# verbosity flag. (At the moment, . is not used./CabalTag an s= whose error string should be output to the screen verbatim.0Cabal Check if an s% should be output verbatim to screen.1Cabal Create a r) whose error text will be output verbatimCabal’Given a block of IO code that may raise an exception, annotate it with the metadata from the current scope. Use this as close to external code that raises IO exceptions as possible, since this function unconditionally wraps the error message with a trace (so it is NOT idempotent.)2CabalBC wrapper around u.CabalCNon fatal conditions that may be indicative of an error or problem.We display these at the Ł verbosity level.CabalUseful status messages.We display these at the Ł verbosity level.“This is for the ordinary helpful status messages that users see. Just enough information to know that things are working but not floods of detail.CabalDisplay a message at Ł( verbosity level, but without wrapping.CabalPretty-print a 3 status message at Ł: verbosity level. Use this if you need fancy formatting.CabalKDisplay a "setup status message". Prefer using setupMessage' if possible.Cabal,More detail on the operation of some action.6We display these messages when the verbosity level is ŚCabal'Detailed internal debugging information6We display these messages when the verbosity level is Ū Cabal A variant of Y that doesn't perform the automatic line wrapping. Produces better output in some cases.!CabalXPerform an IO action, catching any IO exceptions and printing an error if one occurs."Cabal!Run an IO computation, returning e- if it raises a "file does not exist" error.4CabalWraps text unless the +nowrap verbosity flag is active5CabalPrepends a timestamp if  +timestamp verbosity flag is setThis is used by 6#CabalWrap output with a marker if  +markoutput verbosity flag is set.’NB: Why is markoutput done with start/end markers, and not prefixes? Markers are more convenient to add (if we want to add prefixes, we have to • and then ’; here's it's just some concatenates). Note that even in the prefix case, we can't guarantee that the markers are unambiguous, because some of Cabal's output comes straight from external programs, where we don't have the ability to interpose on the output.This is used by 67CabalVAppend a trailing newline to a string if it does not already have a trailing newline.8Cabal8Prepend a call-site and/or call-stack based on Verbosity9CabalbDetermine if we should emit a call stack. If we trace, it also emits any prefix we should append.6Cabal/Add all necessary metadata to a logging message,Cabal$Run a command and return its output.8The output is assumed to be text in the locale encoding.-Cabal²Run a command and return its output, errors and exit status. Optionally also supply some input. Also provides control over whether the binary/text mode of the input and output..CabaløLook for a program and try to find it's version number. It can accept either an absolute path or the name of a program binary, in which case we will look for the program on the path./CabalŅLike the Unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.@Use it with either of the rawSystem variants above. For example: @xargs (32*1024) (rawSystemExit verbosity) prog fixedArgs bigArgs1CabalJFind a file by looking in a search path. The file path must match exactly.2CabalŃFind a file by looking in a search path with one of a list of possible file extensions. The file base name should be given and it will be tried with each of the extensions in each element of the search path.4CabalLike 2x but returns which element of the search path the file was found in, and the file path relative to that base directory.7Cabal@Finds the files corresponding to a list of Haskell module names.As 8 but for a list of module names.9Cabal5Find the file corresponding to a Haskell module name.This is similar to 4j but specialised to a module name. The function fails if the file corresponding to the module is missing.:Cabal9List all the files in a directory and all subdirectories.ÓThe order places files in sub-directories after all the files in their parent directories. The list is generated lazily so is not well defined if the source directory structure changes before the list is used.;Cabal,Is this directory in the system search path?=Cabal’(Compare the modification times of two files to see if the first is newer than the second. The first file must exist but the second need not. The expected use case is when the second file is generated using the first. In this use case, if the result is True then the second file is out of date.>CabalLike =-, but also checks that the first file exists.?CabalSame as createDirectoryIfMissing% but logs at higher verbosity levels.@Cabal‹Copies a file without copying file permissions. The target file is created with default permissions. Any existing target file is replaced.3At higher verbosity levels it logs an info message.ACabalŪInstall an ordinary file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rw-r--r--" while on Windows it uses the default permissions for the target directory.BCabalŻInstall an executable file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rwxr-xr-x" while on Windows it uses the default permissions for the target directory.CCabalEInstall a file that may or not be executable, preserving permissions.DCabalGiven a relative path to a file, copy it to the given directory, preserving the relative path and creating the parent directories if needed.:CabalCommon implementation of E, F, G and H.ECabal¤Copies a bunch of files to a target directory, preserving the directory structure in the target location. The target directories are created if they do not exist.›The files are identified by a pair of base directory and a path relative to that base. It is only the relative part that is preserved in the destination. For example: RcopyFiles normal "dist/src" [("", "src/Foo.hs"), ("dist/build/", "src/Bar.hs")]qThis would copy "src/Foo.hs" to "dist/src/src/Foo.hs" and copy "dist/build/src/Bar.hs" to "dist/src/src/Bar.hs".üThis operation is not atomic. Any IO failure during the copy (including any missing source files) leaves the target in an unknown state so it is best to use it with a freshly created directory so that it can be simply deleted if anything goes wrong.FCabal This is like E but uses A.GCabal This is like E but uses B.HCabal This is like E but uses C.ICabalŖThis installs all the files in a directory to a target location, preserving the directory layout. All the files are assumed to be ordinary rather than executable files.JCabal?Recursively copy the contents of one directory to another path.KCabalLike ;., but also checks that the file is executable.MCabal4Use a temporary filename that doesn't already exist.NCabal A version of M that additionally takes a   argument.OCabal%Create and use a temporary directory.Creates a new temporary directory inside the given directory, making use of the template. The temp directory is deleted after use. For example: >withTempDirectory verbosity "src" "sdist." $ \tmpDir -> do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342.PCabal A version of O that additionally takes a   argument.QCabal¾Write a file but only if it would have new content. If we would be writing the same as the existing content then leave the file as is so that we do not update the file's modification time.NB: Before Cabal-3.0 the file content was assumed to be ASCII-representable. Since Cabal-3.0 the file is assumed to be UTF-8 encoded.RCabalDThe path name that represents the current directory. In Unix, it's "."D, but this is system-specific. (E.g. AmigaOS uses the empty string "" for the current directory.)TCabal"Drop the extension if it's one of U , or return the path unchanged.UCabalDList of possible executable file extensions on the current platform.VCabalPackage description file (pkgname.cabal)WCabalDFind a package description file in the given directory. Looks for .cabal files.XCabalLike W , but calls die in case of error.YCabalFFind auxiliary package information in the given directory. Looks for  .buildinfo files.!Cabal.a description of the action we were attemptingCabalthe action itself*CabalNew working dir or inheritCabalNew environment or inheritCabalstdinCabalstdoutCabalstderr+CabalNew working dir or inheritCabalNew environment or inheritCabalstdinCabalstdoutCabalstderrCabal7Any handles created for stdin, stdout, or stderr with  CreateProcess, and a handle to the process.-CabalProgram locationCabal ArgumentsCabalNew working dir or inheritCabalNew environment or inheritCabalinput text and binary modeCabaloutput in binary modeCabaloutput, errors, exit.Cabal version argsCabal8function to select version number from program outputCaballocation0Cabalsearch locationsCabal File Name1Cabalsearch locationsCabal File Name6Cabal"build prefix (location of objects)Cabalsearch suffixesCabalmodules7Cabal"build prefix (location of objects)Cabalsearch suffixesCabalmodules8Cabal"build prefix (location of objects)Cabalsearch suffixesCabalmodule9Cabal"build prefix (location of objects)Cabalsearch suffixesCabalmodule?CabalCreate its parents too?MCabalTemp dir to create the file inCabalFile name template. See ¹.NCabalTemp dir to create the file inCabalFile name template. See ¹.WCabal Where to lookCabal pkgname.cabalYCabalDirectory to searchCabaldir/pkgname .buildinfo , if presents™£WŚŪÜŻŽß’       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYs !%&#"'(),-*+$/.ŻŽßŚŪÜ?@EDABCFGHIJKRSTU1524397:;<=> LMNOPWVWXYQ     £™’086‡None27 O [Cabal%NubListR : A right-biased version of ] . That is +toNubListR ["-XNoFoo", "-XFoo", "-XNoFoo"] will result in ["-XFoo", "-XNoFoo"], unlike the normal ]), which is left-biased. Built on top of  and .]CabalANubList : A de-duplicated list that maintains the original order._Cabal'Smart constructor for the NubList type.`Cabal7Lift a function over lists to a function over NubLists.<Cabal1Helper used by NubList/NubListR's Read instances.aCabal(Smart constructor for the NubListR type.bCabal8Lift a function over lists to a function over NubListRs.cCabal>Binary instance for 'NubList a' is the same as for '[a]'. For G6, we just pull off constructor and put the list. For F, we get the list and make a ] out of it using _.gCabalMonoid operations on NubLists. For a valid Monoid instance we need to satistfy the required monoid laws; identity, associativity and closure.'Identity : by inspection: mempty ! NubList xs == NubList xs ! mempty1Associativity : by inspection: (NubList xs ! NubList ys) ! NubList zs == NubList xs ! (NubList ys ! NubList zs)dClosure : appending two lists of type a and removing duplicates obviously does not change the type.[\]^_`ab]_^`[a\bˆNone>MSX –CoCabalThe ē4 monad with specialized logging and error messages.pCabalRun o!, outputting traces according to ×, die if there is an error.qCabal"Output a warning trace message in o.rCabal)Output an informational trace message in o.sCabal+Fail the computation with an error message.=Cabal:Format a message with context. (Something simple for now.)tCabal+Add a message to the error/warning context.opqrstopqrst‰(c) Sergey Vinokurov 2017 BSD3-stylecabal-devel@haskell.orgNone>SX š©xCabal-Working directory to create response file in.Cabal Template for response file name.Cabal+Encoding to use for response file contents.Cabal$Arguments to put into response file.xxŠDuncan Coutts 2013cabal-devel@haskell.orgportableNone7>SX ©›zCabalA specific dir{CabalThe system default|CabalOA search path to use when locating executables. This is analogous to the unix $PATH or win32 %PATH%Q but with the ability to use the system default method for finding executables (>) which on unix is simply looking on the $PATH* but on win32 is a bit more complicated).The default to use is [ProgSearchPathDefault]‹ but you can add extra dirs either before, after or instead of the default, e.g. here we add an extra dir to search after the usual ones. 8['ProgramSearchPathDefault', 'ProgramSearchPathDir' dir]Cabal Interpret a | to construct a new $PATHx env var. Note that this is close but not perfect because on Windows the search algorithm looks at more than just the %PATH%.€Cabal=Get the system search path. On Unix systems this is just the $PATH6 env var, but on windows it's a bit more complicated.yz{|}~€|yz{}~€‹)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone27>SX ŪŚ„Cabal‹Where a program was found. Also tells us whether it's specified by user or not. This includes not just the path, but the program as well.…CabalHThe user gave the path to this program, eg. --ghc-path=/usr/bin/ghc-6.6†Cabal$The program was found automatically.ˆCabalKRepresents a program which has been configured and is thus ready to be run.(These are usually made by configuring a “=, but if you have to construct one directly then start with  and override any extra fields.ŠCabalJust the name again‹Cabal,The version of this program, if it is known.ŒCabalDefault command-line args for this program. These flags will appear first on the command line, so they can be overridden by subsequent flags.Cabal„Override command-line args for this program. These flags will appear last on the command line, so they override all earlier flags.ŽCabal­Override environment variables for this program. These env vars will extend/override the prevailing environment of the current to form the environment for the new process.Cabal­A key-value map listing various properties of the program, useful for feature detection. Populated during the configuration step, key names depend on the specific program.CabalLocation of the program. eg. /usr/bin/ghc-6.4‘CabalIn addition to the ’" where the program was found, these are additional locations that were looked at. The combination of ths found location and these not-found locations can be used to monitor to detect when the re-configuring the program might give a different result (e.g. found in a different location).“Cabal-Represents a program which can be configured.9Note: rather than constructing this directly, start with œ and override any extra fields.•Cabal'The simple name of the program, eg. ghc–CabalzA function to search for the program if its location was not specified by the user. Usually this will just be a call to ~.‚It is supplied with the prevailing search path which will typically just be used as-is, but can be extended or ignored as needed.‘For the purpose of change monitoring, in addition to the location where the program was found, it returns all the other places that were tried.—CabalTry to find the version of the program. For many programs this is not possible or is not necessary so it's OK to return Nothing.˜Cabal«A function to do any additional configuration after we have located the program (and perhaps identified its version). For example it could add args, or environment vars.™Cabal A function that filters any arguments that don't impact the output from a commandline. Used to limit the volatility of dependency hashes when using new-build.šCabal&The full path of a configured program.›Cabal/Suppress any extra arguments added by the user.œCabalMake a simple named program.ŠBy default we'll just search for it in the path and not try to find the version name. You can override these behaviours if necessary, eg: L(simpleProgram "foo") { programFindLocation = ... , programFindVersion ... }CabalMake a simple ˆ. 2simpleConfiguredProgram "foo" (FoundOnSystem path)yz{|„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œ“”•–—˜™|yz{œˆ‰Š‹ŒŽ‘š›’„…†‡ŒDuncan Coutts 2009cabal-devel@haskell.orgportableNone>SX š@¬Cabal7Represents a specific invocation of a specific program.’This is used as an intermediate type between deciding how to call a program and actually doing it. This provides the opportunity to the caller to adjust how the program will be called. These invocations can either be run directly or turned into shell or batch scripts.¼CabaleReturn the current environment extended with the given overrides. If an entry is specified twice in  overrides%, the second entry takes precedence.½CabalŅLike the unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.äIt takes four template invocations corresponding to the simple, initial, middle and last invocations. If the number of args given is small enough that we can get away with just a single invocation then the simple one is used:  $ simple args•If the number of args given means that we need to use multiple invocations then the templates for the initial, middle and last invocations are used: I$ initial args_0 $ middle args_1 $ middle args_2 ... $ final args_n©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¬­®Æ°±²³“µ©Ŗ«¶·ø½¹ŗ»¼Duncan Coutts 2009cabal-devel@haskell.orgportableNone õ£¾CabaloGenerate a system script, either POSIX shell script or Windows batch file as appropriate for the given system.æCabal5Generate a POSIX shell script that invokes a program.ĄCabal5Generate a Windows batch file that invokes a program.¾æĄ¾æĄŽThomas Tuegel 2011cabal-devel@haskell.orgportableNone>SX RĮCabal%Invoke hpc with the given parameters.’TPrior to HPC version 0.7 (packaged with GHC 7.8), hpc did not handle multiple .mix paths correctly, so we print a warning, and only pass it the first path in the list. This means that e.g. test suites that import their library as a dependency can still work, but those that include the library modules directly (in other-modules) don't.ĮCabalPath to .tix fileCabalPaths to .mix file directoriesCabal(Path where html output should be locatedCabal&List of modules to exclude from report?CabalPath to .tix fileCabalPaths to .mix file directoriesCabal)Path where html output should be locatedCabal'List of modules to exclude from reportĀCabalPaths to .tix filesCabalPath to resultant .tix fileCabal%List of modules to exclude from union@CabalPaths to .tix filesCabalPath to resultant .tix fileCabal%List of modules to exclude from unionĮĀĮĀ#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone4>SX ,/ ACabalFirst argument: Is this a **/*.extŒ pattern? Second argument: should we match against the exact extensions, or accept a suffix? Third argument: the extensions to accept.BCabalLiteral file name.CCabal,A single subdirectory component + remainder.ĪCabal$The glob matched the value supplied.ĻCabal’)The glob did not match the value supplied because the cabal-version is too low and the extensions on the file did not precisely match the glob's extensions, but rather the glob was a proper suffix of the file's extensions; i.e., if not for the low cabal-version, it would have matched.ŠCabal¤The glob couldn't match because the directory named doesn't exist. The directory will be as it appears in the glob (i.e., relative to the directory passed to Ō, and, for  'data-files', relative to  'data-dir').DCabal#Extract the matches from a list of Ķs.Note: throws away the ŠY results; chances are that you want to check for these and error out if any are present.ŅCabalReturns S% if the glob didn't match at all, or TZ the result if the glob matched (or would have matched with a higher cabal-version).ŌCabal This will n when the glob matches no files, or if the glob refers to a missing directory, or if the glob fails to parse.The M‘ argument must be the spec version of the package description being processed, as globs behave slightly differently in different spec versions. The first q“ argument is the directory that the glob is relative to. It must be a valid directory (and hence it can't be the empty string). The returned values will not include this prefix. The second q is the glob itself.ÕCabal?Match files against a pre-parsed glob, starting in a directory.The M‘ argument must be the spec version of the package description being processed, as globs behave slightly differently in different spec versions.The q³ argument is the directory that the glob is relative to. It must be a valid directory (and hence it can't be the empty string). The returned values will not include this prefix.ECabal^Extract the (possibly null) constant prefix from the pattern. This has the property that, if '(pref, final) = splitConstantPrefix pat, then -pat === foldr GlobStem (GlobFinal final) pref.FCabalThe pattern's extensionCabalThe candidate file's extensionĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÄÅĘĒČÉŹĖĢĶĪĻŠŌÕŅÓŃƐIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone27 qĶÜCabal’nSome compilers (notably GHC) support profiling and can instrument programs so the system can account costs to different functions. There are different levels of detail that can be used for this accounting. For compilers that do not support this notion or the particular detail levels, this is either ignored or just capped to some similar level they do support.äCabal›Some compilers support emitting debug info. Some have different levels. For compilers that do not the level is just capped to the level they do support.éCabal‘Some compilers support optimising. Some have different levels. For compilers that do not the level is just capped to the level they do support.ķCabal£We typically get packages from several databases, and stack them together. This type lets us be explicit about that stacking. For example typical stacks include: n[GlobalPackageDB] [GlobalPackageDB, UserPackageDB] [GlobalPackageDB, SpecificPackageDB "package.conf.inplace"]Note that the ļk is invariably at the bottom since it contains the rts, base and other special compiler-specific packages.’We are not restricted to using just the above combinations. In particular we can use several custom package dbs and the user package db together.>When it comes to writing, the top most (last) package is used.īCabal’rSome compilers have a notion of a database of available packages. For some there is just one global db of packages, other compilers support a per-user or an arbitrary db specified at some location in the file system. This can be used to build isloated environments of packages, for example to build a collection of related packages without installing them globally.ōCabalCompiler flavour and version.õCabalGTag for distinguishing incompatible ABI's on the same architecture/os.öCabalGOther implementations that this compiler claims to be compatible with.÷CabalSupported language standards.ųCabalSupported extensions.łCabal?A key-value map for properties not covered by the above fields.žCabalJIs this compiler compatible with the compiler flavour we're interested in?’For example this checks if the compiler is actually GHC or is another compiler that claims to be compatible with some version of GHC, e.g. GHCJS. 6if compilerCompatFlavor GHC compiler then ... else ...’Cabal‡Is this compiler compatible with the compiler flavour we're interested in, and if so what version does it claim to be compatible with.‹For example this checks if the compiler is actually GHC-7.x or is another compiler that claims to be compatible with some GHC-7.x version. fcase compilerCompatVersion GHC compiler of Just (Version (7:_)) -> ... _ -> ...CabalaReturn the package that we should register into. This is the package db at the top of the stack.CabalMake package paths absoluteCabalBFor the given compiler, return the extensions it does not support. CabalFFor the given compiler, return the flags for the supported extensions.GCabalLooks up the flag for a given extension, for a given compiler. Ignores the subtlety of extensions which lack associated flags.HCabal’Looks up the flag for a given extension, for a given compiler. However, the extension may be valid for the compiler but not have a flag. For example, NondecreasingIndentation is enabled by default on GHC 7.0.4, hence it is considered a supported extension but not an accepted flag.»The outer layer of Maybe indicates whether the extensions is supported, while the inner layer indicates whether it has a flag. When building strings, it is often more convenient to use G , which ignores the difference. Cabal0Does this compiler support parallel --make mode? Cabal.Does this compiler support reexported-modules? Cabal>Does this compiler support thinning/renaming on package flags? Cabal:Does this compiler have unified IPIDs (so no package keys)Cabal(Does this compiler support package keys?Cabal$Does this compiler support unit IDs?Cabal$Does this compiler support Backpack?CabalRDoes this compiler support a package database entry with: "dynamic-library-dirs"?CabalaDoes this compiler's "ar" command supports response file arguments (i.e. @file-style arguments).Cabal4Does this compiler support Haskell program coverage?Cabal%Does this compiler support profiling?ICabal&Utility function for GHC only features` [ ] \ ^ _ ` a b c d e f g h i j k s u l m n o p q r t v w x y z { | } ~ÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’     <ņóōõö÷ųłśūüżž’īļšńķéźėģäåęēčć     ÜŻŽßąįā cabal-devel@haskell.orgportableNone „D 6CabalDInformation about features and quirks of a GHC-based implementation.’Compiler flavors based on GHC behave similarly enough that some of the support code for them is shared. Every implementation has its own peculiarities, that may or may not be a direct result of the underlying GHC version. This record keeps track of these differences.³All shared code (i.e. everything not in the Distribution.Simple.FLAVOR module) should use implementation info rather than version numbers to test for supported features.8Cabal"XHaskell2010 and -XHaskell98 flags9Cabal(-supported-languages gives Ext and NoExt:Cabal%NondecreasingIndentation is always on;Cabalghci-script flag supported<Cabalnew style -fprof-auto* flags=Cabal&use package-conf instead of package-db>Cabalg flag supported?Cabalsupports numeric -g levels@Cabal picks up .ghc.environment filesACabal"Wmissing-home-modules is supportedJCabalThe GHCJS versionCabalThe GHC version6789:;<=>?@ABKJ’None"#7>SX ŠžDDCabal  -fprof-autoECabal -fprof-auto-topFCabal -fprof-auto-exportedHCabal -staticICabal -dynamicJCabal -static -dynamic-tooLCabal -O0MCabal -ONCabal -O2OCabale.g. -OdphQCabal ghc -cRCabal ghcSCabal  ghc --makeTCabalghci / ghc --interactiveUCabalghc --abi-hash( | GhcModeDepAnalysis -- ^ ghc -M( | GhcModeEvaluate -- ^ ghc -eVCabal%A structured set of GHC options/flags<Note that options containing lists fall into two categories:Voptions that can be safely deduplicated, e.g. input modules or enabled extensions;yoptions that cannot be deduplicated in general without changing semantics, e.g. extra ghc options or linking options.XCabal&The major mode for the ghc invocation.YCabal_Any extra options to pass directly to ghc. These go at the end and hence override other stuff.ZCabalpExtra default flags to pass directly to ghc. These go at the beginning and so can be overridden by other stuff.[CabalCThe main input files; could be .hs, .hi, .c, .o, depending on mode.\Cabal/The names of input Haskell modules, mainly for --make mode.]CabalLocation for output file; the ghc -o flag.^Cabal$Location for dynamic output file in J mode; the  ghc -dyno flag._Cabal?Start with an empty search path for Haskell source files; the ghc -i flag (-i# on its own with no path argument).`Cabal*Search path for Haskell source files; the ghc -i flag.aCabal,The unit ID the modules will belong to; the ghc -this-unit-id flag (or -this-package-key or  -package-name( on older versions of GHC). This is a 7‡ because we assume you've already figured out what the correct format for this string is (we need to handle backwards compatibility.)bCabalŌGHC doesn't make any assumptions about the format of definite unit ids, so when we are instantiating a package it needs to be told explicitly what the component being instantiated is. This only gets set when c is non-emptycCabaltHow the requirements of the package being compiled are to be filled. When typechecking an indefinite package, the  W is always a  YL; otherwise, it specifies the installed module that instantiates a package.dCabal*No code? (But we turn on interface writingeCabal"GHC package databases to use, the ghc -package-conf flag.fCabal:The GHC packages to bring into scope when compiling, the ghc -package-id flags.gCabal$Start with a clean package set; the ghc -hide-all-packages flaghCabal.Warn about modules, not listed in command lineiCabal/Don't automatically link in Haskell98 etc; the ghc -no-auto-link-packages flag.jCabal#Names of libraries to link in; the ghc -l flag.kCabal*Search path for libraries to link in; the ghc -L flag.lCabal+Options to pass through to the linker; the  ghc -optl flag.mCabal%OSX only: frameworks to link in; the ghc -framework flag.nCabal6OSX only: Search path for frameworks to link in; the ghc -framework-path flag.oCabal1Don't do the link step, useful in make mode; the  ghc -no-link flag.pCabalDon't link in the normal RTS main entry point; the ghc -no-hs-main flag.qCabal*Module definition files (Windows specific)rCabal/Options to pass through to the C compiler; the  ghc -optc flag.sCabal,Options to pass through to the C++ compiler.tCabal)Options to pass through to the Assembler.uCabal$Options to pass through to CPP; the  ghc -optP flag.vCabal4Search path for CPP includes like header files; the ghc -I flag.wCabal0Extra header files to include at CPP stage; the ghc -optP-include flag.xCabal5Extra header files to include for old-style FFI; the  ghc -#include flag.yCabalThe base language; the ghc -XHaskell98 or  -XHaskell2010 flag.zCabalThe language extensions; the ghc -X flag.{CabalhA GHC version-dependent mapping of extensions to flags. This must be set to be able to make use of the z.|Cabal$What optimisation level to use; the ghc -O flag.}CabalEmit debug info; the ghc -g flag.~CabalCompile in profiling mode; the  ghc -prof flag.Cabal.Automatically add profiling cost centers; the ghc -fprof-auto* flags.€Cabal&Use the "split sections" feature; the ghc -split-sections flag.Cabal*Use the "split object files" feature; the ghc -split-objs flag.‚Cabal(Run N jobs simultaneously (if possible).ƒCabalEnable coverage analysis; the ghc -fhpc -hpcdir flags.„Cabal Extra GHCi startup scripts; the  -ghci-script flag‡Cabalonly in J modeˆCabalonly in J mode“Cabal9Get GHC to be quiet or verbose with what it's doing; the ghc -v flag.”CabalJPut the extra folders in the PATH environment variable we invoke GHC with•CabalZLet GHC know that it is Cabal that's calling it. Modifies some of the GHC error messages.LCabalGHC <7.6 uses '-package-conf' instead of  '-package-db'.šCabalGHC >= 7.6 uses the  '-package-db' flag. See  ,https://ghc.haskell.org/trac/ghc/ticket/5977.XCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™šXVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•PQRSTUKLMNOGHIJCDEF˜™—š–“)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone Ö)§CabalUThe default list of programs. These programs are typically used internally to Cabal.§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀ§ØŖ©«¬­®±²Æµ¶·³“ø¹ŗ»¼½¾æĄĮĀ°”)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone2>SX łĆCabalÆThe configuration is a collection of information about programs. It contains information both about configured programs and also about programs that we are yet to configure.ŻThe idea is that we start from a collection of unconfigured programs and one by one we try to configure them at which point we move them into the configured collection. For unconfigured programs we record not just the “C but also any user-provided arguments and location for the program.ĘCabalThe 'Read'\/'Show' and H1 instances do not preserve all the unconfigured Programs because “ is not in 'Read'\/'Show'D because it contains functions. So to fully restore a deserialised Ć. use this function to add back all the known “s.IIt does not add the default programs, but you probably want them, use §) in addition to any extra you might need.ĒCabal/Add a known program that we may configure laterĖCabalGet the current | used by the Ć“. This is the default list of locations where programs are looked for when configuring them. This can be overridden for specific programs (with Īf), and specific known programs can modify or ignore this search path in their own configuration code.ĢCabalChange the current | used by the Ć}. This will affect programs that are configured from here on, so you should usually set it before configuring any programs.ĶCabalModify the current | used by the Ć€. This will affect programs that are configured from here on, so you should usually modify it before configuring any programs.ĪCabalUser-specify this path. Basically override any path information for this program in the configuration. If it's not a known program ignore it.ŠCabal§User-specify the arguments for this program. Basically override any args information for this program in the configuration. If it's not a known program, ignore it..ŃCabalLike Ī) but for a list of progs and their paths.ŅCabalLike Ī( but for a list of progs and their args.MCabalFGet the path that has been previously specified for a program, if any.ÓCabalEGet any extra args that have been previously specified for a program.ŌCabal Try to find a configured programÕCabal,Update a configured program in the database.ÖCabalList all configured programs.×Cabal’Try to configure a specific program. If the program is already included in the collection of unconfigured programs then we use any user-supplied location and arguments. If the program gets configured successfully it gets added to the configured collection.­Note that it is not a failure if the program cannot be configured. It's only a failure if the user supplied a location and the program could not be found at that location.ŲThe reason for it not being a failure at this stage is that we don't know up front all the programs we will need, so we try to configure them all. To verify that a program was actually successfully configured use Ū.NCabal$Configure a bunch of programs using × . Just a \.ŲCabalrUnconfigure a program. This is basically a hack and you shouldn't use it, but it can be handy for making sure a Ū actually reconfigures.ŁCabalJTry to configure all the known programs that have not yet been configured.ŚCabal\reconfigure a bunch of programs given new user-specified args. It takes the same inputs as Ī and Š- and for all progs with a new path it calls ×.ŪCabal;Check that a program is configured and available to be run.lIt raises an exception if the program could not be configured, otherwise it returns the configured program.ÜCabal;Check that a program is configured and available to be run.mAdditionally check that the program version number is suitable and return it. For example you could require  AnyVersion or } (M [1,0] [])NIt returns the configured program, its version number and a possibly updated Ćb. If the program could not be configured or the version is unsuitable, it returns an error value.ŻCabalLike ÜO, but raises an exception in case of error instead of returning 'Left errMsg'.ŽCabal4Note that this instance does not preserve the known “s. See Ę for details.ßCabal4Note that this instance does not preserve the known “s. See Ę for details.ąCabal4Note that this instance does not preserve the known “s. See Ę for details.ĪCabal Program nameCabal"user-specified path to the programŠCabal Program nameCabaluser-specified argsĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻĆÄÅĘĒČÉŹĖĢĶĪŃĻŠŅÓŌÕÖףŲÜŚŪŻ•)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone>SX ).įCabal"Runs the given configured program.āCabal6Runs the given configured program and gets the output.ćCabal?Looks up the given program in the program database and runs it.äCabal?Looks up the given program in the program database and runs it.įCabal VerbosityCabalThe program to runCabalAny extra arguments to addāCabal VerbosityCabalThe program to runCabalAny extra arguments to addćCabal verbosityCabalThe program to runCaballook up the program hereCabalAny extra arguments to addäCabal verbosityCabalThe program to runCaballook up the program hereCabalAny extra arguments to addd.yz{|}~„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œ¬­®Æ°±²³“µ¶·ø¹ŗ§ØŖ«¬­®Æ°³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĪĻŠŃŅÓŌÕףŚŪÜŻįāćäd“”•–—˜™|yz{œ~}.ˆ‰Š‹ŒŽ‘š’„…†‡įā›¬­®Æ°±²³“µ¶·ø¹ŗ§ĆÅÄĘĒČÉŹĖĢĪŃĻŠŅÓŌÜÕףŚŪŻćäØŖ«¬­®Æµ¶·³“ø¹ŗ»¼½¾æĄĮĀ°–cabal-devel@haskell.orgportableNone>SX -åęęå—Duncan Coutts 2007BSD3cabal-devel@haskell.org(non-portable (ExistentialQuantification)None>ESX \õēCabalwraps a  CommandUI/ together with a function that turns it into a CommandŻ. By hiding the type of flags for the UI allows construction of a list of all UIs at the top level of the program. That list can then be used for generation of manual page as well as for executing the selected command.OCabal(Common flags that apply to every commandõCabal Long command line option stringsöCabal!Short command line option strings÷CabalaAn OptionField takes one or more OptDescrs, describing the command line interface for the field.üCabal’LWe usually have a data type for storing configuration values, where every field stores a configuration option, and the user sets the value either via command line flags or a configuration file. An individual OptionField models such a field, and we usually build a list of options associated to a configuration data type.CabalQThe name of the command as it would be entered on the command line. For example "build".CabalBA short, one line description of the command to use in help texts. CabalIA function that maps a program name to a usage summary for this command. Cabal;Additional explanation of the command to use in help texts. Cabal+Post-Usage notes and examples in help texts CabalInitial / empty flags Cabal&All the Option fields for this commandCabalzCreate an option taking a single OptDescr. No explicit Name is given for the Option, the name is the first LFlag given.CabalŠCreate an option taking several OptDescrs. You will have to give the flags and description individually to the OptDescr constructor.Cabal.Create a string-valued command line interface.CabalCCreate a string-valued command line interface with a default value.Cabal!(String -> a) variant of "reqArg"Cabal!(String -> a) variant of "optArg"Cabalcreate a Choice optionCabal¹create a Choice option out of an enumeration type. As long flags, the Show output is used. As short flags, the first character which does not conflict with a previous one is used.Cabal:Show flags in the standard long option command line formatPCabalDThe help text for this command with descriptions of all the options.Cabal0Default "usage" documentation text for commands.CabalHCreate "usage" documentation from a list of parameter configurations.CabalMake a Command from standard GetOpt options.Cabal'Parse a bunch of command line argumentsCabaljMark command as hidden. Hidden commands don't show up in the 'progname help' or 'progname --help' output."CabalUtility function, many commands do not accept additional flags. This action fails with a helpful error message if the user supplies any extra.#Cabal6Helper function for creating globalCommand descriptionCabalDMkOptDescr constructors partially applied to flags and description.CabalnameCabalsynopsisCabalusage alternativesCabalinitial/empty flagsCabaloptionsCabal&Is the command a global or subcommand??ēčéźėģķļīńšņóōõö÷ųłśūüżž’      !"#$%?     ķļīńš#$é "źėģēč%!üżž’÷ųłśūöõōóņ˜8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone7>SX „CoCabal9When we build haddock documentation, there are two cases: «We build haddocks only for the current development version, intended for local use and not for distribution. In this case, we store the generated documentation in  distdochtml/ packagename.’.We build haddocks for intended for uploading them to hackage. In this case, we need to follow the layout that hackage expects from documentation tarballs, and we might also want to use different flags than for development builds, so in this case we store the generated documentation in  distdochtml/ packageid-docs.‚Cabal Flags to register and  unregister2: (user package, gen-script, in-place, verbosity)Cabal Flags to sdist: (snapshot, verbosity)”Cabal Flags to install: (package db, verbosity)Cabal Flags to copy6: (destdir, copy-prefix (backwards compat), verbosity)¤Cabal Flags to  configure command.+IMPORTANT: every time a new flag is added,   f should be updated. IMPORTANT: every time a new flag is added, it should be added to the Eq instance§CabalAll programs that cabal may runØCabaluser specified programs paths©Cabaluser specified programs argsŖCabalExtend the $PATH«Cabal(The "flavor" of the compiler, e.g. GHC.¬Cabalgiven compiler location­Cabalgiven hc-pkg location®CabalEnable vanilla libraryÆCabalEnable profiling in the library°CabalBuild shared library±CabalBuild static library²Cabal+Enable dynamic linking of the executables.³Cabal0Enable fully static linking of the executables.“Cabal%Enable profiling in the executables.µCabal1Enable profiling in the library and executables.¶Cabal8Profiling detail level in the library and executables.·Cabal'Profiling detail level in the libraryøCabalExtra arguments to  configure¹CabalEnable optimization.ŗCabalInstalled executable prefix.»CabalInstalled executable suffix.¼CabalInstallation paths¾Cabal"path to search for extra librariesæCabal0path to search for extra frameworks (OS X only)ĄCabalpath to search for header filesĮCabalexplicit IPID to be usedĀCabalexplicit CID to be usedĆCabaldbe as deterministic as possible (e.g., invariant over GHC, database, etc). Used by the test suiteÄCabal "dist" prefixÅCabalCabal file to useĘCabalverbosity levelĒCabalThe --user/--global flagČCabalWhich package DBs to useÉCabal!Enable compiling library for GHCiŹCabalEnable -split-sections with GHCĖCabalEnable -split-objs with GHCĢCabalEnable executable strippingĶCabalEnable library strippingĪCabal)Additional constraints for dependencies.ĻCabalThe packages depended on.ŠCabal’The requested Backpack instantiation. If empty, either this package does not use Backpack, or we just want to typecheck the indefinite package.ŅCabalEnable test suite compilationÓCabalEnable benchmark compilationŌCabalEnable program coverageÕCabal$Enable program coverage (deprecated)ÖCabalXAll direct dependencies and flags are provided on the command line by the user via the '--dependency' and  '--flags' options.×CabalEHalt and show an error message indicating an error in flag assignmentŲCabal Enable relocatable package builtŁCabalEmit debug info.ŚCabalXWhether to use response files at all. They're used for such tools as haddock, or or ld.ŪCabalĒAllow depending on private sublibraries. This is used by external tools (like cabal-install) so they can add multiple-public-libraries compatibility to older ghcs by checking visibility externally.ÜCabal:Flags that apply at the top level, not to any sub-command.äCabalMore convenient version of ä. Results in an :# if internal invariant is violated.QCabal Inverse to R.RCabal5Pretty-print a single entry of a module substitution.SCabalFor each known program PROG in progDb , produce a  with-PROG ü.CabalLike S*, but allows to customise the option name.TCabalFor each known program PROG in progDb , produce a  PROG-option ü.CabalFor each known program PROG in progDb , produce a  PROG-options ü.!CabalArguments to pass to a  configure script, e.g. generated by autoconf.$CabalpHelper function to split a string into a list of arguments. It's supposed to handle quoted things sensibly, eg: \splitArgs "--foo=\"C:/Program Files/Bar/" --baz" = ["--foo=C:/Program Files/Bar", "--baz"] SsplitArgs "\"-DMSGSTR=\\\"foo bar\\\"\" --baz" = ["-DMSGSTR=\"foo bar\"","--baz"]’ #$%&'()*+,. ’ ” • “'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoqprstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„Ś¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$’ ÜŻŽßćįā¤„Ś¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŪģęēäå鼝žŸ ”¢£ļķī”•–—˜™š›œņšńrstuvw’żžoqpXYZ[\]^_`abcdefghijklmnxyz{|}~€śūüIJKLMNOPQ '()* ABCDEFGH  RSTUVW‚ƒ„…†‡ˆ‰Š‹Œłö÷ųŽ‘’“õóō0123456789:;<=>?@+,-./ ’ ” • “!č"# ė $ą%&'()*+,.#$™Thomas Schilling, 2007BSD3cabal-devel@haskell.orgportableNone ž­UCabal0A set of targets with their package dependenciesVCabal9A map of dependencies that combines version ranges using €.WCabal)Result of dependency test. Isomorphic to Maybe d but renamed for clarity.XCabal‚Simplify a configuration condition using the OS and arch names. Returns the names of all the flags occurring in the condition.pCabal.Parse a configuration condition from a string.YCabalJTry to find a flag assignment that satisfies the constraints of all trees.’Returns either the missing dependencies, or a tuple containing the resulting data, the associated dependencies, and the chosen flag assignments.£In case of failure, the union of the dependencies that led to backtracking on all branches is returned. [TODO: Could also be specified with a function argument.]LTODO: The current algorithm is rather naive. A better approach would be to:IRule out possible paths, by taking a look at the associated dependencies.ĢInfer the required values for the conditions of these paths, and calculate the required domains for the variables used in these conditions. Then picking a flag assignment would be linear (I guess).iThis would require some sort of SAT solving, though, thus it's not implemented unless we really need it.qCabal Transforms a ¶h by putting the input under the "then" branch of a conditional that is True when Buildable is True. If qƒ can determine that Buildable is always True, it returns the input unchanged. If Buildable is always False, it returns the empty ¶.ZCabalThis is a special version of q for the [ type.fIt is not simply a specialisation. It is more complicated than it ought to be because of the way the [ monoid instance works. The  mempty = \l forgets the component type, which has the effect of completely deleting components that are not buildable.See  *https://github.com/haskell/cabal/pull/4094 for more details.rCabalLExtract conditions matched by the given predicate from all cond trees in a  .]CabalmCombine the target-specific dependencies in a TargetSet to give the dependencies for the package as a whole.^Cabal\Collect up the targets in a TargetSet of tagged targets, storing the dependencies as we go.tCabal>Create a package description with all configurations resolved.This function takes a  ; and several environment parameters and tries to generate  ÅG by finding a flag assignment that result in satisfiable dependencies.’&It takes as inputs a not necessarily complete specifications of flags assignments, an optional package index as well as platform parameters. If some flags are not assigned explicitly, this function will try to pick an assignment that causes this function to succeed. The package index is optional since on some platforms we cannot determine which packages have been installed before. When no package index is supplied, every dependency is assumed to be satisfiable, therefore all not explicitly assigned flags will get their default values.’ƒThis function will fail if it cannot find a flag assignment that leads to satisfiable dependencies. (It will not try alternative assignments for explicitly specified flags.) In case of failure it will return the missing dependencies that it encountered when trying different flag assignments. On success, it will return the package description and the full flag assignment chosen.,Note that this drops any stanzas which have buildable: Falseu. While this is arguably the right thing to do, it means we give bad error messages in some situations, see #3858.uCabal’hFlatten a generic package description by ignoring all conditions and just join the field descriptors into on package description. Note, however, that this may lead to inconsistent field values, since all values are joined into one field, which may not be possible in the original package description, due to the use of exclusive choices (if ... else ...).’TODO: One particularly tricky case is defaulting. In the original package description, e.g., the source directory might either be the default or a certain, explicitly set path. Since defaults are filled in only after the package has been resolved and when no explicit value has been set, the default path will be missing from the package description returned by this function.wCabalWalk a   and apply f to all nested  build-depends fields.YCabal3Domain for each flag name, will be tested in order.Cabal-OS as returned by Distribution.System.buildOSCabal1Arch as returned by Distribution.System.buildArchCabalCompiler informationCabalAdditional constraintsCabalDependency test function.Cabal}Either the missing dependencies (error case), or a pair of (set of build targets with dependencies, chosen flag assignments)tCabal%Explicitly specified flag assignmentsCabaljIs a given dependency satisfiable from the set of available packages? If this is unknown then use True.CabalThe   and  CabalCompiler informationCabalAdditional constraintsCabalhEither missing dependencies or the resolved package description along with the flag assignments chosen. ½¾æĄÅpqrstuvw tupsÅrq½Ąæ¾vwšMartin Sj&#xF6;gren 2004BSD3cabal-devel@haskell.orgportableNone>SXSCM%&'>?@ŅÓŌłśū    ! , - . / 0 1 2 3 4 J K Ā Ć Ä Å Ę Ē Č É        / 7 6 4 3 ; = : 0 1 2 5 8 9 < >}~ / 7 6 4 3 ; = : 0 1 2 5 8 9 < >M}~›None456 _CabalZBlock of lines, Boolean parameter tells whether block should be surrounded by empty lines‚CabalPrettyprint a list of fields.'Note: the first argument should return 70s without newlines and properly prefixes (with --q) to count as comments. This unsafety is left in place so one could generate empty lines between comment lines.ƒCabal‚! with user specified indentation.…CabalUsed in ‡.†CabalUsed in ‡.‡CabalSimple variant of genericFromParsecFieldˆCabal%Collapse margins, any margin = margin„Cabaltransform field contentsCabaltransform section arguments €‚ƒ„…†‡ €‚ƒ‡„…†œNone>SXK Cabal:A monad with failure and accumulating errors and warnings.ŽCabal Destruct a  into the emitted warnings and either a successful value or list of errors and possibly recovered a spec-version declaration.CabalRecover/ the parse result, so we can proceed parsing. Ž will still result in S, if there are recorded errors.CabalSet cabal spec version.‘CabalGet cabal spec version.’Cabal5Add a warning. This doesn't fail the parsing process.“CabalAdd multiple warnings at once.”Cabal*Add an error, but not fail the parser yet.For fatal failure use ••CabalAdd an fatal error.–CabalA 3.—Cabal3Helper combinator to do parsing plumbing for files.`Given a parser and a filename, return the parse of the file, after checking if the file exists.:Argument order is chosen to encourage partial application.—Cabal#File contents to final value parserCabalVerbosity levelCabal File to read˜Cabal#File contents to final value parserCabalVerbosity levelCabal File name Ž‘’“”•–—˜ Ž’“”•–‘—˜None:œCabalParse ˜  A from section arguments provided by parsec based outline parser.œœ Nonex7]^_`abcdefhg—˜™žŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶üż€‚„‡Ž’“”•˜7fhg]^de`abc_üżŽ˜’“”• ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µžŸ¶—˜™€‚„‡žNone4 ĖžCabal We can use  to pp print the s.Note: there is not trailing  ($+$ text "").žžŸNone4X"££CabalThe £ constructor of f.„Cabal4Single field, without name, but with its annotation. ¢£¤„¦§Ø©Ŗ«¬­ ¢©Ŗ§„¦Ø£¤¬«­ None=>?X)½`CabalPartitioning state¹Cabal6Reverse function application which binds tighter than Ń and #-. Useful for refining grammar specification. <*> ±L "extensions" (alaList' FSep MQuoted) oldExtensions ^^^ µ [1,12] "Please use 'default-extensions' or 'other-extensions' fields." ŗCabal;Partition field list into field map and groups of sections.»CabalTake all fields from the front."©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»ž¢£¤§©Ŗ«¬·ø¹ŗ»"©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¢ø©Ŗ·ž¹£¤§ŗ»¬«¹5”None/8¼CabalsAn intermediate type just used for parsing the benchmark stanza. After validation it is converted into the proper   type.ĀCabaltAn intermediate type just used for parsing the test-suite stanza. After validation it is converted into the proper   type."¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻ"ČÉŹĖĀĆÄÅĘĒŠŃŅĢĶĪĻ¼½¾æĄĮ×ŲŁÓŌÕÖŪÜŻŚ¢Jürgen Nicklisch-Franken 2010BSD3cabal-devel@haskell.org provisionalportableNone5VąCabal7Writes a .cabal file from a generic package descriptionįCabal0Writes a generic package description to a stringāCabal)Convert a generic package description to s.ćCabaläCabalåCabalęCabaląįāćäåęąįāćäåę£Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone>SXP aCabalSee b.cCabalCreate a from  ¦9. This class is used to implement common stanza parsing.Law: #view buildInfo . fromBuildInfo = idThis takes name, as ©s take names too.dCabalState of section parserēCabalParse the given package file.čCabalParses the given file into a  .„In Cabal 1.2 the syntax for package descriptions was changed to a format with sections and possibly indented property descriptions.éCabalH variant of čeCabal%Parse a non-recursive list of fields.fCabalPWarn on "import" fields, also map to Maybe, so errorneous fields can be filteredbCabal Sectionize2 an old-style Cabal file. A sectionized file has:/all global fields at the beginning, followed by"all flag declarations, followed by_an optional library section, and an arbitrary number of executable sections (in any order).•The current implementation just gathers all library-specific fields in a library section and wraps all executable stanzas in an executable section.ģCabal#Quickly scan new-style spec-versionŒA new-style spec-version declaration begins the .cabal file and follow the following case-insensitive grammar (expressed in RFC5234 ABNF): Önewstyle-spec-version-decl = "cabal-version" *WS ":" *WS newstyle-pec-version *WS spec-version = NUM "." NUM [ "." NUM ] NUM = DIGIT0 / DIGITP 1*DIGIT0 DIGIT0 = %x30-39 DIGITP = %x31-39 WS = %20 eCabalfields to be parsedgCabalaccept elifCabalgrammarCabalcommon stanzasCabalconstructor from buildInfoCabalcondition extractorhCabalgrammarCabalconstruct fromBuildInfoCabalcommon stanzasiCabalconstruct fromBuildInfoCabalcommon stanzasŽēčéźėģēč鍎ģźė¤None4SXSŚōCabal/A collection field parsers and pretty-printers.õCabal$Lookup a field value pretty-printer.öCabalLookup a field value parser.ųCabalNote: default values are printed.ōõö÷ōõö÷„None"#=?@AZæjCabal[This type is used to mangle fields as in serialised textual representation to the actual  K fields.kCabalJSPDX License expression or legacy license. Lenient parser, accepts either.lCabalCombine w1. in parsing we prefer value coming from munged name field over the lib-name.Should be irrelevant.mCabalSetter for the  package-name9 field. It should be acceptable for this to be a no-op.ūūn4¦"(c) The University of Glasgow 2004libraries@haskell.orgportableNoneiŅ Cabal˜Get the indefinite unit identity representing this package. This IS NOT guaranteed to give you a substitution; for instantiated packages you will get $DefiniteUnitId (installedUnitId ipi)A. For indefinite libraries, however, you will correctly get an  OpenUnitId with the appropriate  V. Cabal€Returns the set of module names which need to be filled for an indefinite package, or the empty set if the package is definite. Cabal2Return either errors, or IPI with list of warningsNote: errors array may< be empty, but the parse is still failed (it's a bug though) Cabal Pretty print  K.pkgRoot; isn't printed, as ghc-pkg prints it manually (as GHC-8.4).CabalThe variant of   which outputs pkgroot field too.Cabal=let ipi = emptyInstalledPackageInfo { maintainer = "Tester" }9fmap ($ ipi) $ showInstalledPackageInfoField "maintainer"Just "maintainer: Tester"> | } ~  # $ % & K L Q T v k ^ M N O P R S U V W X Y Z [ \ ] _ ` a b c d e f g h i j l m n o p q r s t u y     > K L Q T v k ^ M N O P R S U V W X Y Z [ \ ] _ ` a b c d e f g h i j l m n o p q r s t u   | } ~  # $ % & y  §None7HVˆ© Cabal?The first five fields are common across all algebraic variants.Cabal’NIt would be very convenient to store the literal Library here, but if we do that, it will get serialized (via the Binary) instance twice. So instead we just provide the ComponentName, which can be used to find the Component in the PackageDescription. NB: eventually, this will NOT uniquely identify the ComponentLocalBuildInfo.Cabal The computed Ņ of this component.Cabal The computed  .= which uniquely identifies this component. Might be hashed.Cabal:Is this an indefinite component (i.e. has unfilled holes)?Cabal"How the component was instantiatedCabalMResolved internal and external package dependencies for this component. The  ¦Å specifies a set of build dependencies that must be satisfied in terms of version ranges. This field fixes those dependencies to the specific versions available on this machine for this compiler.CabalQThe set of packages that are brought into scope during compilation, including a lP which may used to hide or rename modules. This is what gets translated into  -package-id. arguments. This is a modernized version of ', which is kept around for BC purposes.Cabal7The internal dependencies which induce a graph on the 0 of this package. This does NOT coincide with  because it ALSO records  'build-tool'. dependencies on executables. Maybe one day  cabal-install& will also handle these correctly too! CabalBCompatibility "package key" that we pass to older versions of GHC.!Cabal@Compatibility "package name" that we register this component as."CabaldA list of exposed modules (either defined in this component, or reexported from another component.)#CabalqConvenience field, specifying whether or not this is the "public library" that has the same name as the package. !"#$% !"#$%ØNoneHV¦+CabalThe +T contains all the information necessary to build a specific target (e.g., componentmodule4file) in a package. In principle, one can get the  ¢ from a  and LocalBuildInfo@, but it is much more convenient to have the component in hand.+,-.+,-.©Duncan Coutts 2009, 2013cabal-devel@haskell.orgportableNone>SX²O0Cabal+Additional variations in the behaviour for C.2Cabal7Allows re-registering / overwriting an existing package3CabaluInsist on the ability to register multiple instances of a single version of a single package. This will fail if the hc-pkg does not support it, see = and >.4CabalÖRequire that no checks are performed on the existence of package files mentioned in the registration info. This must be used if registering prior to putting the files in their final place. This will fail if the hc-pkg does not support it, see ?.5Cabal6Information about the features and capabilities of an hc-pkg program.8Cabalno package DB stack supported9Cabal'hc-pkg does not support verbosity flags:Cabal-use package-conf option instead of package-db;Cabal*supports directory style package databases<Cabal*requires directory style package databases=Cabal%supports --enable-multi-instance flag>Cabal#supports multi-instance via recache?Cabal$supports --force-files or equivalent@CabalCall hc-pkg9 to initialise a package database at the location {path}. hc-pkg init {path}ACabalRun hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it.BCabal Defaults are True, False and FalseCCabalCall hc-pkg to register a package. Ahc-pkg register {filename | -} [--user | --global | --package-db]DCabalCall hc-pkg to unregister a package <hc-pkg unregister [pkgid] [--user | --global | --package-db]ECabalCall hc-pkg$ to recache the registered packages. 1hc-pkg recache [--user | --global | --package-db]FCabalCall hc-pkg to expose a package. 8hc-pkg expose [pkgid] [--user | --global | --package-db]GCabalCall hc-pkg to retrieve a specific package :hc-pkg describe [pkgid] [--user | --global | --package-db]HCabalCall hc-pkg to hide a package. 6hc-pkg hide [pkgid] [--user | --global | --package-db]ICabalCall hc-pkgK to get all the details of all the packages in the given package database.JCabalCall hc-pkgQ to get the source package Id of all the packages in the given package database.(This is much less information than with IL, but also rather quicker. Note in particular that it does not include the  ., just the source  !3 which is not necessarily unique in any package db.$0123456:789;<=>?@ABCDEFGHIJKLMNOPQRS$56:789;<=>?01234B@ACDEFHIGJKLMNOQRPSŖp(c) David Himmelstrup 2005, Bjorn Bringert 2007, Duncan Coutts 2008-2009cabal-devel@haskell.orgportableNone7=>? eoCabal(We maintain the invariant that, for any o=, there is only one instance of the package in our database.XCabal)The default package index which contains InstalledPackageInfo. Normally use this.YCabal>The collection of information about packages from one or more  PackageDB8s. These packages generally should have an instance of  -Packages are uniquely identified in by their  .Q, they can also be efficiently looked up by package name or by name and version.ZCabal*Build an index out of a bunch of packages.If there are duplicates by  .$ then later ones mask earlier ones.[CabalMerge two indexes.SPackages from the second mask packages from the first if they have the exact same  .."For packages with the same source  !, packages from the second are "preferred" over those from the first. Being preferred means they are top result when we do a lookup by source  !M. This is the mechanism we use to prefer user packages over global packages.\Cabal(Inserts a single package into the index.8This is equivalent to (but slightly quicker than) using ! or [ with a singleton index.]Cabal2Removes a single installed package from the index.^Cabal&Removes all packages with this source  ! from the index._CabalDRemoves all packages with this (case-sensitive) name from the index.9NB: Does NOT delete internal libraries from this package.`Cabal$Get all the packages from the index.aCabal$Get all the packages from the index.4They are grouped by package name (case-sensitively).$(Doesn't include private libraries.)bCabal$Get all the packages from the index.AThey are grouped by source package id (package name and version).#(Doesn't include private libraries)cCabal$Get all the packages from the index.7They are grouped by source package id and library name.%This DOES include internal libraries.dCabal!Does a lookup by unit identifier..Since multiple package DBs mask each other by  .(, then we get back at most one package.eCabalTDoes a lookup by component identifier. In the absence of Backpack, this is just a d.fCabal4Does a lookup by source package id (name & version).>There can be multiple installed packages with the same source  ! but different  .K. They are returned in order of preference, with the most preferred first.gCabalConvenient alias of f0, but assuming only one package per package ID.hCabal%Does a lookup by source package name.iCabal=Does a lookup by source package name and a range of versions.oWe get back any number of versions of the specified package name, all satisfying the version range constraint.VThis does NOT work for internal dependencies, DO NOT use this function on those; use j instead.INVARIANT: List of eligible  K is non-empty.jCabal=Does a lookup by source package name and a range of versions.oWe get back any number of versions of the specified package name, all satisfying the version range constraint.INVARIANT: List of eligible  K is non-empty.kCabal/Does a case-insensitive search by package name.óIf there is only one package that compares case-insensitively to this name then the search is unambiguous and we get back all versions of that package. If several match case-insensitively but one matches exactly then it is also unambiguous.’ If however several match case-insensitively and none match exactly then we have an ambiguous result, and we get back all the versions of all the packages. The list of ambiguous results is split by exact package name. So it is a non-empty list of non-empty lists.lCabal9Does a case-insensitive substring search by package name.BThat is, all packages that contain the given string in their name.mCabal\Find if there are any cycles in the dependency graph. If there are no cycles the result is [].¶This actually computes the strongly connected components. So it gives us a list of groups of packages where within each group they all depend on each other, directly or indirectly.nCabalHAll packages that have immediate dependencies that are not in the index.GReturns such packages along with the dependencies that they're missing.oCabalATries to take the transitive closure of the package dependencies.€If the transitive closure is complete then it returns that subset of the index. Otherwise it returns the broken packages as in n.Note that if the result is Right []3 it is because at least one of the original given  !s do not occur in the index.pCabalBTakes the transitive closure of the packages reverse dependencies. The given  !s must be in the index.sCabal+Builds a graph of the package dependencies.Dependencies on other packages that are not in the index are discarded. You can check if there are any such dependencies with n.tCabalLGiven a package index where we assume we want to use all the packages (use oŲ if you need to get such a index subset) find out if the dependencies within it use consistent versions of each package. Return all cases where multiple packages depend on different versions of some other package.œEach element in the result is a package name along with the packages that depend on it and the versions they require. These are guaranteed to be distinct.uCabal7A rough approximation of GHC's module finder, takes a Xc and turns it into a map from module names to their source packages. It's used to initialize the  build-deps field in  cabal init."TUVWXYZ[\]^_`abcdefghijklmnopqrstu"XYZ[\]^_defghijkTUVWl`abcnopqrtmsu«None7>SXV²1}Cabal1Data cached after configuration step. See also ¤.CabaldOptions passed to the configuration step. Needed to re-run configuration when .cabal is out of date€Cabal9The final set of flags which were picked for this packageCabal;What components were enabled during configuration, and why.‚CabaluExtra args on the command line for the configuration step. Needed to re-run configuration when .cabal is out of dateƒCabalxThe installation directories for the various different kinds of files TODO: inplaceDirTemplates :: InstallDirs FilePath„Cabal The compiler we're building with…CabalThe platform we're building for†CabalWhere to build the package.‡Cabal6Path to the cabal file, if given during configuration.ˆCabalŁAll the components to build, ordered by topological sort, and with their INTERNAL dependencies over the intrapackage dependency graph. TODO: this is assumed to be short; otherwise we want some sort of ordered map.‰CabalLA map from component name to all matching components. These coincide with ˆŠCabalóAll the info about the installed packages that the current package depends on (directly or indirectly). The copy saved on disk does NOT include internal dependencies (because we just don't have enough information at this point to have an InstalledPackageInfoe for an internal dep), but we will often update it with the internal dependencies; see for example Ģ <. (This admonition doesn't apply for per-component builds.)‹Cabal5the filename containing the .cabal file, if availableŒCabal“WARNING WARNING WARNING Be VERY careful about using this function; we haven't deprecated it but using it could introduce subtle bugs related to  å.«In principle, this is supposed to contain the resolved package description, that does not contain any conditionals. However, it MAY NOT contain the description wtih a  å applied to it; see  åc for the whole sordid saga. As much as possible, Cabal library should avoid using this parameter.Cabal"Location and args for all programsŽCabal)What package database to use, global/userCabalWhether to build normal libs.Cabal,Whether to build profiling versions of libs.‘Cabal)Whether to build shared versions of libs.’CabalHWhether to build static versions of libs (with all other libs rolled in)“Cabal'Whether to link executables dynamically”Cabal,Whether to link executables fully statically•Cabal+Whether to build executables for profiling.–Cabal"Level of automatic profile detail.—Cabal"Level of automatic profile detail.˜Cabal2Whether to build with optimization (if available).™Cabal*Whether to emit debug info (if available).šCabal1Whether to build libs suitable for use with GHCi.›Cabal*Use -split-sections with GHC, if availableœCabal&Use -split-objs with GHC, if availableCabal+Whether to strip executables during installžCabal)Whether to strip libraries during installŸCabal-Whether to enable executable program coverage Cabal*Whether to enable library program coverage”Cabal/Prefix to be prepended to installed executables¢Cabal.Suffix to be appended to installed executables¤Cabal Extract the Ņ) from the public library component of a }D if it exists, or make a fake component ID based on the package ID.„Cabal Extract the   of a }. This is a "safe" use of Œ¦Cabal Extract the  ." from the library component of a }? if it exists, or make a fake unit ID based on the package ID.§CabalNExtract the compatibility package key from the public library component of a }C if it exists, or make a fake package key based on the package ID.pCabal+Convenience function to generate a default + from a 0. The idea is to call this once, and then use +* everywhere else. Private to this module.ØCabal Return all +s associated with Į[. In the presence of Backpack there may be more than one! Has a prime because it takes a  Å# argument which may disagree with Œ in }.ŖCabal Return all s associated with Į:. In the presence of Backpack there may be more than one!«CabalReturn the list of default +ms associated with a configured package, in the order they need to be built. Has a prime because it takes a  Å# argument which may disagree with Œ in }.¬CabalExecute f for every +w in the package, respecting the build dependency order. (TODO: We should use Shake!) Has a prime because it takes a  Å# argument which may disagree with Œ in }.­Cabal3Return the list of all targets needed to build the uidsG, in the order they need to be built. Has a prime because it takes a  Å# argument which may disagree with Œ in }.®CabalExecute f for every + needed to build uidKs, respecting the build dependency order. Has a prime because it takes a  Å# argument which may disagree with Œ in }.ÆCabalpIs coverage enabled for test suites? In practice, this requires library and executable profiling to be enabled.9}~„Œ£€‚ƒ…†‡ˆ‰Š‹Ž‘’“”•–—˜™š›œžŸ ”¢¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ9}~„Œ£€‚ƒ…†‡ˆ‰Š‹Ž‘’“”•–—˜™š›œžŸ ”¢¤¦§„ŖØ©«¬­®Æ°±²³“µ¬Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone7>SXpY »Cabal#Perform the action on each enabled  Ś& in the package description with the .¼Cabal#Perform the action on each enabled  x3 in the package description. Extended version of  š+ that also gives corresponding build info.½Cabal#Perform the action on each enabled   in the package description.ĮCabal%Perform the action on each buildable  - or  xV (Component) in the PackageDescription, subject to the build order specified by the compBuildOrder field of the given }ĆCabal|Determine the directories containing the dynamic libraries of the transitive dependencies of the component we are building.EWhen wanted, and possible, returns paths relative to the installDirs  ™ÄCabalIGet all module names that needed to be built by GHC; i.e., all of these RGs have interface files associated with them that need to be installed.ÅCabalOBackwards compatibility function which computes the InstallDirs assuming that $libname points to the public library (or some fake package identifier if there is no public library.) IF AT ALL POSSIBLE, please use Ę instead.ĘCabalSee  ­.ČCabalOBackwards compatibility function which computes the InstallDirs assuming that $libname points to the public library (or some fake package identifier if there is no public library.) IF AT ALL POSSIBLE, please use É instead.ÉCabalSee  ®ĆCabalBuilding for inplace?Cabal&Generate prefix-relative library pathsCabalComponent that is being built„;<=>?@ABCDEFGHIJKLMNOPQwxy|ĮĀĆÄÅĘĒÉ ¢ £ ¤ „ ¦ § Ø © Ŗ « ü ż ’  ‘ ’ ” • “ – — ˜ ™ š › œ  ¢ £ ¤ ¦ ž Ÿ   ” „ § Ø © Ŗ « ¬ Æ ° ± ³ “ µ ¶ · ø !"#}~„Œ£€‚ƒ…†‡ˆ‰Š‹Ž‘’“”•–—˜™š›œžŸ ”¢¤¦§ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹ„}~„Œ£€‚ƒ…†‡ˆ‰Š‹Ž‘’“”•–—˜™š›œžŸ ”¢¤¦§ ¢ £ ¤ „ ¦ §ĮĀĆÄÅĘwxy|ĒÉ !"#ŗ Ø « © Ŗ ü ż ’ ĀĆÄĮ»¼½¾æĄ;<=>?@ABCDEFGHIJKLMNOPQ  ‘ ’ ” • “ – — ˜ ™ š › œ  ¢ £ ¤ ¦ ž Ÿ   ” „ § Ø © Ŗ « ¬ Æ ° ± ³ “ µ ¶ · øÅČĒĘÉŹ­None>SX…Ź ŃCabal/Logs test suite results, itemized by test case.ÖCabal\Logs all test results for a package, broken down first by test suite and then by test case.ÜCabalA Ö1 with package and platform information specified.ŻCabal<Count the number of pass, fail, and error test results in a Ė tree.ŽCabalFrom a Ń%, determine if the test suite passed.ßCabalFrom a Ń%, determine if the test suite failed.ąCabalFrom a Ń1, determine if the test suite encountered errors.āCabalˆPrint a summary to the console after all test suites have been run indicating the number of successful test suites and cases. Returns U if all test suites passed and R otherwise.ćCabal~Print a summary of a single test case's result to the console, supressing output for certain verbosity or test filter levels.äCabal|Print a summary of the test suite's results on the console, suppressing output for certain verbosity or test filter levels.ŻCabal)Passes, fails, and errors, respectively.įCabaltest suite nameCabaltest suite resultsĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŪŚÜŻŽßąįāćäåÖ×ŲŁŪŚĖĢĶĪĻŠŃŅÓŌÕŻÜāäåćąßŽį®Duncan Coutts 2009cabal-devel@haskell.orgportableNone>SXˆ¬ļCabalCall ld -r* to link a bunch of object files together.ļļÆDuncan Coutts 2009cabal-devel@haskell.orgportableNone>SX\‘™šCabalCall ar: to create a library archive from a bunch of object files.qCabalarµ by default includes various metadata for each object file in their respective headers, so the output can differ for the same inputs, making it difficult to avoid re-linking. GNU ar(1) has a deterministic mode (-Dr) flag that always writes zero for the mtime, UID and GID, and 0644 for the file mode. However detecting whether -DJ is supported seems rather harder than just re-implementing this feature.½šš½°Thomas Tuegel 2011BSD3cabal-devel@haskell.orgportableNone>SX ¢÷Cabal?Path to the .tix file containing a test suite's sum statistics.łCabalAttempt to guess the way the test suites in this package were compiled and linked with the library so the correct module interfaces are found.śCabal*Generate the HTML markup for a test suite.ūCabal<Generate the HTML markup for all of a package's test suites.rCabal"dist/" prefixCabal/Directory containing component's HPC .mix filesõCabal"dist/" prefixCabalComponent nameCabal,Directory containing test suite's .mix filesöCabal"dist/" prefixCabalComponent nameCabal,Directory containing test suite's .tix files÷Cabal"dist/" prefixCabalComponent nameCabalPath to test suite's .tix fileųCabal"dist/" prefixCabalComponent nameCabal*Path to test suite's HTML markup directoryśCabal"dist/" prefixCabal Library nameūCabal"dist/" prefixCabal Library name ńņóōõö÷ųłśū ńņóōłųõö÷ūś±(c) Duncan Coutts 2012BSD-likeduncan@community.haskell.orgNone7>SXŪ’sCabal‰A matcher embodies a way to match some input as being some recognised value. In particular it deals with multiple and ambiguous matches.&There are various matcher primitives ( matchExactly, t), ways to combine matchers ( ambiguousWith, shadows;) and finally we can run a matcher against an input using u.Cabal expected thing(actually got)Cabal (no such thing, actually got) CabalA fully resolved build target. CabalA specific component Cabal.A specific module within a specific component.Cabal,A specific file within a specific component.Cabal4Various ways that a user may specify a build target.vCabalOA target specified by a single name. This could be a component module or file. Jcabal build foo cabal build Data.Foo cabal build Data/Foo.hs Data/Foo.hscwCabal¬A target specified by a qualifier and name. This could be a component name qualified by the component namespace kind, or a module or file qualified by the component name. Pcabal build lib:foo exe:foo cabal build foo:Data.Foo cabal build foo:Data/Foo.hsxCabalsA fully qualified target, either a module or file qualified by a component name with the component namespace kind. acabal build lib:foo:Data/Foo.hs exe:foo:Data/Foo.hs cabal build lib:foo:Data.Foo exe:foo:Data.FooCabalTake a list of 79 build targets, and parse and validate them into actual + s to be built registered whatever.CabalGRead a list of user-supplied build target strings and resolve them to  s according to a  Åf. If there are problems with any of the targets e.g. they don't exist or are misformatted, throw an  IOException.yCabalreadUserBuildTarget "comp"$Right (UserBuildTargetSingle "comp")readUserBuildTarget "lib:comp"*Right (UserBuildTargetDouble "lib" "comp")"readUserBuildTarget "pkg:lib:comp"0Right (UserBuildTargetTriple "pkg" "lib" "comp")readUserBuildTarget "\"comp\""$Right (UserBuildTargetSingle "comp")"readUserBuildTarget "lib:\"comp\""*Right (UserBuildTargetDouble "lib" "comp")&readUserBuildTarget "pkg:lib:\"comp\""0Right (UserBuildTargetTriple "pkg" "lib" "comp")'readUserBuildTarget "pkg:lib:comp:more"6Left (UserBuildTargetUnrecognised "pkg:lib:comp:more")&readUserBuildTarget "pkg:\"lib\":comp"5Left (UserBuildTargetUnrecognised "pkg:\"lib\":comp")zCabalUnless you use !, this function is PARTIAL; use  instead.CabalUnambiguously render a  ., so that it can be parsed in all situations.CabalRGiven a bunch of user-specified targets, try to resolve what it is they refer to.{CabalœCombine two matchers. Exact matches are used over inexact matches but if we have multiple exact, or inexact then the we collect all the ambiguous matches.|Cabal)Combine two matchers. This is similar to  ambiguousWith“ with the difference that an exact match from the left matcher shadows any exact match on the right. Inexact matches are still collected however.}Cabal)Lift a list of matches to an exact match.~Cabal)Lift a list of matches to an exact match.uCabalfGiven a matcher and a key to look up, use the matcher to find all the possible matches. There may be  , a single € match or you may have an " match with several possibilities.tCabal6A primitive matcher that looks up a value in a finite I¶. It checks for an exact or inexact match. We get an inexact match if the match is not exact, but the canonical forms match. It takes a canonicalisation function for this purpose.æSo for example if we used string case fold as the canonicalisation function, then we would get case insensitive matching (but it will still report an exact match when the case matches too).‚CabalDCheck that the given build targets are valid in the current context.)Also swizzle into a more convenient form.          ²9Isaac Jones 2003-2004, Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone>SXż2CabalmThis is the name of the directory in which the generated haddocks should be stored. It does not include the  distdochtml prefix.3CabalIThe directory to which generated haddock documentation should be written.4CabalYThe directory in which we put auto-generated modules for EVERY component in the package.5CabalQThe directory in which we put auto-generated modules for a particular component.7CabalGThe name of the auto-generated Paths_* module associated with a package=Cabal:The directory where we put build results for an executable>Cabal>The directory where we put build results for a foreign library?CabalHCreate a library name for a static library from a given name. Prepends lib+ and appends the static library extension (.a).BCabalHCreate a library name for a shared library from a given name. Prepends lib and appends the #-<compilerFlavour><compilerVersion>* as well as the shared library extension.ECabal’Create a library name for a bundled shared library from a given name. This matches the naming convention for shared libraries as implemented in GHC's packageHsLibs function in the Packages module. If the given name is prefixed with HS, then this prepends lib¶ and appends the compiler flavour/version and shared library extension e.g.: "HSrts-1.0" -> "libHSrts-1.0-ghc8.7.20190109.so" Otherwise the given name should be prefixed with C, then this strips the C , prepends lib5 and appends the shared library extension e.g.: Cffi -> "libffi.so"FCabalLDefault extension for executable files on the current platform. (typically "" on Unix and "exe" on Windows or OS/2)GCabal5Extension for object files. For GHC the extension is "o".HCabalCExtension for dynamically linked (or shared) libraries (typically "so" on Unix and "dll" on Windows)ICabalExtension for static librariesnTODO: Here, as well as in dllExtension, it's really the target OS that we're interested in, not the build OS.ą0123456789:;<=>?@ABCDEFGHIą021345768?@ABCDEFGHI<9:;=>³Andres Loeh 2009BSD3cabal-devel@haskell.orgportableNone>SXƒCabal'The flags for the supported extensions.„CaballHack to add version numbers to UHC-built-in packages. This should sooner or later be fixed on the UHC side.…Cabal*Name of the installed package config file.†CabalŹCheck if a certain dir contains a valid package. Currently, we are looking only for the presence of an installed package configuration. TODO: Actually make use of the information provided in the file.‡Cabal4Create a trivial package info from a directory name.JKLMNOPJKLMNOP“Lennart Kolmodin 2008BSD3cabal-devel@haskell.orgportableNoneMBQCabalJA record of operations needed to check the contents of packages. Used by a.WCabal-Results of some kind of failed package check.’’There are a range of severities, from merely dubious to totally insane. All of them come with a human readable explanation. In future we may augment them with more machine readable explanations, for example to help an IDE suggest automatic corrections.XCabalThis package description is no good. There's no way it's going to build sensibly. This should give an error at configure time.YCabal¤A problem that is likely to affect building the package, or an issue that we'd like every package author to be aware of, even if the package is never distributed.ZCabal’$An issue that might not be a problem for the package author but might be annoying or detrimental when the package is distributed to users. We should encourage distributed packages to be free from these issues, but occasionally there are justifiable reasons so we cannot ban them entirely.[CabalxLike PackageDistSuspicious but will only display warnings rather than causing abnormal exit when you run 'cabal check'.\CabalŅAn issue that is OK in the author's environment but is almost certain to be a portability problem for other environments. We can quite legitimately refuse to publicly distribute packages with these problems.^Cabal?Check for common mistakes and problems in package descriptions.“This is the standard collection of checks covering all aspects except for checks that require looking at files within the package. For those see `.It requires the  I and optionally a particular configuration of that package. If you pass S@ then we just check a version of the generic description using u.ˆCabal,Check that this package description is sane.‰Cabal„Checks GHC options from all ghc-*-options fields in the given PackageDescription and reports commonly misused or non-portable flagsŠCabal„Extracts GHC options belonging to the given field from the given PackageDescription using given function and checks them for commonly misused or non-portable flags‹Cabal3Check that the package declares the version in the "cabal-version" field correctly.ŒCabalACheck the build-depends fields for any weirdness or bad practise.CabalFcabal-version <2.2 + Paths_module + default-extensions: doesn't build.ŽCabal³Checks GHC options from all ghc-*-options fields from the given BuildInfo and reports flags that are OK during development process, but are unacceptable in a distrubuted packageCabal„Checks the given list of flags belonging to the given field and reports flags that are OK during development process, but are unacceptable in a distributed package`CabalSanity check things that requires IO. It looks at the files in the package and expects to find the package unpacked in at the given file path.aCabaleSanity check things that requires looking at files in the package. This is a generalised version of `7 that can work in any monad for which you can provide Q operations.zThe point of this extra generality is to allow doing checks in some virtual file system, for example a tarball in memory.CabalDFind a package description file in the given directory. Looks for .cabal files. Like  , but generalized over monads.bCabal“Check the names of all files in a package for portability problems. This should be done for example when creating or validating a package tarball.‘Cabal=Check a file name is valid for the portable POSIX tar format.’vThe POSIX tar format has a restriction on the length of file names. It is unfortunately not a simple restriction like a maximum length. The exact restriction is that either the whole path be 100 characters or less, or it be possible to split the path on a directory separator such that the first part is 155 characters or less and the second part 100 characters or less.’Cabal Similar to a, ’Ę inspects the files included in the package, but is primarily looking for files in the working tree that may have been missed or other similar problems that can only be detected pre-distribution.īBecause Hackage necessarily checks the uploaded tarball, it is too late to check these on the server; these checks only make sense in the development and package-creation environment. Hence we can use IO, rather than needing to pass a Q dictionary around.“Cabal/Discover problems with the package's wildcards.Cabal pkgname.cabalQRUTSVWXYZ[\]^_`abWXYZ[\]^_`aQRUTSVbµbIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008cabal-devel@haskell.orgportableNoneU¶gCabal[Generates the name of the environment variable controlling the path component of interest.‡Note: The format of these strings is part of Cabal's public API; changing this function constitutes a *backwards-compatibility* break.gCabalTpath component; one of "bindir", "libdir", "datadir", "libexecdir", or "sysconfdir"Cabalenvironment variable namefgfg¶None>SXiiCabal:The name of the stub executable associated with a library  TestSuite.jCabalSThe filename of the source file for the stub executable associated with a library  TestSuite.kCabal$Write the source file for a library  TestSuite stub executable.lCabal2Source code for library test suite stub executablemCabalÅMain function for test stubs. Once, it was written directly into the stub, but minimizing the amount of code actually in the stub maximizes the number of detectable errors when Cabal is compiled.”Cabal The test runner used in library  TestSuite$ stub executables. Runs a list of lgs. An executable calling this function is meant to be invoked as the child of a Cabal process during  ./setup test. A Ń’ , provided by Cabal, is read from the standard input; it supplies the name of the test suite and the location of the machine-readable test suite log file. Human-readable log information is written to the standard output for capture by the calling Cabal process.nCabalFrom a test stub, write the Ń: to temporary file for the calling Cabal process to read.kCaballibrary  TestSuite# for which a stub is being createdCabal6path to directory where stub source should be locatedhijklmnhljmink·None>SXiooøSimon Marlow 2008cabal-devel@haskell.orgportableNonet„pCabalThe contents of the cabal_macros.h" for the given configured package.qCabal(Helper function that generates just the  VERSION_pkg and MIN_VERSION_pkgb macros for a list of package ids (usually used with the specific deps of a configured package).•Cabal(Helper function that generates just the TOOL_VERSION_pkg and MIN_TOOL_VERSION_pkg* macros for a list of configured programs.–CabalCommon implementation of q and •.—Cabal Generate the CURRENT_COMPONENT_ID; definition for the component ID of the current package.˜Cabal Generate the CURRENT_PACKAGE_VERSION? definition for the declared version of the current package.pqpqNone=?SX–±rCabal.This method computes a default, "good enough" Ņl for a package. The intent is that cabal-install (or the user) will specify a more detailed IPID via the --ipid flag if necessary.sCabalųIn GHC 8.0, the string we pass to GHC to use for symbol names for a package can be an arbitrary, IPID-compatible string. However, prior to GHC 8.0 there are some restrictions on what format this string can be (due to how ghc-pkg parsed the key): ŲIn GHC 7.10, the string had either be of the form foo_ABCD, where foo is a non-semantic alphanumeric/hyphenated prefix and ABCD is two base-64 encoded 64-bit integers, or a GHC 7.8 style identifier.OIn GHC 7.8, the string had to be a valid package identifier like foo-0.1.’ÓSo, the problem is that Cabal, in general, has a general IPID, but needs to figure out a package key / package ID that the old ghc-pkg will actually accept. But there's an EVERY WORSE problem: if ghc-pkg decides to parse an identifier foo-0.1-xxx as if it were a package identifier, which means it will SILENTLY DROP the "xxx" (because it's a tag, and Cabal does not allow tags.) So we must CONNIVE to ensure that we don't pick something that looks like this.CSo this function attempts to define a mapping into the old formats.#The mapping for GHC 7.8 and before:ÓWe use the *compatibility* package name and version. For public libraries this is just the package identifier; for internal libraries, it's something like "z-pkgname-z-libname-0.1". See computeCompatPackageName for more details.The mapping for GHC 7.10:‹For CLibName: If the IPID is of the form foo-0.1-ABCDEF where foo_ABCDEF would validly parse as a package key, we pass ABCDEFĄ. (NB: not all hashes parse this way, because GHC 7.10 mandated that these hashes be two base-62 encoded 64 bit integers), but hashes that Cabal generated using r, are guaranteed to have this form.RIf it is not of this form, we rehash the IPID into the correct form and pass that.UFor sub-components, we rehash the IPID into the correct format and pass that.rsŗNone²< uCabal1A configured component, we know exactly what its Ņ is, and the Ņs of the things it depends on.wCabal7Unique identifier of component, plus extra useful info.xCabalFThe fragment of syntax from the Cabal file describing this component.yCabal’Is this the public library component of the package? (If we invoke Setup with an instantiation, this is the component the instantiation applies to.) Note that in one-component configure mode, this is always True, because any component is the "public" one.)zCabal!Dependencies on executables from  build-tools and build-tool-depends.{Cabal?The mixins of this package, including both explicit (from the mixins field) and implicit (from  build-dependsC). Not mix-in linked yet; component configuration only looks at Ņs.|Cabal+Uniquely identifies a configured component.}Cabal%The package this component came from.~CabalThe Įx of a component; this uniquely identifies a fragment of syntax within a specified Cabal file describing the component.CabalPretty-print a u.™Cabal Construct a u, given that the Ņc and library/executable dependencies are known. The primary work this does is handling implicit backpack-include fields.šCabalAlso computes the ŅU, and sets cc_public if necessary. This is Cabal-only; cabal-install won't use this.›Cabal'build-depends:'’” stanzas are currently ambiguous as the external packages and internal libraries are specified the same. For now, we assume internal libraries shadow, and this function disambiguates accordingly, but soon the underlying ambiguity will be addressed. Multiple public libraries (cabal 3.0) added an unambiguous way of specifying sublibraries, but we still have to support the old syntax for bc reasons.tuvwxyz{|}~€‚ƒuvwxyz{~|}€‚tƒ»None¼6„CabalQA list of components associated with the source level dependencies between them.…CabalFA graph of source-level components by their source-level dependencies†Cabal Pretty-print „.‡Cabal Create a ŗ of  ¢+, or report a cycle if there is a problem.ˆCabal$Given the package description and a  ÅŁ (used to determine if a package name is internal or not), sort the components in dependency order (fewest dependencies first). This is NOT necessarily the build order (although it is in the absence of Backpack.)‰CabalAError message when there is a cycle; takes the SCC of components.„…†‡ˆ‰…„‡ˆ†‰¼None>SX¾/’Cabalinstall locationCabal&install location for dynamic librariesCabalBuild location Š‹ŒŽ‘’“”• Š‹ŒŽ‘’“”•Isaac Jones 2003-2007cabal-devel@haskell.orgportableNone>SXÖŲ–Cabal'The kinds of entries we can stick in a .ghc.environment file.—Cabal  -- a comment˜Cabal package-id foo-1.0-4fe301a...™Cabalglobal-package-db, user-package-db or package-db blahpackage.conf.dšCabal clear-package-dbœCabal/Adjust the way we find and configure gcc and ldCabal.Strip out flags that are not supported in ghcižCabal&GHC's rendering of its host or target  ` as used in its platform strings and certain file locations (such as user package db location).ŸCabal&GHC's rendering of its host or target  ` as used in its platform strings and certain file locations (such as user package db location).›CabalGHC's rendering of its platform and compiler version string as used in certain file locations (such as user package db location). For example x86_64-linux-7.10.4œCabal3Make entries for a GHC environment file based on a ķ$ and a bunch of package (unit) ids.‰If you need to do anything more complicated then either use this as a basis and add more entries, or just make all the entries directly.CabalWrite a .ghc.environment-$arch-$os-$ver file in the given directory.The  and GHC M% are needed as part of the file name.%Returns the name of the file written. CabalThe .ghc.environment-$arch-$os-$ver file namežCabal.Render a bunch of GHC environment file entries”Cabal/Render an individual GHC environment file entryCabaldirectory in which to put itCabalthe GHC target platformCabalthe GHC versionCabal the content –—˜™š¢œ£¤„¦§Ø©Ŗ«¬­®Æ°±²žŸ›œ ž”None"#2>MSX_×ĻŸ ”¢‘None>PSX˜³CabalhA collection of: * C input files * C++ input files * GHC input files * GHC input modules)Used to correctly build and link sources.“CabalsBuilding an executable, starting the REPL, and building foreign libraries are all very similar and implemented in µ. The “6 distinguishes between the various kinds of operation.„Cabal9Given a single package DB, return all installed packages.¦Cabal8Given a package DB stack, return all installed packages.ØCabal Return the q$ to the global GHC package database.¶Cabal Return the q& to the per-user GHC package database.©Cabal:Get the packages from specific PackageDBs, not cumulative.¬Cabal.Start a REPL without loading any source files.­CabalBuild a foreign libraryÆCabalBuild an executable with GHC.·Cabal8Target name for a foreign library (the actual file name)ÅWe do not use mkLibName and co here because the naming for foreign libraries is slightly different (we don't use "_p" or compiler version suffices, and we don't want the "lib" prefix on Windows).TODO: We do use H» and co here, but really that's wrong: they use the OS used to build cabal to determine which extension to use, rather than the target OS (but this is wrong elsewhere in Cabal as well).øCabal#Name for the library when building.If the `lib-version-info` field or the `lib-version-linux`g field of a foreign library target is set, we need to incorporate that version into the SONAME field.’©If a foreign library foo has lib-version-info 5:1:2, it should be built as libfoo.so.3.2.1. We want it to get soname libfoo.so.3. However, GHC does not allow overriding soname by setting linker options, as it sets a soname of its own (namely the output filename), after the user-supplied linker options. Hence, we have to compile the library with the soname as its filename. We rename the compiled binary afterwards.lThis method allows to adjust the name of the library at build time such that the correct soname can be set.¹CabalMain module name when overridden by ghc-options: -main-is ... or S if no -main-is flag could be found. In case of S, K can be assumed.ŗCabalDecode argument to  '-main-is'Returns S( if argument set only the function name.ÅThis code has been stolen/refactored from GHC's DynFlags.setMainIs function. The logic here is deliberately imperfect as it is intended to be bug-compatible with GHC's parser. See discussion in  @https://github.com/haskell/cabal/pull/4539#discussion_r118981753.»CabalLocate and return the ³ required to build and link.µCabal(Generic build function. See comment for “.¼Cabal Do we need the RPATH workaround?See Note [RPATH].½Cabal7Extract (and compute) information about the RTS library!TODO: This hardcodes the name as  HSrts-ghc versionM. I don't know if we can find this information somewhere. We can lookup the  hsLibraries field of  K but it will tell us [HSrts, Cffi], which doesn't really help.¾Cabal—Returns True if the modification date of the given source file is newer than the object file we last compiled for it, or if no object file exists yet.æCabal3Finds the object file name of the given source fileĄCabal7Calculate the RPATHs for the component we are building. Calculates relative RPATHs when £ is set.ĮCabal‚Remove the "-threaded" flag when building a foreign library, as it has no effect when used with "-shared". Returns the updated  ¦x, along with whether or not the flag was present, so we can use it to link against the appropriate RTS on our own.±CabalyExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built.“CabalInstall executables for GHCJS.µCabal Install foreign library for GHC.¶Cabal6Install for ghc, .hi, .a and, if --with-ghci given, .o»CabalGet the JavaScript file name and command and arguments to run a program compiled by GHCJS the exe should be the base program name without exe extension»Cabal specVersionĄCabalComponent we are building“CabalWhere to copy the files toCabalBuild locationCabalExecutable (prefix,suffix)µCabalinstall locationCabalBuild location¶Cabalinstall locationCabal&install location for dynamic librariesCabalBuild location36789:;<=>?@AB–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»3¤£¦©„Ŗ­Æ«®°¬¶µ“±ø¹²³§·Øŗ»–—˜™šœž›¢”Ÿ B6789:;<=>?@A½Isaac Jones 2003-2007BSD3cabal-devel@haskell.orgportableNone>PSX`q ĀCabalhA collection of: * C input files * C++ input files * GHC input files * GHC input modules)Used to correctly build and link sources.ĆCabalsBuilding an executable, starting the REPL, and building foreign libraries are all very similar and implemented in Ä. The Ć6 distinguishes between the various kinds of operation.ÅCabalGiven something like usrlocalbin¦ghc-6.6.1(.exe) we try and find the corresponding tool; e.g. if the tool is ghc-pkg, we try looking for a versioned or unversioned ghc-pkg in the same dir, that is: f/usr/local/bin/ghc-pkg-ghc-6.6.1(.exe) /usr/local/bin/ghc-pkg-6.6.1(.exe) /usr/local/bin/ghc-pkg(.exe)ĘCabalGiven something like usrlocalbinghc-6.6.1(.exe) we try and find a corresponding ghc-pkg, we try looking for both a versioned and unversioned ghc-pkg in the same dir, that is: f/usr/local/bin/ghc-pkg-ghc-6.6.1(.exe) /usr/local/bin/ghc-pkg-6.6.1(.exe) /usr/local/bin/ghc-pkg(.exe)ĒCabalGiven something like usrlocalbinŽghc-6.6.1(.exe) we try and find a corresponding hsc2hs, we try looking for both a versioned and unversioned hsc2hs in the same dir, that is: c/usr/local/bin/hsc2hs-ghc-6.6.1(.exe) /usr/local/bin/hsc2hs-6.6.1(.exe) /usr/local/bin/hsc2hs(.exe)ČCabalGiven something like usrlocalbinghc-6.6.1(.exe) we try and find a corresponding haddock, we try looking for both a versioned and unversioned haddock in the same dir, that is: f/usr/local/bin/haddock-ghc-6.6.1(.exe) /usr/local/bin/haddock-6.6.1(.exe) /usr/local/bin/haddock(.exe)¾Cabal9Given a single package DB, return all installed packages.æCabal8Given a package DB stack, return all installed packages.ÉCabalGiven a list of !(PackageDB, InstalledPackageInfo) pairs, produce a  PackageIndex. Helper function used by ¾ and æ.ĮCabal Return the q$ to the global GHC package database.ŹCabal Return the q& to the per-user GHC package database.ĖCabal:Get the packages from specific PackageDBs, not cumulative.ÅCabal.Start a REPL without loading any source files.ĘCabalBuild a foreign libraryČCabalBuild an executable with GHC.ĢCabal8Target name for a foreign library (the actual file name)ÅWe do not use mkLibName and co here because the naming for foreign libraries is slightly different (we don't use "_p" or compiler version suffices, and we don't want the "lib" prefix on Windows).TODO: We do use H» and co here, but really that's wrong: they use the OS used to build cabal to determine which extension to use, rather than the target OS (but this is wrong elsewhere in Cabal as well).ĶCabal#Name for the library when building.If the `lib-version-info` field or the `lib-version-linux`g field of a foreign library target is set, we need to incorporate that version into the SONAME field.’©If a foreign library foo has lib-version-info 5:1:2, it should be built as libfoo.so.3.2.1. We want it to get soname libfoo.so.3. However, GHC does not allow overriding soname by setting linker options, as it sets a soname of its own (namely the output filename), after the user-supplied linker options. Hence, we have to compile the library with the soname as its filename. We rename the compiled binary afterwards.lThis method allows to adjust the name of the library at build time such that the correct soname can be set.ĪCabalMain module name when overridden by ghc-options: -main-is ... or S if no -main-is flag could be found. In case of S, K can be assumed.ĻCabalDecode argument to  '-main-is'Returns S( if argument set only the function name.ÅThis code has been stolen/refactored from GHC's DynFlags.setMainIs function. The logic here is deliberately imperfect as it is intended to be bug-compatible with GHC's parser. See discussion in  @https://github.com/haskell/cabal/pull/4539#discussion_r118981753.ŠCabalLocate and return the Ā required to build and link.ÄCabal(Generic build function. See comment for Ć.ŃCabal Do we need the RPATH workaround?See Note [RPATH].ŅCabal7Extract (and compute) information about the RTS library!TODO: This hardcodes the name as  HSrts-ghc versionM. I don't know if we can find this information somewhere. We can lookup the  hsLibraries field of  K but it will tell us [HSrts, Cffi], which doesn't really help.ÓCabal—Returns True if the modification date of the given source file is newer than the object file we last compiled for it, or if no object file exists yet.ŌCabal3Finds the object file name of the given source fileÕCabal7Calculate the RPATHs for the component we are building. Calculates relative RPATHs when £ is set.ÖCabal‚Remove the "-threaded" flag when building a foreign library, as it has no effect when used with "-shared". Returns the updated  ¦x, along with whether or not the flag was present, so we can use it to link against the appropriate RTS on our own.ŹCabalyExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built.ĶCabalInstall executables for GHC.ĪCabal Install foreign library for GHC.ĻCabal6Install for ghc, .hi, .a and, if --with-ghci given, .oŠCabal specVersionÕCabalComponent we are buildingĶCabalWhere to copy the files toCabalBuild locationCabalExecutable (prefix,suffix)ĪCabalinstall locationCabalBuild locationĻCabalinstall locationCabal&install location for dynamic librariesCabalBuild location26789:;<=>?@AB–—˜™š›œžŸ ”¢¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓ2½¼æĀ¾ĆĘČÄĒÉÅĻĪĶŹŠŃĖĢĄÓĮŅ–—˜™šœž›¢”Ÿ B6789:;<=>?@A¾NonexIŌCabalJConstruct a JSON document describing the build information for a package.×CabalbGet the command-line arguments that would be passed to the compiler to build the given component.ŌCabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildŌŌæIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone>SXyÕCabal Perform the "./setup install" and " ./setup copy@" actions. Move files into place based on the prefix argument.2This does NOT register libraries, you should call register to do that.ŲCabalCopy package global files.ŁCabal'Copy files associated with a component.ŚCabal&Install the files listed in data-filesŪCabal:Install the files listed in install-includes for a libraryÕCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to copy or installÕÕĄNone7„~ÖCabalA ÖL describes the provisions and requirements of a library. We can extract a Ö from an  K.ŚCabalAThe default module shape, with no provisions and no requirements.Ö×ŲŁŚŪÖ×ŲŁŚŪNoneSX¦Ń ÜCabalThe mutable counterpart of  ŻCabalThe mutable counterpart of  .ŽCabalThe mutable counterpart of a  ModuleSubst (not defined here).ßCabal!An integer for uniquely labeling ąA nodes. We need these labels in order to efficiently serialize ąs into  .™s (we use the label to check if any parent is the node in question, and if so insert a deBruijn index instead.) These labels must be unique across all 'UnitId's/'Module'$s which participate in unification!įCabalA mutable version of  .# which can be imperatively unified.āCabalA mutable version of  J# which can be imperatively unified.ąCabalContents of a mutable ą reference.ćCabalContents of a mutable ć reference.äCabalCA convenient alias for mutable references in the unification monad.åCabalThe unification environment.ęCabal%A supply of unique integers to label ąh cells. This is used to determine loops in unit identifiers (which can happen with mutual recursion.)ēCabal±The set of requirements in scope. When a provision is brought into scope, we unify with the requirement at the same module name to fill it. This mapping grows monotonically.čCabal¶Component id of the unit we're linking. We use this to detect if we fill a requirement with a local module, which in principle should be OK but is not currently supported by GHC.éCabal'How verbose the error message should beźCabalThe error reporting contextėCabal0The package index for expanding unit identifiersģCabalAccumulated errorsķCabalGThe unification monad, this monad encapsulates imperative unification.īCabal+Run a computation in the unification monad.ļCabalLift a computation from š monad to ķ monad. Internal use only.ńCabalImperatively read a ä.ņCabalImperatively write a ä.óCabal(Get the current unification environment.ōCabal)Add a fixed message to the error context.õCabalAAdd a message to the error context. It may make monadic queries.öCabalConversion of  ModuleSubst to Ž÷CabalConversion of Ž to  ModuleSubstųCabal An empty Ż.łCabal Convert a Ö into a Ż", so we can do unification on it.śCabal Convert a Ż to a  .ūCabal Convert a   to a ÜüCabal Convert a Ü to a  )żŻŽįāąž’ćåęēčéźėģķīļóōõö÷  ųłśūüNone\¬j CabalCGiven to scopes of provisions and requirements, link them together. CabalµLink a list of possibly provided modules to a single requirement. This applies a side-condition that all of the provided modules at the same name are *actually* the same module. CabalImperatively unify two modules. ĮNone27¬µįāćäåęēįāćäåęēNone“ÕCabalStripped down version of LinkedComponent0 for things we don't need to know how to build.Cabal7The actual name of the package. This may DISAGREE with pc_pkgid9 for internal dependencies: e.g., an internal component lib may be munged to  z-pkg-z-lib+, but we still want to use it when we see lib in  build-dependsCabal!The actual name of the component.Cabal Convert an  K into a *, which was brought into scope under the >0 (important for a package qualified reference.) ĀNoneHVXČ’ ģCabalŹA linked component is a component that has been mix-in linked, at which point we have determined how all the dependencies of the component are explicitly instantiated (in the form of an OpenUnitId). u is mix-in linked into ģ#, which is then instantiated into ReadyComponent.īCabal$Uniquely identifies linked componentļCabalCorresponds to x.šCabal build-tools and build-tool-depends dependencies. Corresponds to z.ńCabal:Is this the public library of a package? Corresponds to y.ņCabalCorresponds to {i, but (1) this does not contain includes of signature packages (packages with no exports), and (2) the l for requirements (stored in }+) has been removed, as it is reflected in  Z.)óCabalLike ņK, but this specifies includes on signature packages which have no exports.ōCabalKThe module shape computed by mix-in linking. This is newly computed from uõCabalUniquely identifies a ģ. Corresponds to |.öCabalCorresponds to }.÷CabalThe  Z= of this component in the "default" instantiation. See also ų. ģ-s cannot be instantiated (e.g., there is no ModSubst instance for them).ųCabalThe instantiation of ÷I; this always has the invariant that it is a mapping from a module name A to  A (the hole A).ėģķīļšńņóōõö÷ųłśūüģķīļšńņóōų÷õöśūłėüĆNone>MSX×pžCabal‡An opaque type representing a file's modification time, represented internally as a 64-bit unsigned integer in the Windows UTC format.Cabal`Return modification time of the given file. Works around the low clock resolution problem that  has on GHC < 7.8.}This is a modified version of the code originally written for Shake by Neil Mitchell. See module Development.Shake.FileInfo.Cabal!Convert POSIX seconds to ModTime.CabalConvert  to ž.Cabal!Return age of given file in days.CabalReturn the current time as ž.Cabal7Based on code written by Neil Mitchell for Shake. See sleepFileTimeCalibrate in é. Returns a pair of microsecond values: first, the maximum delay seen, and the recommended delay to use before testing for file modification change. The returned delay is never smaller than 10 ms, but never larger than 1 second.ž’ž’NoneHVĘCabalkA state monad for doing instantiations (can't use actual State because that would be an extra dependency.)Cabal The state of ; a mapping from  . s to their ready component, or Nothing@ if its an external component which we don't know how to build.CabalAn > is a library with requirements which we will typecheck only.Cabal The requirements of the library.Cabal0The modules exported/reexported by this library. CabalbThe dependencies which need to be passed to the compiler to bring modules into scope. These are  Z> because these may refer to partially instantiated libraries.!CabalAn !V is a library which is fully instantiated (or, possibly, has no requirements at all.)"Cabal"How this library was instantiated.#CabalDependencies induced by "W. These are recorded here because there isn't a convenient way otherwise to get the  ! we need to fill componentPackageDeps as needed.$Cabal0The modules exported/reexported by this library.%Cabal–The dependencies which need to be passed to the compiler to bring modules into scope. These always refer to installed fully instantiated libraries.&CabalA &é is one that we can actually generate build products for. We have a ready component for the typecheck-only products of every indefinite package, as well as a ready component for every way these packages can be fully instantiated.'CabalThe  Z· for this package. At the moment, this is used in only one case, which is to determine if an export is of a module from this library (indefinite libraries record these exports as  W); '9 can be conveniently used to test for equality, whereas  .% cannot always be used in this case.(CabalCorresponds to õ. Invariant: if ' records a Ņ, it coincides with this one.)CabalCorresponds to ļ.*CabalCorresponds to šN. Build-tools don't participate in mix-in linking. (but what if they could?)+CabalCorresponds to ń.,CabalExtra metadata depending on whether or not this is an indefinite library (typechecked only) or an instantiated component (can be compiled).-CabalThe final, string  .I that will uniquely identify the compilation products of this component..CabalCorresponds to ö./CabalCompute the dependencies of a &! that should be recorded in the depends field of InstalledPackageInfo.0CabalGet the  œ of a & IF it is a library.1CabalGiven a list of ģ‚s, expand the module graph so that we have an instantiated graph containing all of the instantiated components we need to build.:Instantiation intuitively follows the following algorithm:Łinstantiate a definite unit id p[S]: recursively instantiate each module M in S recursively instantiate modules exported by this unit recursively instantiate dependencies substituted by S_The implementation is a bit more involved to memoize instantiation if we have done it already. We also call  improveUnitIdG during this process, so that fully instantiated components are given  HashedUnitId.2 !3"#$%&45'()*+,-./61ÄNone "#2HVX\±  ÅNone>SX 1 CabalšPrint a Setup message stating (1) what operation we are doing, for (2) which component (with enough details to uniquely identify the build in question.) Cabal'Operation being done (capitalized), on:CabalPackageCabalComponent nameCabal3Instantiation, if available. Polymorphic to take  OpenModule or Module  ĘIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone>SXeCabal Compute the ł$ of a library that we built inplace.Cabal5Create an empty package DB at the specified location.CabalRun hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it.Cabal Construct  KF for a library in a package, given a set of installation directories.Cabal Construct  K3 for a library that is in place in the build tree.:This function knows about the layout of in place packages.Cabal Construct  K6 for the final install location of a library package.;This function knows about the layout of installed packages. Cabal(Install in the user's database?; verboseCabal8Translate relative include dir paths to absolute paths.Cabaltop of the build treeCaballocation of the dist tree01234B  01234BĒ+(c) 2003-2005, Isaac Jones, Malcolm WallaceBSD3cabal-devel@haskell.orgportableNone>SXN> CabalgA preprocessor for turning non-Haskell files with the given extension into plain Haskell source files.7CabalA newtype around 8, useful for storing 8] inside of another type constructor (e.g., a list) without impredicativity (recall that the Œ type, which is contained in 8, is a synonym for  HasCallStack => Prelude.IO , which is a polymorphic type).8CabalÜFunction to determine paths to possible extra C sources for a preprocessor: just takes the path to the build directory and uses this to search for C sources with names that match the preprocessor's output name format.Cabal’The interface to a preprocessor, which may be implemented using an external program, but need not be. The arguments are the name of the input file, the name of the output file and a verbosity level. Here is a simple example that merely prepends a comment to the given source file: ’tppTestHandler :: PreProcessor ppTestHandler = PreProcessor { platformIndependent = True, runPreProcessor = mkSimplePreProcessor $ \inFile outFile verbosity -> do info verbosity (inFile++" has been preprocessed to "++outFile) stuff <- readFile inFile writeFile outFile ("-- preprocessed as a test\n\n" ++ stuff) return ExitSuccess’ We split the input and output file names into a base directory and the rest of the file name. The input base dir is the path in the list of search dirs that this file was found in. The output base dir is the build dir where all the generated source files are put.’(The reason for splitting it up this way is that some pre-processors don't simply generate one output .hs file from one input file but have dependencies on other generated files (notably c2hs, where building one .hs file may require reading other .chi files, and then compiling the .hs file may require reading a generated .h file). In these cases the generated files need to embed relative path names to each other (eg the generated .hs file mentions the .h file in the FFI imports). This path must be relative to the base directory where the generated files are located, it cannot be relative to the top level of the build tree because the compilers do not look for .h files relative to there, ie we do not use "-I .", instead we use "-I dist/build" (or whatever dist dir has been set by the user)Most pre-processors do not care of course, so mkSimplePreProcessor and runSimplePreProcessor functions handle the simple case."Cabal(Apply preprocessors to the sources from  ¹2 for a given component (lib, exe, or test suite).9CabalQFind the first extension of the file that exists, and preprocess it if required.,Cabal>Convenience function; get the suffixes of these preprocessors.-CabalGStandard preprocessors: GreenCard, c2hs, hsc2hs, happy, alex and cpphs.:CabalCStandard preprocessors with possible extra C sources: c2hs, hsc2hs..CabalsFind any extra C sources generated by preprocessing that need to be added to the component (addresses issue #238).9Cabalsource directoriesCabalbuild directoryCabalpreprocess for sdistCabalmodule file nameCabal verbosityCabalbuiltin suffixesCabalpossible preprocessors !"#$%&'()*+,-.".-, !%&#('*+$)ČIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone>SX“,/CabalƒHooks allow authors to add specific functionality before and after a command is run, and also to specify additional preprocessors.©WARNING: The hooks interface is under rather constant flux as we try to understand users needs. Setup files that depend on this interface may break in future releases.1CabalRead the description file2Cabal3Custom preprocessors in addition to and overriding -.3CabalgThese programs are detected at configure time. Arguments for them are added to the configure command.4Cabal$Hook to run before configure command5Cabal?Over-ride this hook to get different behavior during configure.6Cabal#Hook to run after configure command7CabalHHook to run before build command. Second arg indicates verbosity level.8Cabal;Over-ride this hook to get different behavior during build.9CabalGHook to run after build command. Second arg indicates verbosity level.:CabalGHook to run before repl command. Second arg indicates verbosity level.;CabalDOver-ride this hook to get different behavior during interpretation.<CabalFHook to run after repl command. Second arg indicates verbosity level.=CabalHHook to run before clean command. Second arg indicates verbosity level.>Cabal;Over-ride this hook to get different behavior during clean.?CabalGHook to run after clean command. Second arg indicates verbosity level.@CabalHook to run before copy commandACabal:Over-ride this hook to get different behavior during copy.BCabalHook to run after copy commandCCabal"Hook to run before install commandDCabal=Over-ride this hook to get different behavior during install.ECabaldHook to run after install command. postInst should be run on the target, not on the build machine.FCabal#Hook to run before register commandGCabalBOver-ride this hook to get different behavior during registration.HCabal"Hook to run after register commandICabal%Hook to run before unregister commandJCabalDOver-ride this hook to get different behavior during unregistration.KCabal$Hook to run after unregister commandLCabalKHook to run before hscolour command. Second arg indicates verbosity level.MCabal>Over-ride this hook to get different behavior during hscolour.NCabalJHook to run after hscolour command. Second arg indicates verbosity level.OCabalJHook to run before doctest command. Second arg indicates verbosity level.PCabal=Over-ride this hook to get different behavior during doctest.QCabalIHook to run after doctest command. Second arg indicates verbosity level.RCabalJHook to run before haddock command. Second arg indicates verbosity level.SCabal=Over-ride this hook to get different behavior during haddock.TCabalIHook to run after haddock command. Second arg indicates verbosity level.UCabal Hook to run before test command.VCabal:Over-ride this hook to get different behavior during test.WCabalHook to run after test command.XCabal!Hook to run before bench command.YCabal;Over-ride this hook to get different behavior during bench.ZCabal Hook to run after bench command.\CabalEmpty / which do nothing../0512346789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\./0512346789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ÉThomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone>SX…\]Cabal Perform the " ./setup test " action.]Cabal!positional command-line argumentsCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to test]]ŹJohan Tibell 2011BSD3cabal-devel@haskell.orgportableNone>SX‰°^Cabal Perform the " ./setup bench " action.^Cabal!positional command-line argumentsCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to benchmark^^¹Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone"#2>SX÷„+;Cabal}An external dependency from the package database, OR an internal dependency which we are getting from the package database.<CabalAn internal dependency ( !H should be a library name) which we are going to have to build. (The  !C here is a hack to get a modest amount of polymorphism out of the   typeclass.)_Cabal/The errors that can be thrown when reading the  setup-config file.`CabalNo header found.aCabalIncorrect header.bCabalCannot parse file contents.cCabalNo file!dCabalMismatched version.=Cabal Format a _ as a user-facing error message.eCabal Read the l„. Throw an exception if the file is missing, if the file cannot be read, or if the file was created by an older version of Cabal.fCabal Read the l5, returning either an error or the local build info.gCabalTry to read the l.hCabal Read the lƒ. Throw an exception if the file is missing, if the file cannot be read, or if the file was created by an older version of Cabal.iCabalTry to read the l.jCabal$After running configure, output the } to the l.>Cabal(Identifier of the current Cabal package.?Cabal+Identifier of the current compiler package.@Cabal Parse the  setup-configL file header, returning the package identifiers for Cabal and the compiler.ACabal Generate the  setup-config file header.kCabalMCheck that localBuildInfoFile is up-to-date with respect to the .cabal file.lCabalGet the path of dist/setup-config.mCabalĪReturn the "dist/" prefix, or the default prefix. The prefix is taken from (in order of highest to lowest preference) the override prefix, the "CABAL_BUILDDIR" environment variable, or the default prefix.nCabal»Return the "dist/" prefix, or the default prefix. The prefix is taken from (in order of highest to lowest preference) the override prefix, the "CABAL_BUILDDIR" environment variable, or ą+ is used. Call this function to resolve a  *DistPref0 flag whenever it is not known to be set. (The  *DistPref; flags are always set to a definite value before invoking  UserHooks.)oCabal Perform the "./setup configure" action. Returns the  .setup-config file.BCabal,Check if the user used any deprecated flags.CCabalSanity check: if '--exact-configuration'X was given, ensure that the complete flag assignment was specified on the command line.pCabalÄCreate a PackageIndex that makes *any libraries that might be* defined internally to this package look like installed packages, in case an executable should refer to any of them as dependencies.’It must be *any libraries that might be* defined rather than the actual definitions, because these depend on conditionals in the .cabal file, and we haven't resolved them yet. finalizePD does the resolution of conditionals, and it takes internalPackageSet as part of its input.DCabal®Returns true if a dependency is satisfiable. This function may report a dependency satisfiable even when it is not, but not vice versa. This is to be passed to finalizePD.ECabal;Finalize a generic package description. The workhorse is t7 but there's a bit of other nattering about necessary.(TODO: what exactly is the business with  flaggedTests and flaggedBenchmarks?FCabal>Check for use of Cabal features which require compiler supportGCabal$Select dependencies for the package.HCabal?Select and apply coverage settings for the build based on the ¤ and ņ.qCabal4Compute the effective value of the profiling flags --enable-library-profiling and --enable-executable-profiling from the specified ¤Ō. This may be useful for external Cabal tools which need to interact with Setup in a backwards-compatible way: the most predictable mechanism for enabling profiling across many legacy versions is to NOT use --enable-profiling! and use those two flags instead. Note that --enable-executable-profilingF also affects profiling of benchmarks and (non-detailed) test suites.ICabal@Select and apply profiling settings for the build based on the ¤ and ņ.JCabalGTest for a package dependency and record the version we have installed.rCabalåList all installed packages in the given package databases. Non-existent package databases do not cause errors, they just get skipped with a warning and treated as empty ones, since technically they do not contain any package.sCabalLike r, but for a single package DB.,NB: Why isn't this always a fall through to r? That is because r– performs some sanity checks on the package database stack in question. However, when sandboxes are involved these sanity checks are not desirable.tCabalA set of files (or directories) that can be monitored to detect when there might have been a change in the installed packages.uCabalKThe user interface specifies the package dbs to use with a combination of --global, --user and $--package-db=global|user|clear|$filer. This function combines the global/user flag and interprets the package-db flag into a single package db stack.KCabal¤Configure a required program, ensuring that it exists in the PATH (or where the user has specified the program must live) and making it available for use via the Ć; interface. If the program is known (exists in the input Ć ), we will make sure that the program matches the required version; otherwise we will accept any version of the program and assume that it is a simpleProgram.vCabalMakes a  ¦" from C compiler and linker flags.©This can be used with the output from configuration programs like pkg-config and similar package-specific programs like mysql-config, freealut-config etc. For example: ½ccflags <- getDbProgramOutput verbosity prog progdb ["--cflags"] ldflags <- getDbProgramOutput verbosity prog progdb ["--libs"] return (ccldOptionsBuildInfo (words ccflags) (words ldflags))LCabal=Output package check warnings and errors. Exit if any errors.MCabal0Preform checks if a relocatable build is allowedeCabalThe file path of the  setup-config file.fCabalThe file path of the  setup-config file.gCabalThe dist directory path.hCabalThe dist directory path.iCabalThe dist directory path.jCabalThe dist directory path.CabalThe } to write.@CabalThe file contents.ACabalThe processed package.lCabalThe dist directory path.mCabaldefault "dist" prefixCabaloverride "dist" prefixnCabaloverride "dist" prefixDCabaluse external internal deps?Cabalexact configuration?Cabal allow depending on private libs?Cabal installed setCabal internal setCabalrequired dependenciesECabalPtests if a dependency is satisfiable. Might say it's satisfiable even when not.GCabalinternal packagesCabalinstalled packagesCabal required depsJCabalPackage id of current packageCabalInstalled packagesCabal;Packages for which we have been given specific deps to useCabal'Are we configuring a single component?rCabalThe stack of package databases.LCabal Path to the .cabal file's directoryrs)_`abcdefghijklmnopqrstuvwxyojehkgimnprslrtsxwqvyu_`abcdf)ĖSimon Marlow 2004BSD3cabal-devel@haskell.orgportableNone>SX!ÅNCabal#Callback type for use by sdistWith.|CabalCreate a source distribution.}CabalØList all source files of a package. Returns a tuple of lists: first component is a list of ordinary files, second one is a list of those files that may be executable.OCabalKList those source files that may be executable (e.g. the configure script).PCabalHList those source files that should be copied with ordinary permissions.~Cabal)Prepare a directory tree of source files.QCabal)Find the setup script file, if it exists.RCabalKCreate a default setup script in the target directory, if it doesn't exist.SCabalFind the main executable file.TCabalFind a module definition file#TODO: I don't know if this is rightUCabalCGiven a list of include paths, try to find the include file named f]. Return the name of the file and the full path, or exit with error if there's no such file.VCabal(Remove the auto-generated modules (like  'Paths_*') from 'exposed-modules' and 'other-modules'.Cabal²Prepare a directory tree of source files for a snapshot version. It is expected that the appropriate snapshot version has already been set in the package description, eg using € or .€Cabal Modifies a  ÅA by appending a snapshot number corresponding to the given date.Cabal Modifies a MA by appending a snapshot number corresponding to the given date.‚CabalWGiven a date produce a corresponding integer representation. For example given a date 18032008 produce the number 20080318.ƒCabalECreate an archive from a tree of source files, and clean up the tree.WCabal8Given a buildinfo, return the names of all source files.„CabalGNote: must be called with the CWD set to the directory containing the '.cabal' file.XCabal)The name of the tarball without extensionNCabal verbosityCabalinfo from cabal fileCabalinfo from configureCabalsource tree to archiveCabalname of archive to create|Cabalinformation from the tarballCabalInformation from configureCabalverbosity & snapshotCabalbuild prefix (temp dir)Cabal'extra preprocessors (includes suffixes)}Cabal verbosityCabalinfo from the cabal fileCabal'extra preprocessors (include suffixes)~Cabal verbosityCabalinfo from the cabal fileCabalsource tree to populateCabal'extra preprocessors (includes suffixes)Cabal verbosityCabalinfo from the cabal fileCabalsource tree to populateCabal(extra preprocessors (includes suffixes)YCabal verbosityCabalinfo from the cabal fileCabal source treeWCabalExtra preprocessorsCabalExposed modules |}~€‚ƒ„ |„~ƒ€‚}ĢhIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008, 2012BSD3cabal-devel@haskell.orgportableNone>SX@……Cabal4Build the libraries and executables in this package.ˆCabal7Start an interpreter without loading any package files.ZCabalEAdd extra C sources generated by preprocessing to build information.[CabalGAdd extra C++ sources generated by preprocessing to build information.\CabalGAdd extra C-- sources generated by preprocessing to build information.]CabalGAdd extra ASM sources generated by preprocessing to build information.^CabalTranslate a exe-style  # component into an exe for building_CabalTranslate a exe-style  # component into an exe for building`CabalTranslate a lib-style  ( component into a lib + exe for building‰CabalRInitialize a new package db file for libraries defined internally to the package.aCabalBuild a foreign libraryeNOTE: We assume that we already checked that we can actually build the foreign library in configure.ŠCabalRuns ‹ on every configured component.‹CabalFCreates the autogenerated files for a particular configured component.ŒCabal!Generate and write out the Paths_ pkg.hs and cabal_macros.h files…Cabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildCabal%preprocessors to run before compiling†Cabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to build‡Cabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildCabal%preprocessors to run before compilingŠCabal "dist" prefixCabal'mostly information from the .cabal fileCabalConfiguration informationCabalThe verbosity to use‹Cabal "dist" prefixCabal'mostly information from the .cabal fileCabalConfiguration informationCabalThe verbosity to use…†‡ˆ‰Š‹Œ…†‡ˆŠ‰‹ŒĶIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone7>SXVbCabal3The FilePath of a directory, it's a monoid under '( /)'.cCabalTA record that represents the arguments to the haddock executable, a product monoid.dCabal?Path to the interface file, relative to argOutputDir, required.eCabalPackage name, required.fCabal!(Hide modules ?, modules to hide)gCabalIgnore export lists in modules?hCabalA(Template for modules, template for symbols, template for lines).iCabalGenerate hyperlinked sourcesjCabalGenerate quickjump indexkCabalOptional custom CSS file.lCabalOptional URL to contents page.mCabal%HTML or Hoogle doc or both? Required.nCabal G(Interface file, URL to the HTML docs and hyperlinked-source for links).oCabal$Where to generate the documentation.pCabalPage title, required.qCabalPrologue text, required.rCabal Additional flags to pass to GHC.sCabal"To find the correct GHC, required.tCabalRe-exported modulesuCabalModules to process.vCabal*Call haddock with the specified arguments.ŽCabalGiven a list of  Kps, return a list of interfaces and HTML paths, and an optional warning for packages with missing documentation.wCabaltemplate for HTML locationxCabaltemplate for HTML locationyCabaltemplate for HTML locationzCabaltemplate for HTML location{Cabaltemplate for HTML location|CabalCalled when the  exe is not found.ŽŽĪMoritz Angermann 2017BSD3cabal-devel@haskell.orgportableNone7>SXYw}CabalAA record that represents the arguments to the doctest executable.~CabalModules to process™™ĻIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone>SX_lĢ žCabalA simple implementation of mainƒ for a Cabal setup script. It reads the package description file using IO, and performs the action specified on the command line.ŸCabal A version of ž[ that is passed the command line arguments, rather than getting them from the environment. CabalA customizable version of ž.”CabalA customizable version of ž- that also takes the command line arguments.¢CabalLike žP, but accepts the package description as input rather than using IO to read it.£CabalA customizable version of ¢.¤CabalA customizable version of ¢- that also takes the command line arguments.CabalVCombine the preprocessors in the given hooks with the preprocessors built into cabal.€CabalTry to read the lCabal Read the l or throw an exception.„CabalLHooks that correspond to a plain instantiation of the "simple" build system¦CabalBasic autoconf /:6 runs  ./configure , if present.the pre-hooks 7, =, @, C, F and I+ read additional build information from package .buildinfo , if present.Thus  configure/ can use local system information to generate package .buildinfo and possibly other files.’ÆMOPQRST`abcdefghijklxyz{|}~€‚ƒ„…†‡ˆŠœžŸ ¢£¤„¦§©ØŖ«¬­®Æ°±²³“µ¶%&'>?@ŅÓŌłśūśūüżž’     ! , - . / 0 1 2 3 4 J K Ā Ć Ä Å Ę Ē Č É        / 7 6 4 3 ; = : 0 1 2 5 8 9 < > ? @ A Æ  ē č Į Ī Ķ ŗ ą Ü ½ Ō  Ą ¹ Ć ± Å é ø Ū Ź æ ¶ ū ¼ ś ö     į Ę Ó ° ² ³ “ µ · » ¾ Ā Ä Ē Č É Ė Ģ Ļ Š Ń Ņ Õ Ö × Ų Ł Ś Ż Ž ß ā ć ä å ę ź ė ģ ķ ī ļ š ń ņ ó ō õ ÷ ų ł ü ż ž ’                     ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < [ ] \ ^ _ ` a b c d e f g h i j k s u l m n o p q r t v w x y z { | } ~ÜŻŽßąįāäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’     /0512346789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\žŸ ”¢£¤„¦– [ ] \ ^ _ ` a b c d e f g h i j k s u l m n o p q r t v w x y z { | } ~ÜŻŽßąįāäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’     ž¢Ÿ/0512346789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ ”£¤„¦\‚ !"#$%$&'()*+*,-./0/1/2/34546*789:;<=>?@-A-B-C-DÖEFGHIJ/K/L4MNO-P-QRS÷ü*T4UVW-XNY-Z[\]õ?^_’żžųł`abcbdbebfbghihjhkhlmnopqbr-sbtuvuwuxuyz{|}b~pp€bz‚zƒb„b…b†‡ˆ‡‰‡Šż‹żŒżŽ""‘"’"“"”"•"–"—"˜"™"š"›œœžŸ ”¢Ÿ£Ÿ¤„¦§Ø’©’Ŗ’«’¬’­’®’Æ’°’±’²’³’“’µ’¶’·’ø’¹’ŗ’»’¼’½’¾æĄæĮæĮæĀæĆæĆÄÅÄĘÄĒÄČÄÉÄŹÄĖÄĢÄĶÄėÄźÄĪÄĻÄŠŃŅŃÓzŌÕÖV×VŲVŁVŚŪÜNŻNŽNßNąNįNāNćNäNåNęNēNčNéNźNėNģNķNīNļNšNńNņNóNōNõNöN÷NųNłNśNūNüżžż’żżżżżūū--- - - - - ------------////// !["[#[$[%[&['[([)*+,-./0123456789:;<=>?@ABCDEFEGEHEIEJEKELEM$N$O*P*Q*R*S*TUVWXYZ[\]^_`abcdefghijklmnopoqor4s4t4u4v4w4x4y4z4{4|}~}~€}~}~‚ƒ„…ƒŪ†ƒŪ‡ƒŪˆ‰Š‹‰ŠŒŽŽŽ‘ ’ “”•–Š— ˜ ™ š › œ  ž Ÿ   ” ¢££¤„„¦§§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒŌČŌÉŌŹŌĖŌĢŌĶ ĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõöÜ÷ŗųł0gśūüżž’Ś          Ś    !"#$%&'()*+,-./0123456789:;<=>?@ABCŽDŽEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhijjkllmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•––——˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹¹ŗ»¼½¾æĄĮĀĆÄÅĘĘĒČÉŹĖĢĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńńņóōõöö÷ųłśūūüüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ ‰ Š!‹"Œ""Ž"""‘""’"""“"”"•"–"—"˜"™"š"›"œ""ž"Ÿ" "”"¢"£"¤"„"¦"¦"§"Ø"©"Ŗ"«"«"¬"­"®"Æ"°"±"²"³"“"µ"¶"·"ø"¹"ŗ#»#¼#½#¾#æ#Ą#Į#Ā#Ć#Ä#Å#Ę#Ē#Č#É#Ź#Ė#Ģ#Ķ#Ī#Ļ#Š#Ń#Ņ#Ó$Ō$Ō$Õ$Ö$×$Ų$Ł$Ś$Ū$Ü$Ż$Ž$ß$ą$į$ā$ć$ä$å$ę$ē$č$é$ź$ė$ģ$ķ$ī$ļ$š$ń$ņ$ó$ō$õ$ö$÷$ų$ł$ś$ū%ü%ż%ž%’%%%ŗ%%%&&&''' ' ' ' ' 'čč(((((((((((((( !"#$%&'()*+,-./0123456789:;<=>?)@)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š0ń0ņ0ó0ō0õ0ö11111111111 1!1"2#2$2%2&2'2(2)2*2+2,2-2.2/202122232425262728293:3;3<3=3>3?3@3A3B3C3D3E3F3G4H4H4I4J4K4L4M4N4O4P4Q5R5S5T5U5V5W5X5Y5Z5[5\5]5^5_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q7r7r7s7t7u7v7w7x7y7z7{8|8}8~88€88‚8ƒ8„8…8†8‡8ˆ8‰9Š9‹9Œ99Ž999‘9’9“9”9•9–9—9˜9™9š9›:œ:œ::ž:Ÿ: :”:¢:£:¤:„:¦:§:Ø;©;Ŗ;«;¬;­;®;Æ;°;±;²;³;“;µ;¶;·;ø;¹<ŗ<»<¼<½<¾<æ<Ą<Į<Ā<Ć<Ä=Å=Ę=Ē=Č=É=Ź=Ė=Ģ=Ķ=Ī=Ļ=Š=Ń=Ņ>Ó>Ō>Õ>Ö>×>Ų>Ł>Ś>Ū>Ü>Ż>Ž>ß>ą>į>ā>ć?ä?å?ę?ē?č?é?ź?ė?ģ?ķ?ī?ļ?š?ń@ņ@ņ@ó@ō@õ@ö@÷@ų@ł@śAūAüAżAžA’AAAAAAAAAA B B B B BBBBBBBBCCšDDDDDDDDDDD D!D"D#D$D%D&D'D(D)D*D+D,D-D.D/D0D1D2D3D4D5D6D7D8D9D:D;D<D=D>D?D@DADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQDRDSDTDUDVDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfEgEhEiEjEkElEmEnEoEpEqErEsEtEuFvFwFxFyFzF{F|F}F~FF€FF‚FƒF„F…F†F‡FˆF‰FŠF‹FŒFFŽFFF‘F’F“F”F•F–F—F˜F™FšF›FœFFžFŸF F”F¢F£F¤F„F¦F§FØF©FŖF«F¬F­F®FÆF°F±F²F³F“FµF¶F·FøF¹FŗF»F¼F½F¾FæFĄFĮFĀFĆFÄFÅFĘFĒFČFÉFŹFĖFĢFĶFĪFĻFŠFŃFŅFÓFŌFÕFÖF×FŲFŁFŚFŪFÜFŻFŽFßFąFįFāFćFäFåFęFēFčFéFźFėFģFķFīFļFšFńFņFóFōFõFöF÷FųFłFśFūFüFżFžF’FFFFFFFFFF F F F F FFFFFFFFFFFFFFFFFFF F!F"F#F$F%F&F'F(F)F*F+F,F-F.F/F0F1F2F3F4F5F6F7F8F9F:F;F<F=F>F?F@FAFBFCFDFEFFFGFHFIFJFKFLFMFNFOFPFQFRFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaFbFcFdFeFfFgFhFiFjFkFlFmFnFoFpFqFrFsFtFuFvFwFxFyFzF{F|F}F~FF€FF‚FƒF„F…F†F‡FˆF‰FŠF‹FŒFFŽFFF‘F’F“F”F•F–F—F˜F™FšF›FœFFžFŸF F”F¢F£F¤F„F¦F§FØF©FŖF«F¬F­F®FÆF°F±F²F³F“FµF¶F·FøF¹FŗF»F¼F½F¾FæFĄFĮFĀFĆFÄFÅFĘFĒFČFÉFŹFĖFĢFĶFĪFĻFŠFŃFŅFÓFŌFÕFÖF×FŲFŁFŚFŪFÜFŻFŽFßFąFįFāFćFäFåFęFēFčFéFźFėFģFķFīFļFšFńFņFóFōFõFöF÷FųFłGśGūGüGżGžG’G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G !G "G #G $G %G &G 'G (G )G *G +G ,G -G .H /H 0H 1H 2H 3H 4H 5H 6H 7H 8H 9H :H ;H <H =H >H ?H @H AH BH CH DH EH FH GH HH IH JH KI LI MI LI NI OI PI QI RI SI TI UI VI WJ XJ XJ YJ ZJ [J \J ]J ^K _K _K `K aKK bK cK dK eK fK gK hK iK jK kK lK mK nK oK pK qK rK sK tK uK vL wL wL xL yL zL {L |L }L ~L L €L L ‚L ƒL „L …L †MńMńM ‡M ˆM ‰M ŠM ‹M ŒM M ŽM M M ‘M ’M “M ”N •N •N –N —N ˜N ™N šN ›N œN N žN ŸN  N ”O ¢O ¢O £O ¤O „O ¦O §O ØO ©O ŖO «O ¬O ­O ®P ÆP °P ±P ²P ³P “P µP ¶P ·P øP ¹P ŗP »P ¼P ½P ¾P æP ĄP ĮQ ĀQ ĆQ ÄQ ÅQ ĘQ ĒQ ČQ ÉQ ŹQ ĖQ ĢQ ĶQ ĪQ ĻQ ŠQ ŃQ ŅQ ÓQ ŌQ ÕQ ÖQ ×Q ŲQ ŁQ ŚQ ŪQ ÜRŅR ŻR ŽR ßR ąR įR āR ćR äR åR ęR ēR čR éR źR ėR ģR ķR īR ļR šR ńR ņR óR ōR õR öR ÷R ųR łR śR ūR üR żR žS ’S S S S S S S T T T T T T T T T T T T T T U U U U U U U U U U U U U !V "V "V #V $V %V &V 'V (V )V *V +V ,V -V .V /W 0W 1W 2W 3W 4W 5W 6W 7W 8W 9W :W ;W <W =W >W ?W @W AW BW CW DW EW FW GW HW IW JW KW LW MX NX NX OX PX QX RX SX TX UX VX WX XY YY ZY ZY [Y \Y ]Y ^Y _Y `Y aY bY cY dY eY fY gY hY iY jY kY lY mY nY oY pY qY rY sY tY uY vY wY xY yY zY {Y |Y }Z ~Z ~Z Z €Z Z ‚Z ƒZ „Z …Z †Z ‡Z ˆ[ ‰[ Š[ ‹[ Œ[ [ Ž[ [ \ ‘\ ’\ ’\ “\ ”\ •\ –] —] ˜] ™^ #^ $_ š_ š_ ›_ œ_ _ ž_ Ÿ_  _ ”_ ¢_ £_ ¤_ „_ ¦_ §` Ø` Ø` ©` Ŗ` «` ¬` ­` ®` Æ` °` ±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 Ģc Ķc Ķc Īc Ļc Šc Ńc Ņc Óc Ōc Õc Öc ×c Ųd Īd Ļe Łe Śe Ūe Üe Że Že ße ąf įf āf ćf äf åf ęf ēf čf éf źf ėf ģf ķg īg ļg šg ńg ņg óg ōg õg ög ÷g ųg łh śh ūh üh żh žh ’h h h h h h h h i i i i i i i i i i j j j j j j j j k k k k k k k k k k k !k "l Ll #l $l %l &l 'l (lTl/l )l *l +l ,l -l .l /l 0l 1l 2l Nl Ol Pl Ql Wl Sl Rl Tl Vm 3m 3m 4m 5m 6m 7m żm 8m 9m :m ;m <m =m >m ?m @m Am Bm Cm Dm Em Fm Gm Hm Im Jm Km Lm Mm Nm Om Pm Qm Rm Sm Tm Um Vm Wm Xm Ym Zm [m \m ]m ^m _m `m am bm cm dm em fm gm hm im jn 4n żn 6n 8n 5n 9n :n ;n <n =n >n ?n @n An Bn Cn Dn En Fn Gn Hn In Jn Kn Ln Mn Nn On Pn Qn Rn Sn Tn Un Vn Wn Xn Yn Zn [n \n 7o ko lo mo no oo po qo ro so to uo vo wo xo yo zo {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 ”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 ­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 Ę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 Ž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 ÷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 o o o o o p p p p p p p p p p p p p p p p !p "p #p $p %p &p 'p (p )p *p +p ,p -p .p /p 0p 1p 2p 3p 4p 5p 6p 7p 8p 9p :p ;p <p =p >p ?p @p Ap Bp Cp Dp Ep Fp Gp Hp Ip Jp Kp Lp Mp Np Op Pp Qp Rp Sp Tp Up Vp Wp Xp Yp Zp [p \q ]q ]q ^q _q `q aq bq cq Uq Vq Wq dq Yq eq fq gq hq iq jq kq lq mq nq oq pq qq rq sq tq uq vq wq xq yq Qq Rq zq {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 •s –s —s ˜s ™s ^s _s `s as bs cs Us Vs Ws ds Ys es fs gs hs is js ks ls ms ns os ps qs rs ss ts us vs ws xs ys Qs Rs zs {sÆs |s }s ~s s €s s št ›t ›t œt t žt Ÿt  t ”t ¢t £t ¤t „t ¦t §t Øt ©t Ŗt «t ¬u œu u žv ­v ­v ®v Gv Æv °v ±v 7v ²v ³v “v µv ¶v ·v øv ¹v ŗv »v ¼v ½v ¾v æw ®w Gw Æw °w ±w 7w ²x Ąx Įx Įx Āx Ćx Äx Åx Ęx Ēx Čx Éx Źx Ėx Ģx Ķx Īx Ļx Šx Ńx Ņx Óx Ōx Õx Öx ×x Ųx Łx Śx Ūx Üx Żx Žx ßx ąx įx āx ćx äx åy Āy Ćy Äy Åy Ęy Ēy Čz ęz ęz ēz čz éz ™z źz ėz ģz ķz īz ļz šz ńz ņz óz ōz õz ö{ ē{ č{ é{ ÷| ų| ų| ł| ś| ū| ü| ż| ž| ’| | | | | | | | | | } } } } } } } } } } } } } } } } ~ ~ ~ ~ ~ ~ ~ ~ ~ !~ "~ #~ $~ %~ &~ '~ (~ )~ *~ + , , - . / 0 ; < = > 1 ? @ 2 3 A B C 4 5 6 7 8 9 : ; < = M > ? @ 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€+€€N€ f€ g€ h€N€ i€ j€ k€ l€ m€ n€ n€ o€ p€ q€ r€ s€ t€ u€ v€ w€ x€ y€ z€ {€ |€ }€ ~€ € €€ € ‚€ ƒ€ „€ …€ †€ ‡€ ˆ€ ‰€]€ Š€ ‹€ Œ€ € Ž€ € € ‘€ ’€ “€ ”€ •€ –€ —€ ˜€ ™€ š€ ›€ œ€a€_€ €`€ ž€ Ÿ€  € ”€ ¢€ £€ ¤€ „€ ¦€ §€ ؁ o p q r s t u v © j k l m Ŗ « ¬ ­‚ ł‚ ś‚ ūƒ .ƒ /ƒ 0ƒ ;ƒ <ƒ =ƒ >ƒ 1ƒ ?ƒ @ƒ 2ƒ 3ƒ Aƒ Bƒ Cƒ 4ƒ -ƒ 5ƒ 6ƒ 7ƒ 8ƒ 9ƒ :ƒ ;ƒ <ƒ =ƒ Mƒ >ƒ ?ƒ @ƒ Hƒ ®ƒ „ Ƅ °„ ±„ ²… ³… “… µ… ¶… ·… ø… ¹… ŗ… ŗ… »… ¼… ½… ¾… æ… Ą… Į… Ā… ƅ ą Ņ ʅ Ē… ȅ Ʌ Ź… Ė… Ģ… Ķ… Ī… Ļ… Š… х Ņ… Ӆ Ō… Յ օ ׅ Ų… Ł… Ś… Ū… ܅ Ż… Ž… ߅ ą… į… ā… ć… ä… å… ę… ē… č… é… ź… ė… ģ† ķ† ķ† ī† ļ† ļ† š† ń† ń† ņ† ó† ó† ō† õ† õ† ö† ÷† ÷† ų††† ł† ś† ū† ü† ż† ž† ž† ’† ’††††††††††††† † † † † ††††††††††††††††††† †! " " # $ % & ' ( Ó ) * + , - . / 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‡{‡|‡}‡~‡‡€ˆˆ‚ˆƒˆ„ˆ…ˆ†ˆ‡ˆˆˆ‰‰ŠŠ‹ŠŒŠŠŽŠŠŠ‘Š’Š“Š”Š•‹–‹—‹˜‹™‹š‹š‹›‹œ‹‹ž‹Ÿ‹ ‹”‹¢‹£‹¤‹¤‹„‹¦‹§‹؋©‹Ŗ‹«‹¬‹­‹®‹Ƌ°‹±‹²‹³‹“‹µ‹¶‹·‹øŒ¹ŒŗŒ»Œ¼Œ¼Œ½Œ¾ŒæŒĄŒĮŒĀŒƌČŌʌĒŒȌɌŹŒĖŒĢĶĪĻŽŠŽяŅӏŌՏ֏׏ŲŁŚŪ܏ŻŽߏąįāćäåęēčéźėģķīļšńNņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@AB C 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’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˜3˜4˜5˜6˜7˜8˜9˜:˜;˜<˜=˜>˜?˜@˜A˜B˜C˜C˜D˜E˜F˜G˜H˜I˜J˜J˜K˜L˜M˜N˜O˜P˜Q˜R˜R˜S˜T˜U˜V˜W˜W˜X˜Y˜Z˜[˜\˜]˜^˜_˜`˜a˜b˜c˜d˜e˜f˜g˜h˜i˜j˜k˜l˜m˜n˜o˜p˜p˜q˜r˜s˜t˜u˜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›r›s›t›u›v›w›x›y›z›{›|›}›~œœ€œœ‚œƒœ„œ…œ†œ‡œˆœ‰œŠœ‹œŒœŽžžž‘ž’ž“Ÿ”Ÿ˜Ÿ•Ÿ–Ÿ—Ÿ˜Ÿ™ŸšŸ›ŸœŸŸžŸŸŸ Ÿ”Ÿ¢Ÿ£Ÿ¤Ÿ„Ÿ¦Ÿ§ Ø © Ŗ « ¬”­”­”®”Æ”°”±”²”²”³”“”µ”¶”·”ø”¹”ŗ”»”¼”½”¾”æ”Ą”Į”Ā”Ć”Ä”Å”Ę”Ē”ȔɔŹ”Ė”Ģ”Ķ”Ī¢Ļ¢Š¢Ń¢Ņ¢Ó¢Ō¢Õ£Ö£×£Ų£Ł£Ś£Ū£Ü£Ż£Ž£ߣą£į£ā¤ć¤ä¤å¤ę¤ē¤č¤é„ź„ė„ģ„ķ„ī„ļ„š„ń„ņ„ó„ō„õ„ö¦÷¦ų¦ł¦ś¦ū¦ü¦ż¦ž¦’§§§§§§§§§§ § § § § §§§§§§§§§§§§ØØØØØ©©©© ©!©"©"©#©$©%©I©&©'©(©)©*©A©+©,©-©.©/©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«e«f«g«h«i«j«k«l«m«n«o«p«q«r«s«t«u«v«w«x«y«z«{«|«}«~««€««‚«ƒ«„«…«†«‡«ˆ«‰«Š«‹«Œ««Ž«««‘«’«“«”«•«–«—«˜«™«š«›«œ««ž«Ÿ« ¬”¬¢¬£¬¤¬„¬¦¬§¬ج©¬Ŗ¬«¬ Ļ¬¬¬­¬ Š¬®¬ Ō­Æ­°­±­ œ­²­³­“­“­µ­¶­·­ø­ø­ .­k­¹­ ;­ŗ­»­¼­½­¾­æ­Ą­Į­Ā­Ć­Ä­Å­Ę­Ē­Č­É­Ź­Ė­Ģ®ĶÆĪ°Ļ°Š°Ń°Ņ°Ó°Ō°Õ°Ö°×°Ų°Ł°Ś°Ū°Ü°Ż°Ž±ß±ą±į±ā±ć±ä±å±ę±ē±č±é±ź±ė±ģ±ķ±ī±ļ±š±ń±ņ±ó±ō±õ±ö±÷±ų±ł±ś±ū±ü±ż±ž±’±±±±±±±±±± ± ± ± ± ²²²²²²²²²²²²²²²²²²² ²!²"²#²$²%²&²'³(³)³*³+³,³-³.“/“/“0“1“2“3“4“5“6“7“8“9“:“;“<“=“>“?“@“A“BµCµD¶E¶F¶G¶H¶I¶J¶K·EøLøMNOŗPŗQŗQŗRŗSŗTŗUŗVŗWŗXŗYŗZŗ[ŗ\ŗ]ŗ^»_»`»a»b»c»d¼(¼e¼f¼g¼h¼i¼)¼*¼,¼-¼j¼klmnopqrstuuvw‘(‘x‘y‘)‘z‘{‘|‘*‘}‘~‘‘€‘+‘‘‚‘ƒ‘„‘…‘†‘,‘‡‘ˆ‘-‘ \‘‰½(½x½y½)½z½{½|½*½}½~½½€½+½½‚½ƒ½„½…½†½,½ˆ½-½ \½‡¾Šæ‹ĄŒĄŒĄĄŽĄĄĄ‘Ą’Ą“Ą”Ą•Į–Į–Į—Į˜Į™ĮšĮ›ĮœĮĮžĀŸĀ Ā Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ć±Ć±Ć²Ć³Ć“ƵƶƷĆøĆ¹ĆŗĆ»Ć¼Ä½Å¾Ę-ĘæĘ DĘjĘĄĘĮĘĀĘĆĘ-ĘÄĘÅĘĘĘ.ĘĒĒČĒÉĒÉĒŹĒĖĒĢĒĶĒĪĒĻĒŠĒŃĒŅĒÓĒŌĒÕĒÖĒ×ĒŲĒŁĒŚČŪČŪČÜČŻČŽČßČąČįČāČćČäČåČęČēČčČéČźČėČģČķČīČļČšČńČņČóČōČõČöČ÷ČųȳȜČūČüȿȞȒČČČČČČČČÉŹ ¹ ¹ ¹ ¹ ¹¹¹¹¹¹¹¹¹¹¹¹¹(¹¹¹)¹y¹|¹¹¹¹¹ ¹!¹"Ė#Ė$Ė%Ė&Ė'Ė(Ė)Ė*Ė+Ģ Ģ,Ģ-Ģ~Ģ.Ģ/Ģ0Ģ1Ķ2Ķ3Ķ4Ķ5Ķ6Ķ7Ķ8Ķ9Ķ:Ķ;Ķ<Ķ=Ī>Ī?Ī@ĪAĪBĻpĻqĻCĻDĻEĻFĻGĻHĻIuJuKuL}MN}MO}MP}MQ}MR}MS}~T}~U}~V}~W}XY}XZ}[\}]^"_"`Šabcb8dedfŌg×h××ijŻkŽlŽmŽnŽoŽpŽqßrćsćtßuvwxāyāz{|{ā}{~{{€{{‚{ƒ{{å„…†‡ˆ‰Š‹ŒŽ‘ę’ę“ę”ę•ę–ę—ę˜ę™ēš››œžvŸ v”x¢m.£K¤L„ņ¦ņ§ņØņ©ņŖņ«ņ©ņŃņ¬R­R®RÆR°R±ó²ó³ó“óµó¶ó·óøó²ó¹óŗó»ó¼ó½ó¶ó¾óæóĄóĮóĀoĆvÄ~ŀʆĒČÉŹČÉĖĢĶzĪĻŠŃŅ Ó Ō Õ Ö × Ų Ł ŚČÉŪ Ü Ż Ž ß ą į āŽ0‡ćˆäŠåŽęŽēčéźėģķīļš ń ņ’ó”ō”õ—ö—÷˜ų˜ł˜ś˜ū™ü™ż™ž™’™™™™™™› ££ £ £ £ £ £££„„„Ä„„Ŗ«Æ°±±±±±±±± ±!±"±#±$±?±@±A±%³&³'³(³)³*“+“,“-“.“/“0“1“2““3“4“5¶6ø7ø8ø9ø:ŗ;ŗ<ŗ=>?@ABCDixh„EFƒGHIJKLMNO‘P‘Q‘R‘S‘T‘U‘V‘W‘X‘Y‘Z‘[‘\‘]‘^½P½Q½R½_½`½a½b½c½S½d½T½U½V½W½X½Y½Z½[½\½]½^¾eæfægæhæijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒopŽs‘’“”•–—˜™š›œšžŸ ”¢Ž£Ć¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾Ŗ®³æĄĒĮĒĀĒĆĒĹŹĘ¹Ē¹Č¹ɹŹ¹Ė¹Ģ¹Ķ¹Ī¹Ļ¹Š¹Ń¹Ņ¹Ó¹Ō¹Õ¹Ö¹×ĖŲĖŁĖŚĖŪĖÜĖŻĖŽĖßĖąĖįĖāĖćĢäĢåĢęĢēĢčĢéĢźĢĶėĶģĶķĶīĶļĶšĶńĶņĶóĶōĶõĶöĶ÷ĶųĶłĶśĶūĶüĶżĶžĶ’ĶĶĶĶĶĶĪĪžĻĻĻ  $Cabal-3.0.0.0-CD1INMNwoxXIKVgcu1nec5$Distribution.Compat.Prelude.InternalDistribution.Compat.SemigroupDistribution.Compat.StackDistribution.Compat.ParsingDistribution.Compat.ExceptionDistribution.Utils.GenericDistribution.Compat.GraphDistribution.Compat.DirectoryDistribution.Compat.BinaryDistribution.Simple.UtilsDistribution.Compat.Newtype Distribution.Compat.ResponseFileDistribution.Compat.DListDistribution.Compat.LensDistribution.Compat.CharParsingDistribution.CabalSpecVersionDistribution.Compat.CreatePipeDistribution.Fields.Field&Distribution.PackageDescription.Quirks%Distribution.PackageDescription.UtilsDistribution.Parsec.PositionDistribution.Parsec.ErrorDistribution.Parsec.WarningDistribution.Fields.LexerMonadDistribution.Fields.LexerDistribution.Fields.ParserDistribution.Pretty$Distribution.SPDX.LicenseListVersionDistribution.Simple.CCompilerDistribution.Simple.Flag(Distribution.Simple.InstallDirs.Internal$Distribution.Simple.PreProcess.Unlit$Distribution.Simple.Program.InternalDistribution.TestSuiteDistribution.Types.ConditionDistribution.Types.CondTreeDistribution.Utils.IODataDistribution.Utils.MapAccumDistribution.Utils.ProgressDistribution.Utils.ShortText#Distribution.Parsec.FieldLineStreamDistribution.ParsecDistribution.Types.Version(Distribution.Types.VersionRange.InternalDistribution.Types.VersionRange"Distribution.Types.VersionIntervalDistribution.Types.SourceRepo"Distribution.Types.SourceRepo.Lens#Distribution.Types.PkgconfigVersion(Distribution.Types.PkgconfigVersionRange Distribution.Types.PkgconfigName&Distribution.Types.PkgconfigDependencyDistribution.Types.PackageName&Distribution.Types.UnqualComponentName+Distribution.Types.PackageVersionConstraint$Distribution.Types.LibraryVisibilityDistribution.Types.LibraryName$Distribution.Types.MungedPackageName!Distribution.Types.ForeignLibType#Distribution.Types.ForeignLibOption"Distribution.Types.ExecutableScope Distribution.Types.ComponentNameDistribution.Types.ComponentId!Distribution.Types.GivenComponentDistribution.Types.BuildTypeDistribution.Types.AbiHashDistribution.TextDistribution.System"Distribution.SPDX.LicenseReferenceDistribution.SPDX.LicenseId$Distribution.SPDX.LicenseExceptionId#Distribution.SPDX.LicenseExpressionDistribution.SPDX.LicenseDistribution.ReadEDistribution.ModuleName!Distribution.Types.ModuleRenaming"Distribution.Types.IncludeRenamingDistribution.Types.Mixin!Distribution.Types.ModuleReexportDistribution.FieldGrammar.ClassDistribution.Verbosity.InternalDistribution.VerbosityDistribution.VersionDistribution.Types.TestType%Distribution.Types.TestSuiteInterfaceDistribution.Types.PackageIdDistribution.Types.UnitIdDistribution.Types.ModuleDistribution.Backpack Distribution.Types.ExposedModuleDistribution.Backpack.ModSubst Distribution.Backpack.FullUnitId$Distribution.Types.PackageName.Magic!Distribution.Types.PackageId.Lens"Distribution.Types.MungedPackageId&Distribution.Types.LegacyExeDependency Distribution.Types.ExeDependencyDistribution.Types.Dependency!Distribution.Types.SetupBuildInfo&Distribution.Types.SetupBuildInfo.Lens Distribution.Types.DependencyMap Distribution.Types.BenchmarkType%Distribution.Types.BenchmarkInterfaceDistribution.PackageDistribution.Types.AnnotatedId#Distribution.Types.ComponentInclude Distribution.Types.AbiDependencyDistribution.License'Distribution.Types.InstalledPackageInfo,Distribution.Types.InstalledPackageInfo.LensLanguage.Haskell.ExtensionDistribution.CompilerDistribution.Types.BuildInfo"Distribution.Types.HookedBuildInfo!Distribution.Types.BuildInfo.LensDistribution.Types.TestSuite!Distribution.Types.TestSuite.LensDistribution.Types.LibraryDistribution.Types.Library.LensDistribution.Types.ForeignLib"Distribution.Types.ForeignLib.LensDistribution.Types.Executable"Distribution.Types.Executable.LensDistribution.Types.BenchmarkDistribution.Types.Component)Distribution.Types.ComponentRequestedSpec%Distribution.Types.PackageDescription,Distribution.Types.GenericPackageDescription1Distribution.Types.GenericPackageDescription.Lens!Distribution.Types.Benchmark.Lens*Distribution.Types.PackageDescription.Lens$Distribution.Simple.BuildToolDependsDistribution.Simple.InstallDirsDistribution.Parsec.NewtypesDistribution.Utils.NubListDistribution.Utils.LogProgress(Distribution.Simple.Program.ResponseFile Distribution.Simple.Program.Find!Distribution.Simple.Program.TypesDistribution.Simple.Program.Run"Distribution.Simple.Program.ScriptDistribution.Simple.Program.HpcDistribution.Simple.GlobDistribution.Simple.CompilerDistribution.Simple.GHCJSDistribution.Simple.Program.GHC#Distribution.Simple.Program.BuiltinDistribution.Simple.Program.DbDistribution.Simple.Program!Distribution.Simple.Program.StripDistribution.Simple.CommandDistribution.Simple.Setup-Distribution.PackageDescription.ConfigurationDistribution.MakeDistribution.Fields.PrettyDistribution.Fields.ParseResultDistribution.Fields.ConfVar Distribution.FieldGrammar.Pretty Distribution.FieldGrammar.ParsecDistribution.FieldGrammar,Distribution.PackageDescription.FieldGrammar+Distribution.PackageDescription.PrettyPrint&Distribution.PackageDescription.Parsec%Distribution.FieldGrammar.FieldDescrs4Distribution.Types.InstalledPackageInfo.FieldGrammar!Distribution.InstalledPackageInfo*Distribution.Types.ComponentLocalBuildInfoDistribution.Types.TargetInfo!Distribution.Simple.Program.HcPkg Distribution.Simple.PackageIndex!Distribution.Types.LocalBuildInfo"Distribution.Simple.LocalBuildInfoDistribution.Simple.Test.LogDistribution.Simple.Program.LdDistribution.Simple.Program.ArDistribution.Simple.HpcDistribution.Simple.BuildTargetDistribution.Simple.BuildPathsDistribution.Simple.UHC%Distribution.PackageDescription.Check%Distribution.Simple.Build.PathsModuleDistribution.Simple.Test.LibV09Distribution.Simple.Test.ExeV10 Distribution.Simple.Build.MacrosDistribution.Simple.Configure)Distribution.Backpack.ConfiguredComponent%Distribution.Backpack.ComponentsGraph Distribution.Simple.HaskellSuiteDistribution.Simple.GHC!Distribution.Simple.ShowBuildInfoDistribution.Simple.Install!Distribution.Backpack.ModuleShape$Distribution.Backpack.PreModuleShape%Distribution.Backpack.LinkedComponentDistribution.Compat.TimeDistribution.Backpack.Configure$Distribution.Backpack.DescribeUnitIdDistribution.Simple.RegisterDistribution.Simple.PreProcessDistribution.Simple.UserHooksDistribution.Simple.TestDistribution.Simple.BenchDistribution.Simple.SrcDistDistribution.Simple.BuildDistribution.Simple.HaddockDistribution.Simple.DoctestDistribution.Simple%Distribution.Compat.Internal.TempFileDistribution.Compat.MonadFail Verbosity annotateIODistribution.Compat.PreludeText.PrettyPrint<>Distribution.Compat.SnocListData.MapelemstoList Data.GraphGraph$Distribution.Compat.GetShortPathNameDistribution.Compat.CopyFileDistribution.Compat.EnvironmentControl.Exception IOExceptionDistribution.GetOptSystem.EnvironmentgetArgsDistribution.LexDistribution.Simple.Utils.JsonDistribution.Utils.Base62Distribution.Utils.String Data.ListnubnubBySystem.FilePath isAbsolute isRelativeDistribution.SPDX simpleParseIncludeRenamingDistribution.Utils.UnionFind!Distribution.Backpack.ModuleScope Data.TypeableTypeable Data.GenericsData GHC.GenericsGenericGeneric1 Data.FunctorFunctorData.Traversable Traversable Data.FoldableFoldableLanguage.Haskell.TH.SyntaxLift PackageDescription.ConfigurationaddBuildableConditionDistribution.Types.LensDistribution.PackageDescriptionCheck Paths_Cabal Distribution.Simple.GHC.ImplInfo D.C.SetupfilterConfigureFlagsDistribution.FieldsbuildfindPackageDescDistribution.Backpack.Id Distribution.Simple.GHC.Internal)Distribution.Simple.GHC.EnvironmentParsermainDistribution.Backpack.UnifyMDistribution.Backpack.MixLink*Distribution.Backpack.PreExistingComponentTestType$Distribution.Backpack.ReadyComponentbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negatefail>>=>>fmapreturn Control.Arrowfirst Data.String fromString fromIntegral realToFrac toInteger toRationalmemptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalIsString Applicative SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeInteger GHC.MaybeMaybeOrderingRationalWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherGHC.Stack.Types CallStackFalseNothingJustTrueLeftRightLTEQGT Control.MonadunlessfoldMfilterMfor sequenceAtraverseControl.ApplicativeoptionalreadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputChar GHC.StackwithFrozenCallStack callStackGHC.IO.ExceptionioErrorGHC.IOFilePath userErrorIOError GHC.ExceptionprettyCallStackGHC.Exception.TypedisplayExceptionfindnotElemallanyorand concatMapconcat sequence_for_ traverse_productsumminimummaximumelemlengthnullfoldl'foldlfoldrfoldMapData.Semigroup.InternalgetAllAllgetAnyAny Data.OldListunwordswordsunlineslinesunfoldrsortBysort intercalate intersperse isInfixOf isSuffixOf isPrefixOf Text.Read readMaybereadseitherData.Ord comparinglex readParenreadList readsPrecText.ParserCombinators.ReadPReadSatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogexppiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix GHC.UnicodetoUppertoLowerisUpper isAlphaNumisAlphaisDigitisSpacevoid<$>lcmgcd^^^oddevendivModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumtoEnumpredsuccGHC.Charchr showParen showStringshowCharshowsShowSshowListshow showsPrecunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailhead Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybeuncurrycurrysubtractsignumabs*+asTypeOfuntil$!flip.constidordapliftM2liftMwhen=<<<$<*manysome<|>empty Alternativemplusmzero MonadPlus:|NonEmptyStringGHC.Err undefinederrorWithoutStackTraceerror/=<=compare&&||not<>maxminbinary-0.8.6.0Data.Binary.ClassputListgetputBinarycontainers-0.6.0.1Data.Map.InternalMap CyclicSCC AcyclicSCCSCCdeepseq-1.4.4.0Control.DeepSeqrnfNFDatadirectory-1.3.3.0System.Directory doesPathExist listDirectory makeAbsolutedecodeFileOrFail'decodeOrFailIOtryIOcatchIO catchExitcreateTempDirectoryNewtypepackunpackalaalafpack'unpack'$fNewtype->Endo$fNewtypeaProduct $fNewtypeaSum$fNewtypeaIdentityOption' getOption'Last'getLast'First' getFirst'gmappendgmempty$fSemigroupFirst'$fFunctorLast'$fSemigroupLast'$fMonoidOption'$fSemigroupOption'$fGSemigroup:*:$fGSemigroupM1$fGSemigroupK1 $fGMonoid:*: $fGMonoidM1 $fGMonoidK1 $fEqFirst' $fOrdFirst' $fShowFirst' $fEqLast' $fOrdLast' $fReadLast' $fShowLast' $fBinaryLast' $fEqOption' $fOrdOption' $fReadOption' $fShowOption'$fBinaryOption'$fFunctorOption' WithCallStackparentSrcLocPrefixwithLexicalCallStackannotateCallStackIO NoCallStackIOIO<<>> genericRnffoldr1foldl1expandResponseParsingtryskipManyskipSome unexpectedeof notFollowedBychoiceoption skipOptionalbetweensepBysepBy1 sepByNonEmpty sepEndBy1sepEndByendBy1endBycountchainrchainlchainl1chainr1manyTill$fParsingParsecT$fParsingIdentityT $fParsingRWST$fParsingRWST0$fParsingWriterT$fParsingWriterT0$fParsingReaderT$fParsingStateT$fParsingStateT0NodeNIsNodeKeynodeKey nodeNeighbors nodeValuesizememberinsert deleteKey deleteLookup unionRight unionLeftstronglyConnCompcyclesbroken neighbors revNeighborsclosure revClosuretopSort revTopSortfromDistinctListkeyskeysSettoMaptoGraph$fIsNodeEither $fNFDataGraph$fFoldableGraph $fEqGraph $fBinaryGraph $fReadGraph $fShowGraph $fIsNodeNode $fFunctorNode $fShowNode$fEqNodeDListrunDList singletonfromListsnoc$fSemigroupDList $fMonoidDListPretext runPretextALens'ALensASetterAGetterGetting Traversal'Lens' TraversalLens LensLike'LensLikeviewusegettingsetover toDListOftoListOftoSetOfaview_1_2&^..~?~%~.=?=%=^##~#%~ cloneLens$fFunctorPretextsetFileOrdinarysetFileExecutable CharParsingsatisfycharnotCharanyCharstringtextoneOfnoneOfspacesspacenewlinetabupperloweralphaNumletterdigithexDigitoctDigit satisfyRangeintegralmunch1munch skipSpaces1$fCharParsingParsecT$fCharParsingIdentityT$fCharParsingRWST$fCharParsingRWST0$fCharParsingWriterT$fCharParsingWriterT0$fCharParsingReaderT$fCharParsingStateT$fCharParsingStateT0 HasGlobstar NoGlobstarHasCommonStanzasNoCommonStanzasHasElifNoElifCabalSpecVersion CabalSpecV1_0 CabalSpecV1_2 CabalSpecV1_4 CabalSpecV1_6 CabalSpecV1_8CabalSpecV1_10CabalSpecV1_12CabalSpecV1_18CabalSpecV1_20CabalSpecV1_22CabalSpecV1_24 CabalSpecV2_0 CabalSpecV2_2 CabalSpecV2_4 CabalSpecV3_0showCabalSpecVersioncabalSpecLatestcabalSpecFromVersionDigitsspecHasCommonStanzas specHasElif$fEqCabalSpecVersion$fOrdCabalSpecVersion$fShowCabalSpecVersion$fReadCabalSpecVersion$fEnumCabalSpecVersion$fBoundedCabalSpecVersion$fDataCabalSpecVersion$fGenericCabalSpecVersion $fEqHasElif $fShowHasElif$fEqHasCommonStanzas$fShowHasCommonStanzas createPipeName FieldName SectionArg SecArgName SecArgStr SecArgOther FieldLineFieldSection fieldNamefieldAnn fieldUniverse fieldLineAnn fieldLineBS sectionArgAnnmkNamegetNamenameAnn $fEqFieldLine$fShowFieldLine$fFunctorFieldLine$fFoldableFieldLine$fTraversableFieldLine$fEqSectionArg$fShowSectionArg$fFunctorSectionArg$fFoldableSectionArg$fTraversableSectionArg$fEqName $fShowName $fFunctorName$fFoldableName$fTraversableName $fEqField $fShowField$fFunctorField$fFoldableField$fTraversableField patchQuirksuserBugcabalBugPositionincPosretPosshowPoszeroPos positionCol positionRow$fNFDataPosition$fBinaryPosition $fEqPosition $fOrdPosition$fShowPosition$fGenericPositionPError showPError$fNFDataPError$fBinaryPError $fShowPError$fGenericPErrorPWarning PWarnTypePWTOtherPWTUTF PWTBoolCase PWTVersionTag PWTNewSyntax PWTOldSyntaxPWTDeprecatedFieldPWTInvalidSubsectionPWTUnknownFieldPWTUnknownSectionPWTTrailingFieldsPWTExtraMainIsPWTExtraTestModulePWTExtraBenchmarkModule PWTLexNBSP PWTLexBOM PWTLexTabPWTQuirkyCabalFile PWTDoubleDashPWTMultipleSingularFieldPWTBuildTypeDefault showPWarning$fNFDataPWarnType$fBinaryPWarnType$fNFDataPWarning$fBinaryPWarning $fEqPWarnType$fOrdPWarnType$fShowPWarnType$fEnumPWarnType$fBoundedPWarnType$fGenericPWarnType$fShowPWarning$fGenericPWarning InputStreamLexStatecurPoscurInputcurCodewarnings LexWarningLexWarningTypeLexWarningNBSP LexWarningBOM LexWarningTab LexResultLexunLex toPWarnings execLexersetPosgetPos adjustPosgetInputsetInput getStartCode setStartCode addWarning $fMonadLex$fApplicativeLex $fFunctorLex$fEqLexWarningType$fOrdLexWarningType$fShowLexWarningType$fShowLexWarningLTokenLTokenTokSymTokStrTokOtherIndent TokFieldLineColon OpenBrace CloseBraceEOF LexicalErrorlexTokenltest mkLexState bol_sectionin_field_bracesin_field_layout in_section $fShowToken $fShowLToken readFields readFields'$fStreamLexState'IdentityLToken SeparatorPrettyprettyprettyVersioned prettyShow defaultStyle flatStyle showFilePath showToken showFreeTextshowFreeTextV3$fPrettyIdentity $fPrettyInt $fPrettyBoolLicenseListVersionLicenseListVersion_3_0LicenseListVersion_3_2LicenseListVersion_3_6!cabalSpecVersionToSPDXListVersion$fEqLicenseListVersion$fOrdLicenseListVersion$fShowLicenseListVersion$fEnumLicenseListVersion$fBoundedLicenseListVersionCDialectC ObjectiveC CPlusPlusObjectiveCPlusPluscSourceExtensionscDialectFilenameExtensionfilenameCDialect$fSemigroupCDialect$fMonoidCDialect $fEqCDialect$fShowCDialect BooleanFlagasBoolFlagNoFlagtoFlagfromFlagfromFlagOrDefault flagToMaybe flagToListallFlags maybeToFlag $fEnumFlag $fBoundedFlag$fSemigroupFlag $fMonoidFlag$fApplicativeFlag $fFunctorFlag $fBinaryFlag$fBooleanFlagBool$fEqFlag $fGenericFlag $fShowFlag $fReadFlagPathTemplateVariable PrefixVar BindirVar LibdirVar LibsubdirVar DynlibdirVar DatadirVar DatasubdirVar DocdirVar HtmldirVar PkgNameVar PkgVerVarPkgIdVar LibNameVar CompilerVarOSVarArchVarAbiVar AbiTagVarExecutableNameVarTestSuiteNameVarTestSuiteResultVarBenchmarkNameVar PathComponentOrdinaryVariable$fReadPathTemplateVariable$fShowPathTemplateVariable$fBinaryPathTemplateVariable$fReadPathComponent$fShowPathComponent$fBinaryPathComponent$fEqPathTemplateVariable$fOrdPathTemplateVariable$fGenericPathTemplateVariable$fEqPathComponent$fOrdPathComponent$fGenericPathComponentplainunlitstripExtractVersionResultPassFailErrorProgressFinishedOptionsGroup ExtraOptions groupName concurrently groupTests OptionType OptionFile OptionString OptionNumber OptionBool OptionEnum OptionSet OptionRngSeedoptionFileMustExistoptionFileIsDiroptionFileExtensionsoptionStringMultilineoptionNumberIsIntoptionNumberBounds OptionDescr optionNameoptionDescription optionType optionDefault TestInstancerunnametagsoptions setOption testGroup$fEqOptionType$fReadOptionType$fShowOptionType$fEqOptionDescr$fReadOptionDescr$fShowOptionDescr $fEqResult $fReadResult $fShowResult ConditionVarLitCNotCOrCAndcNotcAndcOrsimplifyCondition$fNFDataCondition$fBinaryCondition$fMonadPlusCondition$fAlternativeCondition$fSemigroupCondition$fMonoidCondition$fMonadCondition$fApplicativeCondition$fTraversableCondition$fFoldableCondition$fFunctorCondition$fShowCondition $fEqCondition$fDataCondition$fGenericCondition CondBranchcondBranchConditioncondBranchIfTruecondBranchIfFalseCondTreeCondNode condTreeDatacondTreeConstraintscondTreeComponents condIfThencondIfThenElse mapCondTreemapTreeConstrs mapTreeConds mapTreeDatatraverseCondTreeVtraverseCondBranchVtraverseCondTreeCtraverseCondBranchCextractConditionsimplifyCondTreeignoreConditions$fNFDataCondBranch$fBinaryCondBranch$fFoldableCondBranch$fNFDataCondTree$fBinaryCondTree$fShowCondBranch$fEqCondBranch$fDataCondBranch$fGenericCondBranch$fFunctorCondBranch$fTraversableCondBranch$fShowCondTree $fEqCondTree$fDataCondTree$fGenericCondTree$fFunctorCondTree$fFoldableCondTree$fTraversableCondTree IODataModeIODataModeTextIODataModeBinaryIOData IODataText IODataBinary hGetContents hPutContents$fNFDataIOData mapAccumM$fApplicativeStateM$fFunctorStateM stepProgress failProgress foldProgress$fAlternativeProgress$fApplicativeProgress$fMonadProgress$fFunctorProgressdecodeStringUtf8encodeStringUtf8 ShortText toShortText fromShortText$fIsStringShortText$fMonoidShortText$fSemigroupShortText$fReadShortText$fShowShortText$fNFDataShortText$fBinaryShortText $fEqShortText$fOrdShortText$fGenericShortText$fDataShortTextwrapTextwrapLinewithFileContentswriteFileAtomic fromUTF8BS fromUTF8LBStoUTF8BS toUTF8LBS validateUTF8 ignoreBOM readUTF8FilewithUTF8FileContents writeUTF8FilenormaliseLineEndingsdropWhileEndLEtakeWhileEndLEordNubordNubBy listUnion ordNubRightlistUnionRightsafeTailequating lowercaseisAscii isAsciiAlphaisAsciiAlphaNum unintersperse breakMaybe spanMaybeunfoldrMisAbsoluteOnAnyPlatformisRelativeOnAnyPlatformFieldLineStreamFLSLastFLSConsfieldLineStreamEndfieldLineStreamFromStringfieldLineStreamFromBS$fStreamFieldLineStreammChar$fShowFieldLineStream ParsecParserPPunPP CabalParsing parsecWarningparsecHaskellStringaskCabalSpecVersionParsecparsec lexemeParsec simpleParsec eitherParsecexplicitEitherParsecrunParsecParserrunParsecParser' parsecToken parsecToken'parsecFilePathparsecStandardparsecCommaListparsecLeadingCommaListparsecOptCommaListparsecLeadingOptCommaList parsecQuotedparsecMaybeQuotedparsecUnqualComponentName $fParsecBool$fParsecIdentity$fCabalParsingParsecParser$fCharParsingParsecParser$fParsingParsecParser$fMonadFailParsecParser$fMonadPlusParsecParser$fMonadParsecParser$fAlternativeParsecParser$fApplicativeParsecParser$fFunctorParsecParserVersionversionDigitParser mkVersionversion0 mkVersion'versionNumbers nullVersion alterVersion validVersion$fParsecVersion$fPrettyVersion$fNFDataVersion$fBinaryVersion $fReadVersion $fShowVersion $fOrdVersion $fDataVersion $fEqVersion$fGenericVersion VersionRangeF AnyVersionF ThisVersionF LaterVersionFOrLaterVersionFEarlierVersionFOrEarlierVersionFWildcardVersionFMajorBoundVersionFUnionVersionRangesFIntersectVersionRangesFVersionRangeParensF VersionRange AnyVersion ThisVersion LaterVersionOrLaterVersionEarlierVersionOrEarlierVersionWildcardVersionMajorBoundVersionUnionVersionRangesIntersectVersionRangesVersionRangeParens anyVersion noVersion thisVersionnotThisVersion laterVersionorLaterVersionearlierVersionorEarlierVersionunionVersionRangesintersectVersionRanges withinVersionmajorBoundVersionprojectVersionRangecataVersionRangeembedVersionRangeanaVersionRangehyloVersionRangeversionRangeParsermajorUpperBound$fParsecVersionRange$fNFDataVersionRange$fBinaryVersionRange$fPrettyVersionRange$fDataVersionRange$fEqVersionRange$fGenericVersionRange$fReadVersionRange$fShowVersionRange$fDataVersionRangeF$fEqVersionRangeF$fGenericVersionRangeF$fReadVersionRangeF$fShowVersionRangeF$fFunctorVersionRangeF$fFoldableVersionRangeF$fTraversableVersionRangeFfoldVersionRangenormaliseVersionRangestripParensVersionRange withinRangewildcardUpperBoundisWildcardRange hasUpperBound hasLowerBoundBoundExclusiveBoundInclusiveBound UpperBound NoUpperBound LowerBoundVersionIntervalVersionIntervalsasVersionIntervalsversionIntervalsmkVersionIntervalswithinIntervalstoVersionIntervalsfromVersionIntervalsunionVersionIntervalsintersectVersionIntervalsinvertVersionIntervalsrelaxLastIntervalrelaxHeadInterval$fOrdUpperBound$fOrdLowerBound $fEqBound $fShowBound$fEqUpperBound$fShowUpperBound$fEqLowerBound$fShowLowerBound$fEqVersionIntervals$fShowVersionIntervalsRepoTypeDarcsGitSVNCVS MercurialGnuArchBazaarMonotone OtherRepoTypeRepoKindRepoHeadRepoThisRepoKindUnknown SourceReporepoKindrepoType repoLocation repoModule repoBranchrepoTag repoSubdiremptySourceRepoknownRepoTypesclassifyRepoKindclassifyRepoType$fParsecRepoKind$fPrettyRepoKind$fNFDataRepoKind$fBinaryRepoKind$fParsecRepoType$fPrettyRepoType$fNFDataRepoType$fBinaryRepoType$fNFDataSourceRepo$fBinarySourceRepo $fEqRepoKind$fGenericRepoKind $fOrdRepoKind$fReadRepoKind$fShowRepoKind$fDataRepoKind $fEqRepoType$fGenericRepoType $fOrdRepoType$fReadRepoType$fShowRepoType$fDataRepoType$fEqSourceRepo$fOrdSourceRepo$fGenericSourceRepo$fReadSourceRepo$fShowSourceRepo$fDataSourceRepoPkgconfigVersion rpmvercmp$fParsecPkgconfigVersion$fPrettyPkgconfigVersion$fNFDataPkgconfigVersion$fBinaryPkgconfigVersion$fOrdPkgconfigVersion$fEqPkgconfigVersion$fGenericPkgconfigVersion$fReadPkgconfigVersion$fShowPkgconfigVersion$fDataPkgconfigVersionPkgconfigVersionRange PcAnyVersion PcThisVersionPcLaterVersionPcEarlierVersionPcOrLaterVersionPcOrEarlierVersionPcUnionVersionRangesPcIntersectVersionRangesanyPkgconfigVersionisAnyPkgconfigVersionwithinPkgconfigVersionRangeversionToPkgconfigVersion#versionRangeToPkgconfigVersionRange$fParsecPkgconfigVersionRange$fPrettyPkgconfigVersionRange$fNFDataPkgconfigVersionRange$fBinaryPkgconfigVersionRange$fGenericPkgconfigVersionRange$fReadPkgconfigVersionRange$fShowPkgconfigVersionRange$fEqPkgconfigVersionRange$fDataPkgconfigVersionRange PkgconfigNameunPkgconfigNamemkPkgconfigName$fNFDataPkgconfigName$fParsecPkgconfigName$fPrettyPkgconfigName$fBinaryPkgconfigName$fIsStringPkgconfigName$fGenericPkgconfigName$fReadPkgconfigName$fShowPkgconfigName$fEqPkgconfigName$fOrdPkgconfigName$fDataPkgconfigNamePkgconfigDependency$fParsecPkgconfigDependency$fPrettyPkgconfigDependency$fNFDataPkgconfigDependency$fBinaryPkgconfigDependency$fGenericPkgconfigDependency$fReadPkgconfigDependency$fShowPkgconfigDependency$fEqPkgconfigDependency$fDataPkgconfigDependency PackageName unPackageName mkPackageName$fNFDataPackageName$fParsecPackageName$fPrettyPackageName$fBinaryPackageName$fIsStringPackageName$fGenericPackageName$fReadPackageName$fShowPackageName$fEqPackageName$fOrdPackageName$fDataPackageNameUnqualComponentNameunUnqualComponentNamemkUnqualComponentName packageNameToUnqualComponentName unqualComponentNameToPackageName$fNFDataUnqualComponentName$fParsecUnqualComponentName$fPrettyUnqualComponentName$fBinaryUnqualComponentName$fIsStringUnqualComponentName$fGenericUnqualComponentName$fReadUnqualComponentName$fShowUnqualComponentName$fEqUnqualComponentName$fOrdUnqualComponentName$fDataUnqualComponentName$fSemigroupUnqualComponentName$fMonoidUnqualComponentNamePackageVersionConstraint $fParsecPackageVersionConstraint $fPrettyPackageVersionConstraint $fNFDataPackageVersionConstraint $fBinaryPackageVersionConstraint!$fGenericPackageVersionConstraint$fReadPackageVersionConstraint$fShowPackageVersionConstraint$fEqPackageVersionConstraint$fDataPackageVersionConstraintLibraryVisibilityLibraryVisibilityPublicLibraryVisibilityPrivate$fMonoidLibraryVisibility$fSemigroupLibraryVisibility$fNFDataLibraryVisibility$fBinaryLibraryVisibility$fParsecLibraryVisibility$fPrettyLibraryVisibility$fGenericLibraryVisibility$fShowLibraryVisibility$fReadLibraryVisibility$fEqLibraryVisibility$fDataLibraryVisibility LibraryName LMainLibName LSubLibNameprettyLibraryNameComponentparsecLibraryNameComponentdefaultLibNameshowLibraryNamelibraryNameStanzalibraryNameStringmaybeToLibraryName$fNFDataLibraryName$fBinaryLibraryName$fEqLibraryName$fGenericLibraryName$fOrdLibraryName$fReadLibraryName$fShowLibraryName$fDataLibraryNameMungedPackageNamedecodeCompatPackageNameencodeCompatPackageName$fParsecMungedPackageName$fPrettyMungedPackageName$fNFDataMungedPackageName$fBinaryMungedPackageName$fGenericMungedPackageName$fReadMungedPackageName$fShowMungedPackageName$fEqMungedPackageName$fOrdMungedPackageName$fDataMungedPackageNameForeignLibTypeForeignLibNativeSharedForeignLibNativeStaticForeignLibTypeUnknownknownForeignLibTypesforeignLibTypeIsShared$fMonoidForeignLibType$fSemigroupForeignLibType$fNFDataForeignLibType$fBinaryForeignLibType$fParsecForeignLibType$fPrettyForeignLibType$fGenericForeignLibType$fShowForeignLibType$fReadForeignLibType$fEqForeignLibType$fDataForeignLibTypeForeignLibOptionForeignLibStandalone$fNFDataForeignLibOption$fBinaryForeignLibOption$fParsecForeignLibOption$fPrettyForeignLibOption$fGenericForeignLibOption$fShowForeignLibOption$fReadForeignLibOption$fEqForeignLibOption$fDataForeignLibOptionExecutableScopeExecutablePublicExecutablePrivate$fMonoidExecutableScope$fSemigroupExecutableScope$fNFDataExecutableScope$fBinaryExecutableScope$fParsecExecutableScope$fPrettyExecutableScope$fGenericExecutableScope$fShowExecutableScope$fReadExecutableScope$fEqExecutableScope$fDataExecutableScope ComponentNameCLibName CFLibNameCExeName CTestName CBenchNameshowComponentNamecomponentNameStanzacomponentNameString$fParsecComponentName$fPrettyComponentName$fBinaryComponentName$fEqComponentName$fGenericComponentName$fOrdComponentName$fReadComponentName$fShowComponentName ComponentId mkComponentId unComponentId$fNFDataComponentId$fParsecComponentId$fPrettyComponentId$fBinaryComponentId$fIsStringComponentId$fGenericComponentId$fReadComponentId$fShowComponentId$fEqComponentId$fOrdComponentId$fDataComponentIdGivenComponentgivenComponentPackagegivenComponentNamegivenComponentId$fBinaryGivenComponent$fGenericGivenComponent$fReadGivenComponent$fShowGivenComponent$fEqGivenComponent BuildTypeSimple ConfigureMakeCustomknownBuildTypes$fParsecBuildType$fPrettyBuildType$fNFDataBuildType$fBinaryBuildType$fGenericBuildType$fShowBuildType$fReadBuildType $fEqBuildType$fDataBuildTypeAbiHash unAbiHash mkAbiHash$fParsecAbiHash$fPrettyAbiHash$fNFDataAbiHash$fBinaryAbiHash$fIsStringAbiHash $fEqAbiHash $fShowAbiHash $fReadAbiHash$fGenericAbiHashdisplayPlatformArchI386X86_64PPCPPC64SparcArmAArch64MipsSHIA64S390AlphaHppaRs6000M68kVax JavaScript OtherArchOSLinuxWindowsOSXFreeBSDOpenBSDNetBSD DragonFlySolarisAIXHPUXIRIXHaLVMHurdIOSAndroidGhcjsOtherOSClassificationStrictness PermissiveCompatStrictknownOSs classifyOSbuildOS knownArches classifyArch buildArch buildPlatformplatformFromTriple $fParsecOS $fPrettyOS $fNFDataOS $fBinaryOS $fParsecArch $fPrettyArch $fNFDataArch $fBinaryArch$fParsecPlatform$fPrettyPlatform$fNFDataPlatform$fBinaryPlatform$fEqOS $fGenericOS$fOrdOS$fShowOS$fReadOS$fDataOS$fEqArch $fGenericArch $fOrdArch $fShowArch $fReadArch $fDataArch $fEqPlatform$fGenericPlatform $fOrdPlatform$fShowPlatform$fReadPlatform$fDataPlatform LicenseRef licenseReflicenseDocumentRef mkLicenseRef mkLicenseRef'$fParsecLicenseRef$fPrettyLicenseRef$fNFDataLicenseRef$fBinaryLicenseRef$fShowLicenseRef$fReadLicenseRef$fEqLicenseRef$fOrdLicenseRef$fDataLicenseRef$fGenericLicenseRef LicenseIdNullBSDAALAbstyles Adobe_2006 Adobe_GlyphADSLAFL_1_1AFL_1_2AFL_2_0AFL_2_1AFL_3_0AfmparseAGPL_1_0 AGPL_1_0_onlyAGPL_1_0_or_later AGPL_3_0_onlyAGPL_3_0_or_laterAladdinAMDPLPAAMLAMPASANTLR_PD Apache_1_0 Apache_1_1 Apache_2_0APAFMLAPL_1_0APSL_1_0APSL_1_1APSL_1_2APSL_2_0Artistic_1_0_cl8Artistic_1_0_Perl Artistic_1_0 Artistic_2_0BahyphBarrBeerwareBitTorrent_1_0BitTorrent_1_1Blessing BlueOak_1_0_0Borceux BSD_1_ClauseBSD_2_Clause_FreeBSDBSD_2_Clause_NetBSDBSD_2_Clause_Patent BSD_2_ClauseBSD_3_Clause_AttributionBSD_3_Clause_ClearBSD_3_Clause_LBNL$BSD_3_Clause_No_Nuclear_License_2014BSD_3_Clause_No_Nuclear_License BSD_3_Clause_No_Nuclear_WarrantyBSD_3_Clause_Open_MPI BSD_3_ClauseBSD_4_Clause_UC BSD_4_ClauseBSD_ProtectionBSD_Source_CodeBSL_1_0 Bzip2_1_0_5 Bzip2_1_0_6Caldera CATOSL_1_1 CC_BY_1_0 CC_BY_2_0 CC_BY_2_5 CC_BY_3_0 CC_BY_4_0 CC_BY_NC_1_0 CC_BY_NC_2_0 CC_BY_NC_2_5 CC_BY_NC_3_0 CC_BY_NC_4_0CC_BY_NC_ND_1_0CC_BY_NC_ND_2_0CC_BY_NC_ND_2_5CC_BY_NC_ND_3_0CC_BY_NC_ND_4_0CC_BY_NC_SA_1_0CC_BY_NC_SA_2_0CC_BY_NC_SA_2_5CC_BY_NC_SA_3_0CC_BY_NC_SA_4_0 CC_BY_ND_1_0 CC_BY_ND_2_0 CC_BY_ND_2_5 CC_BY_ND_3_0 CC_BY_ND_4_0 CC_BY_SA_1_0 CC_BY_SA_2_0 CC_BY_SA_2_5 CC_BY_SA_3_0 CC_BY_SA_4_0CC_PDDCCC0_1_0CDDL_1_0CDDL_1_1CDLA_Permissive_1_0CDLA_Sharing_1_0 CECILL_1_0 CECILL_1_1 CECILL_2_0 CECILL_2_1CECILL_BCECILL_C CERN_OHL_1_1 CERN_OHL_1_2 ClArtistic CNRI_JythonCNRI_Python_GPL_Compatible CNRI_Python Condor_1_1Copyleft_next_0_3_0Copyleft_next_0_3_1CPAL_1_0CPL_1_0 CPOL_1_02 CrosswordCrystalStacker CUA_OPL_1_0CubeCurl D_FSL_1_0DiffmarkDOCDotseqnDSDPDvipdfmECL_1_0ECL_2_0EFL_1_0EFL_2_0EGenixEntessaEPL_1_0EPL_2_0 ErlPL_1_1 EUDatagridEUPL_1_0EUPL_1_1EUPL_1_2EurosymFair Frameworx_1_0 FreeImageFSFAPFSFULLRFSFULFTL GFDL_1_1_onlyGFDL_1_1_or_later GFDL_1_2_onlyGFDL_1_2_or_later GFDL_1_3_onlyGFDL_1_3_or_laterGiftwareGL2PSGlideGlulxeGnuplot GPL_1_0_onlyGPL_1_0_or_later GPL_2_0_onlyGPL_2_0_or_later GPL_3_0_onlyGPL_3_0_or_later GSOAP_1_3b HaskellReportHPND_sell_variantHPNDIBM_pibsICUIJG ImageMagickIMatixImlib2Info_ZIP Intel_ACPIIntel Interbase_1_0IPAIPL_1_0ISC JasPer_2_0JPNICJSONLAL_1_2LAL_1_3Latex2e Leptonica LGPL_2_0_onlyLGPL_2_0_or_later LGPL_2_1_onlyLGPL_2_1_or_later LGPL_3_0_onlyLGPL_3_0_or_laterLGPLLR Libpng_2_0LibpngLibtiff LiLiQ_P_1_1 LiLiQ_R_1_1LiLiQ_Rplus_1_1 Linux_OpenIBLPL_1_02LPL_1_0LPPL_1_0LPPL_1_1LPPL_1_2 LPPL_1_3a LPPL_1_3c MakeIndexMirOSMIT_0MIT_advertisingMIT_CMUMIT_ennaMIT_fehMITNFAMITMotosotoMpich2MPL_1_0MPL_1_1MPL_2_0_no_copyleft_exceptionMPL_2_0MS_PLMS_RLMTLLMulticsMupNASA_1_3NaumenNBPL_1_0NCSANet_SNMPNetCDFNewsletrNGPLNLOD_1_0NLPLNokiaNOSLNowebNPL_1_0NPL_1_1 NPOSL_3_0NRLNTPOCCT_PLOCLC_2_0ODbL_1_0 ODC_By_1_0OFL_1_0OFL_1_1 OGL_UK_1_0 OGL_UK_2_0 OGL_UK_3_0OGTSL OLDAP_1_1 OLDAP_1_2 OLDAP_1_3 OLDAP_1_4 OLDAP_2_0_1 OLDAP_2_0 OLDAP_2_1 OLDAP_2_2_1 OLDAP_2_2_2 OLDAP_2_2 OLDAP_2_3 OLDAP_2_4 OLDAP_2_5 OLDAP_2_6 OLDAP_2_7 OLDAP_2_8OMLOpenSSLOPL_1_0 OSET_PL_2_1OSL_1_0OSL_1_1OSL_2_0OSL_2_1OSL_3_0 Parity_6_0_0PDDL_1_0PHP_3_01PHP_3_0Plexus PostgreSQLPsfragPsutils Python_2_0QhullQPL_1_0Rdisc RHeCos_1_1RPL_1_1RPL_1_5RPSL_1_0RSA_MDRSCPLRubySAX_PDSaxpathSCEA Sendmail_8_23Sendmail SGI_B_1_0 SGI_B_1_1 SGI_B_2_0SHL_0_51SHL_0_5 SimPL_2_0 SISSL_1_2SISSL SleepycatSMLNJSMPPLSNIA Spencer_86 Spencer_94 Spencer_99SPL_1_0SSPL_1_0SugarCRM_1_1_3SWL TAPR_OHL_1_0TCL TCP_wrappersTMate TORQUE_1_1TOSL TU_Berlin_1_0 TU_Berlin_2_0Unicode_DFS_2015Unicode_DFS_2016 Unicode_TOU UnlicenseUPL_1_0VimVOSTROMVSL_1_0 W3C_19980720 W3C_20150513W3C Watcom_1_0WsuipaWTFPLX11Xerox XFree86_1_1XinetdXnetXppXSkatYPL_1_0YPL_1_1ZedZend_2_0 Zimbra_1_3 Zimbra_1_4Zlib_acknowledgementZlibZPL_1_1ZPL_2_0ZPL_2_1licenseIdMigrationMessage licenseId licenseNamelicenseIsOsiApproved licenseIdList mkLicenseId$fNFDataLicenseId$fParsecLicenseId$fPrettyLicenseId$fBinaryLicenseId $fEqLicenseId$fOrdLicenseId$fEnumLicenseId$fBoundedLicenseId$fShowLicenseId$fReadLicenseId$fDataLicenseId$fGenericLicenseIdLicenseExceptionIdDS389_exceptionAutoconf_exception_2_0Autoconf_exception_3_0Bison_exception_2_2Bootloader_exceptionClasspath_exception_2_0CLISP_exception_2_0DigiRule_FOSS_exceptionECos_exception_2_0Fawkes_Runtime_exceptionFLTK_exceptionFont_exception_2_0Freertos_exception_2_0GCC_exception_2_0GCC_exception_3_1Gnu_javamail_exception GPL_CC_1_0I2p_gpl_java_exceptionLibtool_exceptionLinux_syscall_noteLLVM_exceptionLZMA_exception Mif_exceptionNokia_Qt_exception_1_1OCaml_LGPL_linking_exceptionOCCT_exception_1_0OpenJDK_assembly_exception_1_0Openvpn_openssl_exception!PS_or_PDF_font_exception_20170817Qt_GPL_exception_1_0Qt_LGPL_exception_1_1Qwt_exception_1_0Swift_exceptionU_boot_exception_2_0Universal_FOSS_exception_1_0WxWindows_exception_3_1licenseExceptionIdlicenseExceptionNamelicenseExceptionIdListmkLicenseExceptionId$fNFDataLicenseExceptionId$fParsecLicenseExceptionId$fPrettyLicenseExceptionId$fBinaryLicenseExceptionId$fEqLicenseExceptionId$fOrdLicenseExceptionId$fEnumLicenseExceptionId$fBoundedLicenseExceptionId$fShowLicenseExceptionId$fReadLicenseExceptionId$fDataLicenseExceptionId$fGenericLicenseExceptionIdSimpleLicenseExpression ELicenseIdELicenseIdPlus ELicenseRefLicenseExpressionELicenseEAndEOrsimpleLicenseExpression$fNFDataSimpleLicenseExpression$fParsecSimpleLicenseExpression$fPrettySimpleLicenseExpression$fBinarySimpleLicenseExpression$fNFDataLicenseExpression$fParsecLicenseExpression$fPrettyLicenseExpression$fBinaryLicenseExpression$fShowSimpleLicenseExpression$fReadSimpleLicenseExpression$fEqSimpleLicenseExpression$fOrdSimpleLicenseExpression$fDataSimpleLicenseExpression $fGenericSimpleLicenseExpression$fShowLicenseExpression$fReadLicenseExpression$fEqLicenseExpression$fOrdLicenseExpression$fDataLicenseExpression$fGenericLicenseExpressionLicenseNONE$fParsecLicense$fPrettyLicense$fNFDataLicense$fBinaryLicense $fShowLicense $fReadLicense $fEqLicense $fOrdLicense $fDataLicense$fGenericLicenseReadErunReadE succeedReadE failReadE readEOrFail parsecToReadE$fFunctorReadE ModuleNamevalidModuleComponentfromComponents components toFilePath$fBinaryShortTextLst$fReadShortTextLst$fShowShortTextLst$fNFDataShortTextLst$fIsStringModuleName$fParsecModuleName$fPrettyModuleName$fNFDataModuleName$fBinaryModuleName$fEqShortTextLst$fGenericShortTextLst$fOrdShortTextLst$fDataShortTextLst$fEqModuleName$fGenericModuleName$fOrdModuleName$fReadModuleName$fShowModuleName$fDataModuleNameModuleRenamingDefaultRenamingHidingRenaminginterpModuleRenamingdefaultRenamingisDefaultRenaming$fParsecModuleRenaming$fPrettyModuleRenaming$fNFDataModuleRenaming$fBinaryModuleRenaming$fShowModuleRenaming$fReadModuleRenaming$fEqModuleRenaming$fOrdModuleRenaming$fDataModuleRenaming$fGenericModuleRenamingincludeProvidesRnincludeRequiresRndefaultIncludeRenamingisDefaultIncludeRenaming$fParsecIncludeRenaming$fPrettyIncludeRenaming$fNFDataIncludeRenaming$fBinaryIncludeRenaming$fShowIncludeRenaming$fReadIncludeRenaming$fEqIncludeRenaming$fOrdIncludeRenaming$fDataIncludeRenaming$fGenericIncludeRenamingMixinmixinPackageNamemixinIncludeRenaming $fParsecMixin $fPrettyMixin $fNFDataMixin $fBinaryMixin $fShowMixin $fReadMixin $fEqMixin $fOrdMixin $fDataMixin$fGenericMixinModuleReexportmoduleReexportOriginalPackagemoduleReexportOriginalNamemoduleReexportName$fParsecModuleReexport$fPrettyModuleReexport$fNFDataModuleReexport$fBinaryModuleReexport$fEqModuleReexport$fGenericModuleReexport$fReadModuleReexport$fShowModuleReexport$fDataModuleReexport FieldGrammarblurFieldGrammaruniqueFieldAlabooleanFieldDefoptionalFieldAlaoptionalFieldDefAla freeTextFieldfreeTextFieldDefmonoidalFieldAlaprefixedFields knownField hiddenFielddeprecatedSince removedInavailableSince uniqueField optionalFieldoptionalFieldDef monoidalField VerbosityFlag VCallStack VCallSiteVNoWrap VMarkOutput VTimestampVerbosityLevelSilentNormalVerbose Deafening$fBinaryVerbosityLevel$fBinaryVerbosityFlag$fGenericVerbosityLevel$fShowVerbosityLevel$fReadVerbosityLevel$fEqVerbosityLevel$fOrdVerbosityLevel$fEnumVerbosityLevel$fBoundedVerbosityLevel$fGenericVerbosityFlag$fShowVerbosityFlag$fReadVerbosityFlag$fEqVerbosityFlag$fOrdVerbosityFlag$fEnumVerbosityFlag$fBoundedVerbosityFlagsilentnormalverbose deafening moreVerbose lessVerbosemodifyVerbosityintToVerbosityflagToVerbosity showForCabal showForGHCverboseCallSiteverboseCallStackverboseMarkOutputverboseUnmarkOutput verboseNoWrapverboseTimestampverboseNoTimestampverboseNoFlagsverboseHasFlagsisVerboseCallSiteisVerboseCallStackisVerboseMarkOutputisVerboseNoWrapisVerboseQuietisVerboseTimestamp$fBinaryVerbosity$fBoundedVerbosity$fEnumVerbosity$fOrdVerbosity $fEqVerbosity$fGenericVerbosity$fShowVerbosity$fReadVerbosity isAnyVersion isNoVersionisSpecificVersionsimplifyVersionRangedifferenceVersionRangesinvertVersionRangeremoveUpperBoundremoveLowerBoundTestType TestTypeExe TestTypeLibTestTypeUnknownknownTestTypes$fParsecTestType$fPrettyTestType$fNFDataTestType$fBinaryTestType$fGenericTestType$fShowTestType$fReadTestType $fEqTestType$fDataTestTypeTestSuiteInterfaceTestSuiteExeV10TestSuiteLibV09TestSuiteUnsupported$fSemigroupTestSuiteInterface$fMonoidTestSuiteInterface$fNFDataTestSuiteInterface$fBinaryTestSuiteInterface$fEqTestSuiteInterface$fGenericTestSuiteInterface$fReadTestSuiteInterface$fShowTestSuiteInterface$fDataTestSuiteInterfacePackageIdentifierpkgName pkgVersion PackageId$fNFDataPackageIdentifier$fParsecPackageIdentifier$fPrettyPackageIdentifier$fBinaryPackageIdentifier$fGenericPackageIdentifier$fReadPackageIdentifier$fShowPackageIdentifier$fEqPackageIdentifier$fOrdPackageIdentifier$fDataPackageIdentifier DefUnitId unDefUnitIdUnitIdunUnitIdmkUnitIdnewSimpleUnitIdmkLegacyUnitIdgetHSLibraryNameunsafeMkDefUnitId$fIsStringUnitId$fParsecUnitId$fPrettyUnitId$fBinaryUnitId$fParsecDefUnitId$fGenericUnitId $fReadUnitId $fShowUnitId $fEqUnitId $fOrdUnitId $fDataUnitId$fNFDataUnitId$fGenericDefUnitId$fReadDefUnitId$fShowDefUnitId $fEqDefUnitId$fOrdDefUnitId$fDataDefUnitId$fBinaryDefUnitId$fNFDataDefUnitId$fPrettyDefUnitIdModule$fNFDataModule$fParsecModule$fPrettyModule$fBinaryModule$fGenericModule $fReadModule $fShowModule $fEqModule $fOrdModule $fDataModuleOpenModuleSubst OpenModule OpenModuleVar OpenUnitIdIndefFullUnitIdDefiniteUnitIdopenUnitIdFreeHoles mkOpenUnitId mkDefUnitIdopenModuleFreeHolesdispOpenModuleSubstdispOpenModuleSubstEntryparsecOpenModuleSubstparsecOpenModuleSubstEntryopenModuleSubstFreeHolesabstractUnitIdhashModuleSubst$fParsecOpenModule$fPrettyOpenModule$fNFDataOpenModule$fBinaryOpenModule$fParsecOpenUnitId$fPrettyOpenUnitId$fNFDataOpenUnitId$fBinaryOpenUnitId$fGenericOpenModule$fReadOpenModule$fShowOpenModule$fEqOpenModule$fOrdOpenModule$fDataOpenModule$fGenericOpenUnitId$fReadOpenUnitId$fShowOpenUnitId$fEqOpenUnitId$fOrdOpenUnitId$fDataOpenUnitId ExposedModule exposedNameexposedReexport$fNFDataExposedModule$fBinaryExposedModule$fParsecExposedModule$fPrettyExposedModule$fEqExposedModule$fGenericExposedModule$fReadExposedModule$fShowExposedModuleModSubstmodSubst $fModSubst(,) $fModSubst[] $fModSubstMap $fModSubstSet$fModSubstOpenUnitId$fModSubstOpenModuleFullDb FullUnitIdexpandOpenUnitId expandUnitId$fShowFullUnitId$fGenericFullUnitId nonExistentPackageThisIsCabalBugfakePackageName fakePackageIdMungedPackageId mungedName mungedVersioncomputeCompatPackageId$fNFDataMungedPackageId$fParsecMungedPackageId$fPrettyMungedPackageId$fBinaryMungedPackageId$fGenericMungedPackageId$fReadMungedPackageId$fShowMungedPackageId$fEqMungedPackageId$fOrdMungedPackageId$fDataMungedPackageIdLegacyExeDependency$fParsecLegacyExeDependency$fPrettyLegacyExeDependency$fNFDataLegacyExeDependency$fBinaryLegacyExeDependency$fGenericLegacyExeDependency$fReadLegacyExeDependency$fShowLegacyExeDependency$fEqLegacyExeDependency$fDataLegacyExeDependency ExeDependencyqualifiedExeName$fParsecExeDependency$fPrettyExeDependency$fNFDataExeDependency$fBinaryExeDependency$fGenericExeDependency$fReadExeDependency$fShowExeDependency$fEqExeDependency$fDataExeDependency Dependency depPkgName depVerRange depLibrariesthisPackageVersionnotThisPackageVersionsimplifyDependency$fParsecDependency$fPrettyDependency$fNFDataDependency$fBinaryDependency$fGenericDependency$fReadDependency$fShowDependency$fEqDependency$fDataDependencySetupBuildInfo setupDependsdefaultSetupDepends$fSemigroupSetupBuildInfo$fMonoidSetupBuildInfo$fNFDataSetupBuildInfo$fBinarySetupBuildInfo$fGenericSetupBuildInfo$fShowSetupBuildInfo$fEqSetupBuildInfo$fReadSetupBuildInfo$fDataSetupBuildInfo DependencyMaptoDepMap fromDepMap constrainBy$fSemigroupDependencyMap$fMonoidDependencyMap$fShowDependencyMap$fReadDependencyMap BenchmarkTypeBenchmarkTypeExeBenchmarkTypeUnknownknownBenchmarkTypes$fParsecBenchmarkType$fPrettyBenchmarkType$fNFDataBenchmarkType$fBinaryBenchmarkType$fGenericBenchmarkType$fShowBenchmarkType$fReadBenchmarkType$fEqBenchmarkType$fDataBenchmarkTypeBenchmarkInterfaceBenchmarkExeV10BenchmarkUnsupported$fSemigroupBenchmarkInterface$fMonoidBenchmarkInterface$fNFDataBenchmarkInterface$fBinaryBenchmarkInterface$fEqBenchmarkInterface$fGenericBenchmarkInterface$fReadBenchmarkInterface$fShowBenchmarkInterface$fDataBenchmarkInterfacePackageInstalledinstalledDepends HasUnitIdinstalledUnitIdHasMungedPackageIdmungedIdPackage packageId mungedName'mungedVersion' packageNamepackageVersion$fPackagePackageIdentifier#$fHasMungedPackageIdMungedPackageId AnnotatedIdann_pid ann_cnameann_id$fFunctorAnnotatedId$fPackageAnnotatedId$fOrdAnnotatedId$fEqAnnotatedId$fShowAnnotatedIdComponentInclude ci_ann_id ci_renaming ci_implicitci_idci_pkgidci_cname AbiDependency depUnitId depAbiHash$fNFDataAbiDependency$fBinaryAbiDependency$fParsecAbiDependency$fPrettyAbiDependency$fEqAbiDependency$fGenericAbiDependency$fReadAbiDependency$fShowAbiDependencyGPLAGPLLGPLBSD2BSD3BSD4MPLApache PublicDomainAllRightsReservedUnspecifiedLicense OtherLicenseUnknownLicense knownLicenses licenseToSPDXlicenseFromSPDXInstalledPackageInfosourcePackageId sourceLibNameinstalledComponentId_ libVisibilityinstantiatedWithcompatPackageKeylicense copyright maintainerauthor stabilityhomepagepkgUrlsynopsis descriptioncategoryabiHash indefiniteexposedexposedModules hiddenModulestrusted importDirs libraryDirslibraryDynDirsdataDir hsLibrariesextraLibrariesextraGHCiLibraries includeDirsincludesdepends abiDepends ccOptions cxxOptions ldOptions frameworkDirs frameworkshaddockInterfaces haddockHTMLspkgRootmungedPackageIdmungedPackageNameemptyInstalledPackageInfo$fIsNodeInstalledPackageInfo&$fPackageInstalledInstalledPackageInfo$fHasUnitIdInstalledPackageInfo$fPackageInstalledPackageInfo($fHasMungedPackageIdInstalledPackageInfo$fNFDataInstalledPackageInfo$fBinaryInstalledPackageInfo$fEqInstalledPackageInfo$fGenericInstalledPackageInfo$fReadInstalledPackageInfo$fShowInstalledPackageInfoKnownExtensionOverlappingInstancesUndecidableInstancesIncoherentInstancesDoRec RecursiveDoParallelListCompMultiParamTypeClassesMonomorphismRestrictionFunctionalDependencies Rank2Types RankNTypesPolymorphicComponentsExistentialQuantificationScopedTypeVariablesPatternSignaturesImplicitParamsFlexibleContextsFlexibleInstancesEmptyDataDeclsCPPKindSignatures BangPatternsTypeSynonymInstancesTemplateHaskellForeignFunctionInterfaceArrowsGenericsImplicitPreludeNamedFieldPuns PatternGuardsGeneralizedNewtypeDerivingGeneralisedNewtypeDerivingExtensibleRecordsRestrictedTypeSynonyms HereDocuments MagicHash TypeFamiliesStandaloneDeriving UnicodeSyntaxUnliftedFFITypesInterruptibleFFICApiFFILiberalTypeSynonyms TypeOperatorsRecordWildCards RecordPunsDisambiguateRecordFieldsTraditionalRecordSyntaxOverloadedStringsGADTs GADTSyntax MonoPatBindsRelaxedPolyRecExtendedDefaultRules UnboxedTuplesDeriveDataTypeable DeriveGenericDefaultSignatures InstanceSigsConstrainedClassMethodsPackageImportsImpredicativeTypesNewQualifiedOperatorsPostfixOperators QuasiQuotesTransformListCompMonadComprehensions ViewPatterns XmlSyntaxRegularPatterns TupleSectionsGHCForeignImportPrimNPlusKPatternsDoAndIfThenElse MultiWayIf LambdaCaseRebindableSyntaxExplicitForAllDatatypeContextsMonoLocalBinds DeriveFunctorDeriveTraversableDeriveFoldableNondecreasingIndentation SafeImportsSafe TrustworthyUnsafeConstraintKinds PolyKinds DataKindsParallelArraysRoleAnnotationsOverloadedLists EmptyCaseAutoDeriveTypeableNegativeLiteralsBinaryLiterals NumDecimalsNullaryTypeClassesExplicitNamespacesAllowAmbiguousTypes JavaScriptFFIPatternSynonymsPartialTypeSignaturesNamedWildCardsDeriveAnyClass DeriveLiftStaticPointers StrictData ApplicativeDoDuplicateRecordFieldsTypeApplications TypeInTypeUndecidableSuperClassesMonadFailDesugaringTemplateHaskellQuotesOverloadedLabelsTypeFamilyDependenciesDerivingStrategies DerivingVia UnboxedSumsHexFloatLiteralsBlockArgumentsNumericUnderscoresQuantifiedConstraints StarIsTypeEmptyDataDeriving ExtensionEnableExtensionDisableExtensionUnknownExtensionLanguage Haskell98 Haskell2010UnknownLanguageknownLanguagesclassifyLanguagedeprecatedExtensionsclassifyExtension$fParsecLanguage$fPrettyLanguage$fNFDataLanguage$fBinaryLanguage$fPrettyKnownExtension$fNFDataKnownExtension$fBinaryKnownExtension$fParsecExtension$fPrettyExtension$fNFDataExtension$fBinaryExtension$fGenericLanguage$fShowLanguage$fReadLanguage $fEqLanguage$fDataLanguage$fGenericKnownExtension$fShowKnownExtension$fReadKnownExtension$fEqKnownExtension$fOrdKnownExtension$fEnumKnownExtension$fBoundedKnownExtension$fDataKnownExtension$fGenericExtension$fShowExtension$fReadExtension $fEqExtension$fOrdExtension$fDataExtensionAbiTagNoAbiTag CompilerInfocompilerInfoIdcompilerInfoAbiTagcompilerInfoCompatcompilerInfoLanguagescompilerInfoExtensions CompilerIdPerCompilerFlavorCompilerFlavorGHCGHCJSNHCYHCHugsHBCHeliumJHCLHCUHCEta HaskellSuite OtherCompilerknownCompilerFlavorsclassifyCompilerFlavorbuildCompilerFlavorbuildCompilerIddefaultCompilerFlavorperCompilerFlavorToList abiTagStringunknownCompilerInfo$fParsecCompilerFlavor$fPrettyCompilerFlavor$fNFDataCompilerFlavor$fBinaryCompilerFlavor$fMonoidPerCompilerFlavor$fSemigroupPerCompilerFlavor$fNFDataPerCompilerFlavor$fBinaryPerCompilerFlavor$fParsecCompilerId$fPrettyCompilerId$fNFDataCompilerId$fBinaryCompilerId$fParsecAbiTag$fPrettyAbiTag$fBinaryAbiTag$fBinaryCompilerInfo$fGenericCompilerFlavor$fShowCompilerFlavor$fReadCompilerFlavor$fEqCompilerFlavor$fOrdCompilerFlavor$fDataCompilerFlavor$fGenericPerCompilerFlavor$fShowPerCompilerFlavor$fReadPerCompilerFlavor$fEqPerCompilerFlavor$fDataPerCompilerFlavor$fEqCompilerId$fGenericCompilerId$fOrdCompilerId$fReadCompilerId$fShowCompilerId $fEqAbiTag$fGenericAbiTag $fShowAbiTag $fReadAbiTag$fGenericCompilerInfo$fShowCompilerInfo$fReadCompilerInfo BuildInfo buildable buildToolsbuildToolDepends cppOptions asmOptions cmmOptionspkgconfigDependsextraFrameworkDirs asmSources cmmSourcescSources cxxSources jsSources hsSourceDirs otherModulesvirtualModulesautogenModulesdefaultLanguageotherLanguagesdefaultExtensionsotherExtensions oldExtensions extraLibs extraGHCiLibsextraBundledLibsextraLibFlavoursextraDynLibFlavours extraLibDirsautogenIncludesinstallIncludes profOptions sharedOptions staticOptionscustomFieldsBItargetBuildDependsmixinsemptyBuildInfo allLanguages allExtensionsusedExtensionsusesTemplateHaskellOrQQ hcOptions hcProfOptionshcSharedOptionshcStaticOptions$fSemigroupBuildInfo$fMonoidBuildInfo$fNFDataBuildInfo$fBinaryBuildInfo$fGenericBuildInfo$fShowBuildInfo$fReadBuildInfo $fEqBuildInfo$fDataBuildInfoHookedBuildInfoemptyHookedBuildInfo HasBuildInfostraverseBuildInfos HasBuildInfo buildInfo$fHasBuildInfoBuildInfo TestSuitetestName testInterface testBuildInfoemptyTestSuitetestType testModulestestModulesAutogen$fSemigroupTestSuite$fMonoidTestSuite$fNFDataTestSuite$fBinaryTestSuite$fHasBuildInfoTestSuite$fGenericTestSuite$fShowTestSuite$fReadTestSuite $fEqTestSuite$fDataTestSuiteLibrarylibNamereexportedModules signatures libExposed libBuildInfo emptyLibraryexplicitLibModuleslibModulesAutogen$fSemigroupLibrary$fMonoidLibrary$fNFDataLibrary$fBinaryLibrary$fHasBuildInfoLibrary$fGenericLibrary $fShowLibrary $fEqLibrary $fReadLibrary $fDataLibraryLibVersionInfo ForeignLibforeignLibNameforeignLibTypeforeignLibOptionsforeignLibBuildInfoforeignLibVersionInfoforeignLibVersionLinuxforeignLibModDefFilemkLibVersionInfolibVersionInfoCRAlibVersionNumberlibVersionNumberShowlibVersionMajoremptyForeignLibforeignLibModulesforeignLibIsSharedforeignLibVersion$fParsecLibVersionInfo$fPrettyLibVersionInfo$fNFDataLibVersionInfo$fBinaryLibVersionInfo$fReadLibVersionInfo$fShowLibVersionInfo$fOrdLibVersionInfo$fMonoidForeignLib$fSemigroupForeignLib$fNFDataForeignLib$fBinaryForeignLib$fHasBuildInfoForeignLib$fDataLibVersionInfo$fEqLibVersionInfo$fGenericLibVersionInfo$fGenericForeignLib$fShowForeignLib$fReadForeignLib$fEqForeignLib$fDataForeignLib ExecutableexeName modulePathexeScopeemptyExecutable exeModulesexeModulesAutogen$fSemigroupExecutable$fMonoidExecutable$fNFDataExecutable$fBinaryExecutable$fHasBuildInfoExecutable$fGenericExecutable$fShowExecutable$fReadExecutable$fEqExecutable$fDataExecutable exeBuildInfo Benchmark benchmarkNamebenchmarkInterfacebenchmarkBuildInfoemptyBenchmark benchmarkTypebenchmarkModulesbenchmarkModulesAutogen$fSemigroupBenchmark$fMonoidBenchmark$fHasBuildInfoBenchmark$fNFDataBenchmark$fBinaryBenchmark$fGenericBenchmark$fShowBenchmark$fReadBenchmark $fEqBenchmark$fDataBenchmark ComponentCLibCFLibCExeCTestCBench foldComponentcomponentBuildInfocomponentBuildable componentNamepartitionComponents$fHasBuildInfoComponent$fSemigroupComponent$fShowComponent $fEqComponent$fReadComponentComponentDisabledReasonDisabledComponentDisabledAllTestsDisabledAllBenchmarksDisabledAllButOneComponentRequestedSpecOneComponentRequestedSpectestsRequestedbenchmarksRequesteddefaultComponentRequestedSpeccomponentEnabledcomponentNameRequestedcomponentDisabledReason$fBinaryComponentRequestedSpec$fGenericComponentRequestedSpec$fReadComponentRequestedSpec$fShowComponentRequestedSpec$fEqComponentRequestedSpecPackageDescriptionspecVersionRawpackage licenseRaw licenseFiles testedWith bugReports sourceReposcustomFieldsPD buildTypeRawsetupBuildInfolibrary subLibraries executables foreignLibs testSuites benchmarks dataFiles extraSrcFiles extraTmpFiles extraDocFiles specVersion specVersion'license' buildTypeemptyPackageDescription hasPublicLibhasLibs allLibrarieswithLibhasExeswithExehasTestswithTest hasBenchmarks withBenchmarkhasForeignLibswithForeignLib allBuildInfoenabledBuildInfosallBuildDependsenabledBuildDependsupdatePackageDescription pkgComponentspkgBuildableComponentsenabledComponentslookupComponent getComponent!$fHasBuildInfosPackageDescription$fPackagePackageDescription$fNFDataPackageDescription$fBinaryPackageDescription$fGenericPackageDescription$fShowPackageDescription$fReadPackageDescription$fEqPackageDescription$fDataPackageDescriptionConfVarImplFlagAssignmentFlagNameMkFlagflagNameflagDescription flagDefault flagManualGenericPackageDescriptionpackageDescriptiongenPackageFlags condLibrarycondSubLibrariescondForeignLibscondExecutablescondTestSuitescondBenchmarksemptyGenericPackageDescription emptyFlag mkFlagName unFlagNamemkFlagAssignmentunFlagAssignmentnullFlagAssignmentlookupFlagAssignmentinsertFlagAssignmentdiffFlagAssignmentfindDuplicateFlagAssignments showFlagValuedispFlagAssignmentparsecFlagAssignment$fParsecFlagName$fPrettyFlagName$fBinaryFlagName$fIsStringFlagName $fNFDataFlag$fShowFlagAssignment$fReadFlagAssignment$fMonoidFlagAssignment$fSemigroupFlagAssignment$fOrdFlagAssignment$fEqFlagAssignment$fNFDataConfVar$fBinaryConfVar($fHasBuildInfosGenericPackageDescription!$fNFDataGenericPackageDescription!$fBinaryGenericPackageDescription"$fPackageGenericPackageDescription $fEqFlagName$fGenericFlagName $fOrdFlagName$fShowFlagName$fReadFlagName$fDataFlagName$fNFDataFlagName $fDataFlag$fBinaryFlagAssignment$fGenericFlagAssignment$fNFDataFlagAssignment $fEqConfVar $fShowConfVar $fDataConfVar$fGenericConfVar$fShowGenericPackageDescription$fEqGenericPackageDescription$fDataGenericPackageDescription"$fGenericGenericPackageDescription allCondTrees_OS_Arch_Flag_ImplcomponentModulesdesugarBuildToolgetAllToolDependencies isInternalgetAllInternalToolDependenciesPathTemplateEnv PathTemplateCopyDest NoCopyDestCopyToCopyToDbInstallDirTemplates InstallDirsprefixbindirlibdir libsubdir dynlibdirflibdir libexecdir libexecsubdir includedirdatadir datasubdirdocdirmandirhtmldir haddockdir sysconfdircombineInstallDirsdefaultInstallDirsdefaultInstallDirs'substituteInstallDirTemplatesabsoluteInstallDirsprefixRelativeInstallDirstoPathTemplatefromPathTemplatecombinePathTemplatesubstPathTemplateinitialPathTemplateEnvpackageTemplateEnvcompilerTemplateEnvplatformTemplateEnvabiTemplateEnvinstallDirsTemplateEnv$fSemigroupInstallDirs$fMonoidInstallDirs$fBinaryInstallDirs$fBinaryCopyDest$fReadPathTemplate$fShowPathTemplate$fBinaryPathTemplate$fEqInstallDirs$fReadInstallDirs$fShowInstallDirs$fFunctorInstallDirs$fGenericInstallDirs $fEqCopyDest$fShowCopyDest$fGenericCopyDest$fEqPathTemplate$fOrdPathTemplate$fGenericPathTemplate FilePathNT getFilePathNT TestedWith getTestedWith SpecLicensegetSpecLicense SpecVersiongetSpecVersionMQuoted getMQuotedToken' getToken'getTokenListSep prettySepparseSep NoCommaFSepFSepVCat CommaFSep CommaVCatalaListalaList'$fSepNoCommaFSep $fSepFSep $fSepVCat$fSepCommaFSep$fSepCommaVCat $fPrettyList $fParsecList$fNewtype[]List $fPrettyToken $fParsecToken$fNewtype[]Token$fPrettyToken'$fParsecToken'$fNewtype[]Token'$fPrettyMQuoted$fParsecMQuoted$fNewtypeaMQuoted$fPrettySpecVersion$fParsecSpecVersion$fNewtypeEitherSpecVersion$fPrettySpecLicense$fParsecSpecLicense$fNewtypeEitherSpecLicense$fPrettyTestedWith$fParsecTestedWith$fNewtype(,)TestedWith$fPrettyFilePathNT$fParsecFilePathNT$fNewtype[]FilePathNTTempFileOptionsoptKeepTempFiles cabalVersiondieNoVerbositydieWithLocation'die' dieNoWraptopHandlerWith topHandlerwarnnotice noticeNoWrap noticeDoc setupMessageinfo infoNoWrapdebug debugNoWrap chattyTryhandleDoesNotExistwithOutputMarker maybeExitprintRawCommandAndArgsprintRawCommandAndArgsAndEnv rawSystemExitrawSystemExitCoderawSystemExitWithEnvrawSystemIOWithEnvcreateProcessWithEnvrawSystemStdoutrawSystemStdInOutfindProgramVersionxargsfindFile findFileExfindFileWithExtensionfindAllFilesWithExtensionfindFileWithExtension' findFirstFilefindModuleFilesfindModuleFilesExfindModuleFilefindModuleFileExgetDirectoryContentsRecursiveisInSearchPathaddLibraryPathmoreRecentFileexistsAndIsMoreRecentThancreateDirectoryIfMissingVerbosecopyFileVerboseinstallOrdinaryFileinstallExecutableFileinstallMaybeExecutableFile copyFileTo copyFilesinstallOrdinaryFilesinstallExecutableFilesinstallMaybeExecutableFilesinstallDirectoryContentscopyDirectoryRecursivedoesExecutableExistdefaultTempFileOptions withTempFilewithTempFileExwithTempDirectorywithTempDirectoryEx rewriteFileEx currentDirshortRelativePathdropExeExtension exeExtensionsdefaultPackageDesctryFindPackageDescfindHookedPackageDesc $fEqTraceWhenNubListR fromNubListRNubList fromNubList toNubList overNubList toNubListR overNubListR$fBinaryNubList $fReadNubList $fShowNubList$fSemigroupNubList$fMonoidNubList$fReadNubListR$fShowNubListR$fSemigroupNubListR$fMonoidNubListR $fEqNubList$fGenericNubList $fEqNubListR LogProgressrunLogProgress warnProgress infoProgress dieProgressaddProgressCtx$fMonadLogProgress$fApplicativeLogProgress$fFunctorLogProgresswithResponseFileProgramSearchPathEntryProgramSearchPathDirProgramSearchPathDefaultProgramSearchPathdefaultProgramSearchPathfindProgramOnSearchPathprogramSearchPathAsPATHVargetSystemSearchPath$fBinaryProgramSearchPathEntry$fEqProgramSearchPathEntry$fGenericProgramSearchPathEntryProgramLocation UserSpecified FoundOnSystem locationPathConfiguredProgram programIdprogramVersionprogramDefaultArgsprogramOverrideArgsprogramOverrideEnvprogramPropertiesprogramLocationprogramMonitorFilesProgArgProgram programNameprogramFindLocationprogramFindVersionprogramPostConfprogramNormaliseArgs programPathsuppressOverrideArgs simpleProgramsimpleConfiguredProgram$fBinaryProgramLocation$fBinaryConfiguredProgram $fShowProgram$fEqProgramLocation$fGenericProgramLocation$fReadProgramLocation$fShowProgramLocation$fEqConfiguredProgram$fGenericConfiguredProgram$fReadConfiguredProgram$fShowConfiguredProgram IOEncodingIOEncodingTextIOEncodingUTF8ProgramInvocationprogInvokePathprogInvokeArgs progInvokeEnvprogInvokePathEnv progInvokeCwdprogInvokeInputprogInvokeInputEncodingprogInvokeOutputEncodingemptyProgramInvocationsimpleProgramInvocationprogramInvocationrunProgramInvocationgetProgramInvocationOutput#getProgramInvocationOutputAndErrorsgetEffectiveEnvironmentmultiStageProgramInvocationinvocationAsSystemScriptinvocationAsShellScriptinvocationAsBatchFilemarkupunionGlobGlobSyntaxErrorStarInDirectoryStarInFileNameStarInExtensionNoExtensionOnStar EmptyGlobLiteralFileNameGlobStarVersionDoesNotSupportGlobStarVersionDoesNotSupportGlob GlobResult GlobMatchGlobWarnMultiDotGlobMissingDirectoryexplainGlobSyntaxErrorfileGlobMatches parseFileGlobmatchDirFileGlobrunDirFileGlob$fShowGlobResult$fEqGlobResult$fOrdGlobResult$fFunctorGlobResult$fEqGlobSyntaxError$fShowGlobSyntaxErrorProfDetailLevelProfDetailNoneProfDetailDefaultProfDetailExportedFunctionsProfDetailToplevelFunctionsProfDetailAllFunctionsProfDetailOtherDebugInfoLevel NoDebugInfoMinimalDebugInfoNormalDebugInfoMaximalDebugInfoOptimisationLevelNoOptimisationNormalOptimisationMaximumOptimisationPackageDBStack PackageDBGlobalPackageDB UserPackageDBSpecificPackageDBCompiler compilerIdcompilerAbiTagcompilerCompatcompilerLanguagescompilerExtensionscompilerPropertiesshowCompilerIdshowCompilerIdWithAbicompilerFlavorcompilerVersioncompilerCompatFlavorcompilerCompatVersion compilerInforegistrationPackageDBabsolutePackageDBPathsabsolutePackageDBPathflagToOptimisationLevelflagToDebugInfoLevelunsupportedLanguageslanguageToFlagsunsupportedExtensionsextensionsToFlagsparmakeSupportedreexportedModulesSupportedrenamingPackageFlagsSupportedunifiedIPIDRequiredpackageKeySupportedunitIdSupportedbackpackSupportedlibraryDynDirSupportedarResponseFilesSupportedcoverageSupportedprofilingSupportedflagToProfDetailLevelknownProfDetailLevelsshowProfDetailLevel$fBinaryPackageDB$fBinaryOptimisationLevel$fBinaryDebugInfoLevel$fBinaryCompiler$fBinaryProfDetailLevel $fEqPackageDB$fGenericPackageDB$fOrdPackageDB$fShowPackageDB$fReadPackageDB$fBoundedOptimisationLevel$fEnumOptimisationLevel$fEqOptimisationLevel$fGenericOptimisationLevel$fReadOptimisationLevel$fShowOptimisationLevel$fBoundedDebugInfoLevel$fEnumDebugInfoLevel$fEqDebugInfoLevel$fGenericDebugInfoLevel$fReadDebugInfoLevel$fShowDebugInfoLevel $fEqCompiler$fGenericCompiler$fShowCompiler$fReadCompiler$fEqProfDetailLevel$fGenericProfDetailLevel$fReadProfDetailLevel$fShowProfDetailLevel GhcImplInfosupportsHaskell2010 reportsNoExtalwaysNondecIndentflagGhciScript flagProfAutoflagPackageConf flagDebugInfosupportsDebugLevelssupportsPkgEnvFilesflagWarnMissingHomeModules getImplInfo GhcProfAutoGhcProfAutoAllGhcProfAutoToplevelGhcProfAutoExportedGhcDynLinkMode GhcStaticOnlyGhcDynamicOnlyGhcStaticAndDynamicGhcOptimisationGhcNoOptimisationGhcNormalOptimisationGhcMaximumOptimisationGhcSpecialOptimisationGhcModeGhcModeCompile GhcModeLink GhcModeMakeGhcModeInteractiveGhcModeAbiHash GhcOptions ghcOptMode ghcOptExtraghcOptExtraDefaultghcOptInputFilesghcOptInputModulesghcOptOutputFileghcOptOutputDynFileghcOptSourcePathClearghcOptSourcePathghcOptThisUnitIdghcOptThisComponentIdghcOptInstantiatedWith ghcOptNoCodeghcOptPackageDBsghcOptPackagesghcOptHideAllPackagesghcOptWarnMissingHomeModulesghcOptNoAutoLinkPackagesghcOptLinkLibsghcOptLinkLibPathghcOptLinkOptionsghcOptLinkFrameworksghcOptLinkFrameworkDirs ghcOptNoLinkghcOptLinkNoHsMainghcOptLinkModDefFilesghcOptCcOptionsghcOptCxxOptionsghcOptAsmOptionsghcOptCppOptionsghcOptCppIncludePathghcOptCppIncludesghcOptFfiIncludesghcOptLanguageghcOptExtensionsghcOptExtensionMapghcOptOptimisationghcOptDebugInfoghcOptProfilingModeghcOptProfilingAutoghcOptSplitSectionsghcOptSplitObjs ghcOptNumJobs ghcOptHPCDirghcOptGHCiScriptsghcOptHiSuffixghcOptObjSuffixghcOptDynHiSuffixghcOptDynObjSuffix ghcOptHiDir ghcOptObjDirghcOptOutputDir ghcOptStubDirghcOptDynLinkModeghcOptStaticLib ghcOptShared ghcOptFPicghcOptDylibName ghcOptRPathsghcOptVerbosityghcOptExtraPath ghcOptCabalnormaliseGhcArgsrunGHC ghcInvocationrenderGhcOptionspackageDbArgsDb$fSemigroupGhcOptions$fMonoidGhcOptions $fShowGhcMode $fEqGhcMode$fShowGhcOptimisation$fEqGhcOptimisation$fShowGhcDynLinkMode$fEqGhcDynLinkMode$fShowGhcProfAuto$fEqGhcProfAuto$fShowGhcOptions$fGenericGhcOptionsbuiltinPrograms ghcProgram runghcProgram ghcPkgProgram ghcjsProgramghcjsPkgProgram hmakeProgram jhcProgram uhcProgram hpcProgramhaskellSuiteProgramhaskellSuitePkgProgram happyProgram alexProgram gccProgram arProgram stripProgram hsc2hsProgram c2hsProgram cpphsProgramhscolourProgramdoctestProgramhaddockProgramgreencardProgram ldProgram tarProgram cppProgrampkgConfigProgram ProgramDbemptyProgramDbdefaultProgramDbrestoreProgramDbaddKnownProgramaddKnownProgramslookupKnownProgram knownProgramsgetProgramSearchPathsetProgramSearchPathmodifyProgramSearchPathuserSpecifyPathuserMaybeSpecifyPathuserSpecifyArgsuserSpecifyPathsuserSpecifyArgssuserSpecifiedArgs lookupProgram updateProgramconfiguredProgramsconfigureProgramunconfigureProgramconfigureAllKnownProgramsreconfigureProgramsrequireProgramlookupProgramVersionrequireProgramVersion$fBinaryProgramDb$fReadProgramDb$fShowProgramDb runProgramgetProgramOutput runDbProgramgetDbProgramOutputstripExestripLib CommandSpecCommand CommandType NormalCommand HiddenCommand CommandParse CommandHelp CommandList CommandErrorsCommandReadyToGo MkOptDescrArgPlaceHolderOptFlagsLFlagsSFlagsOptDescrReqArgOptArg ChoiceOptBoolOpt OptionField optionDescr DescriptionShowOrParseArgsShowArgs ParseArgs CommandUI commandNamecommandSynopsis commandUsagecommandDescription commandNotescommandDefaultFlagscommandOptions multiOptionreqArgoptArgreqArg'optArg'noArgboolOptboolOpt' choiceOptchoiceOptFromEnum liftOptioncommandShowOptions usageDefaultusageAlternatives mkCommandUIcommandParseArgs hiddenCommandcommandAddAction commandsRun noExtraFlagsgetNormalCommandDescriptions helpCommandUIcommandFromSpec$fFunctorCommandParseShowBuildInfoFlagsbuildInfoBuildFlagsbuildInfoOutputFileBenchmarkFlagsbenchmarkDistPrefbenchmarkVerbositybenchmarkOptions TestFlags testDistPref testVerbosity testHumanLogtestMachineLogtestShowDetails testKeepTix testWrappertestFailWhenNoTestSuites testOptionsTestShowDetailsNeverFailuresAlways StreamingDirect ReplFlagsreplProgramPathsreplProgramArgs replDistPref replVerbosity replReloadreplReplOptions BuildFlagsbuildProgramPathsbuildProgramArgs buildDistPrefbuildVerbosity buildNumJobs buildArgsbuildCabalFilePath CleanFlags cleanSaveConf cleanDistPrefcleanVerbositycleanCabalFilePath HaddockFlagshaddockProgramPathshaddockProgramArgs haddockHoogle haddockHtmlhaddockHtmlLocationhaddockForHackagehaddockExecutableshaddockTestSuiteshaddockBenchmarkshaddockForeignLibshaddockInternal haddockCsshaddockLinkedSourcehaddockQuickJumphaddockHscolourCsshaddockContentshaddockDistPrefhaddockKeepTempFileshaddockVerbosityhaddockCabalFilePath haddockArgs HaddockTarget ForHackageForDevelopment DoctestFlagsdoctestProgramPathsdoctestProgramArgsdoctestDistPrefdoctestVerbosity HscolourFlags hscolourCSShscolourExecutableshscolourTestSuiteshscolourBenchmarkshscolourForeignLibshscolourDistPrefhscolourVerbosityhscolourCabalFilePath RegisterFlags regPackageDB regGenScript regGenPkgConf regInPlace regDistPref regPrintId regVerbosityregArgsregCabalFilePath SDistFlags sDistSnapshotsDistDirectory sDistDistPrefsDistListSourcessDistVerbosity InstallFlagsinstallPackageDB installDestinstallDistPrefinstallUseWrapperinstallInPlaceinstallVerbosityinstallCabalFilePath CopyFlagscopyDest copyDistPref copyVerbositycopyArgscopyCabalFilePath ConfigFlags configArgsconfigPrograms_configProgramPathsconfigProgramArgsconfigProgramPathExtraconfigHcFlavor configHcPath configHcPkgconfigVanillaLib configProfLibconfigSharedLibconfigStaticLib configDynExeconfigFullyStaticExe configProfExe configProfconfigProfDetailconfigProfLibDetailconfigConfigureArgsconfigOptimizationconfigProgPrefixconfigProgSuffixconfigInstallDirsconfigScratchDirconfigExtraLibDirsconfigExtraFrameworkDirsconfigExtraIncludeDirs configIPID configCIDconfigDeterministicconfigDistPrefconfigCabalFilePathconfigVerbosityconfigUserInstallconfigPackageDBs configGHCiLibconfigSplitSectionsconfigSplitObjsconfigStripExesconfigStripLibsconfigConstraintsconfigDependenciesconfigInstantiateWithconfigConfigurationsFlags configTestsconfigBenchmarksconfigCoverageconfigLibCoverageconfigExactConfigurationconfigFlagErrorconfigRelocatableconfigDebugInfoconfigUseResponseFiles!configAllowDependingOnPrivateLibs GlobalFlags globalVersionglobalNumericVersiondefaultDistPrefdefaultGlobalFlags globalCommandemptyGlobalFlagsconfigProgramsconfigAbsolutePathsdefaultConfigFlagsconfigureCommandconfigureOptionsreadPackageDbListshowPackageDbListinstallDirsOptionsemptyConfigFlagsdefaultCopyFlags copyCommandemptyCopyFlagsdefaultInstallFlagsinstallCommandemptyInstallFlagsdefaultSDistFlags sdistCommandemptySDistFlagsdefaultRegisterFlagsregisterCommandunregisterCommandemptyRegisterFlagsemptyHscolourFlagsdefaultHscolourFlagshscolourCommanddefaultDoctestFlagsdoctestCommandemptyDoctestFlagsdefaultHaddockFlagshaddockCommandhaddockOptionsemptyHaddockFlagsdefaultCleanFlags cleanCommandemptyCleanFlagsdefaultBuildFlags buildCommand buildOptionsemptyBuildFlagsdefaultReplFlags replCommand replOptionsdefaultTestFlags testCommand testOptions'emptyTestFlagsdefaultBenchmarkFlagsbenchmarkCommandemptyBenchmarkFlagsprogramFlagsDescriptionprogramDbPaths'programDbOptionstrueArgfalseArgoptionDistPrefoptionVerbosity optionNumJobsdefaultShowBuildFlagsshowBuildInfoCommand configureArgsconfigureCCompilerconfigureLinker splitArgs$fSemigroupGlobalFlags$fMonoidGlobalFlags$fSemigroupConfigFlags$fMonoidConfigFlags$fEqConfigFlags$fBinaryConfigFlags$fSemigroupCopyFlags$fMonoidCopyFlags$fSemigroupInstallFlags$fMonoidInstallFlags$fSemigroupSDistFlags$fMonoidSDistFlags$fSemigroupRegisterFlags$fMonoidRegisterFlags$fSemigroupHscolourFlags$fMonoidHscolourFlags$fSemigroupDoctestFlags$fMonoidDoctestFlags$fParsecHaddockTarget$fPrettyHaddockTarget$fBinaryHaddockTarget$fSemigroupHaddockFlags$fMonoidHaddockFlags$fSemigroupCleanFlags$fMonoidCleanFlags$fSemigroupBuildFlags$fMonoidBuildFlags$fSemigroupReplFlags$fMonoidReplFlags$fSemigroupTestShowDetails$fMonoidTestShowDetails$fParsecTestShowDetails$fPrettyTestShowDetails$fBinaryTestShowDetails$fSemigroupTestFlags$fMonoidTestFlags$fSemigroupBenchmarkFlags$fMonoidBenchmarkFlags$fGenericGlobalFlags$fGenericConfigFlags$fReadConfigFlags$fShowConfigFlags$fShowCopyFlags$fGenericCopyFlags$fShowInstallFlags$fGenericInstallFlags$fShowSDistFlags$fGenericSDistFlags$fShowRegisterFlags$fGenericRegisterFlags$fShowHscolourFlags$fGenericHscolourFlags$fShowDoctestFlags$fGenericDoctestFlags$fEqHaddockTarget$fShowHaddockTarget$fGenericHaddockTarget$fShowHaddockFlags$fGenericHaddockFlags$fShowCleanFlags$fGenericCleanFlags$fReadBuildFlags$fShowBuildFlags$fGenericBuildFlags$fShowReplFlags$fGenericReplFlags$fEqTestShowDetails$fOrdTestShowDetails$fEnumTestShowDetails$fBoundedTestShowDetails$fGenericTestShowDetails$fShowTestShowDetails$fGenericTestFlags$fGenericBenchmarkFlags$fShowShowBuildInfoFlagsparseConditionextractConditionsfreeVars finalizePDflattenPackageDescriptiontransformAllBuildInfostransformAllBuildDepends$fSemigroupDepTestRslt$fMonoidDepTestRslt$fSemigroupPDTagged$fMonoidPDTagged$fShowPDTagged defaultMaindefaultMainArgs PrettyField PrettySection showFields showFields'genericFromParsecFieldsprettyFieldLinesprettySectionArgsfromParsecFields$fSemigroupMargin$fFunctorPrettyField$fFoldablePrettyField$fTraversablePrettyField $fEqMargin ParseResultrunParseResult recoverWithsetCabalSpecVersiongetCabalSpecVersion parseWarning parseWarnings parseFailureparseFatalFailureparseFatalFailure'readAndParseFile parseString$fMonadParseResult$fApplicativeParseResult$fFunctorParseResultparseConditionConfVarPrettyFieldGrammarprettyFieldGrammar $fFieldGrammarPrettyFieldGrammar$fApplicativePrettyFieldGrammar$fFunctorPrettyFieldGrammarParsecFieldGrammar MkSection NamelessFieldMkNamelessFieldFieldsnamelessFieldAnnparseFieldGrammarfieldGrammarKnownFieldListrunFieldParser'runFieldParserfieldLinesToStream $fFieldGrammarParsecFieldGrammar$fApplicativeParsecFieldGrammar$fEqNamelessField$fShowNamelessField$fFunctorNamelessField $fEqSection $fShowSection$fFunctorSection$fFunctorParsecFieldGrammarPrettyFieldGrammar'ParsecFieldGrammar'^^^partitionFields takeFieldsBenchmarkStanza_benchmarkStanzaBenchmarkType_benchmarkStanzaMainIs_benchmarkStanzaBenchmarkModule_benchmarkStanzaBuildInfoTestSuiteStanza_testStanzaTestType_testStanzaMainIs_testStanzaTestModule_testStanzaBuildInfopackageDescriptionFieldGrammarlibraryFieldGrammarforeignLibFieldGrammarexecutableFieldGrammartestStanzaTestTypetestStanzaMainIstestStanzaTestModuletestStanzaBuildInfotestSuiteFieldGrammarvalidateTestSuiteunvalidateTestSuitebenchmarkStanzaBenchmarkTypebenchmarkStanzaMainIsbenchmarkStanzaBenchmarkModulebenchmarkStanzaBuildInfobenchmarkFieldGrammarvalidateBenchmarkunvalidateBenchmarkbuildInfoFieldGrammarflagFieldGrammarsourceRepoFieldGrammarsetupBInfoFieldGrammar$fHasBuildInfoTestSuiteStanza$fHasBuildInfoBenchmarkStanzawriteGenericPackageDescriptionshowGenericPackageDescriptionppGenericPackageDescriptionwritePackageDescriptionshowPackageDescriptionwriteHookedBuildInfoshowHookedBuildInforeadGenericPackageDescriptionparseGenericPackageDescription#parseGenericPackageDescriptionMaybereadHookedBuildInfoparseHookedBuildInfoscanSpecVersion$fFromBuildInfoBenchmarkStanza$fFromBuildInfoTestSuiteStanza$fFromBuildInfoExecutable$fFromBuildInfoForeignLib$fFromBuildInfoBuildInfo $fEqSyntax $fShowSyntax FieldDescrsfieldDescrPrettyfieldDescrParsefieldDescrsToList$fFieldGrammarFieldDescrs$fApplicativeFieldDescrs$fFunctorFieldDescrsipiFieldGrammar$fPrettyExposedModules$fParsecExposedModules$fNewtype[]ExposedModules$fParsecCompatPackageKey$fPrettyCompatPackageKey$fNewtype[]CompatPackageKey$fParsecInstWith$fPrettyInstWith$fNewtype[]InstWith$fPrettySpecLicenseLenient$fParsecSpecLicenseLenient!$fNewtypeEitherSpecLicenseLenientinstalledComponentIdinstalledOpenUnitIdrequiredSignaturessourceComponentNameparseInstalledPackageInfoshowInstalledPackageInfoshowFullInstalledPackageInfoshowInstalledPackageInfoField#showSimpleInstalledPackageInfoFieldComponentLocalBuildInfoLibComponentLocalBuildInfoFLibComponentLocalBuildInfoExeComponentLocalBuildInfoTestComponentLocalBuildInfoBenchComponentLocalBuildInfocomponentLocalNamecomponentComponentIdcomponentUnitIdcomponentIsIndefinite_componentInstantiatedWithcomponentPackageDepscomponentIncludescomponentExeDepscomponentInternalDepscomponentCompatPackageKeycomponentCompatPackageNamecomponentExposedModulescomponentIsPubliccomponentIsIndefinitemaybeComponentInstantiatedWith$fIsNodeComponentLocalBuildInfo$fBinaryComponentLocalBuildInfo $fGenericComponentLocalBuildInfo$fReadComponentLocalBuildInfo$fShowComponentLocalBuildInfo TargetInfo targetCLBItargetComponent$fIsNodeTargetInfoRegisterOptionsregisterAllowOverwriteregisterMultiInstanceregisterSuppressFilesCheck HcPkgInfo hcPkgProgram noPkgDbStack noVerboseFlagsupportsDirDbsrequiresDirDbsnativeMultiInstancerecacheMultiInstancesuppressFilesCheckinvokedefaultRegisterOptionsregister unregisterrecacheexposedescribehidedumplistinitInvocationregisterInvocationunregisterInvocationrecacheInvocationexposeInvocationdescribeInvocationhideInvocationdumpInvocationlistInvocation SearchResultNone Unambiguous AmbiguousInstalledPackageIndex PackageIndexmerge deleteUnitIddeleteSourcePackageIddeletePackageName allPackagesallPackagesByNameallPackagesBySourcePackageId&allPackagesBySourcePackageIdAndLibName lookupUnitIdlookupComponentIdlookupSourcePackageIdlookupPackageIdlookupPackageNamelookupDependencylookupInternalDependency searchByNamesearchByNameSubstringdependencyCyclesbrokenPackagesdependencyClosurereverseDependencyClosuretopologicalOrderreverseTopologicalOrderdependencyGraphdependencyInconsistenciesmoduleNameIndex$fSemigroupPackageIndex$fMonoidPackageIndex$fBinaryPackageIndex$fEqPackageIndex$fGenericPackageIndex$fShowPackageIndex$fReadPackageIndexLocalBuildInfo configFlagsflagAssignmentcomponentEnabledSpecextraConfigArgsinstallDirTemplatescompiler hostPlatformbuildDir cabalFilePathcomponentGraphcomponentNameMap installedPkgs pkgDescrFile localPkgDescr withPrograms withPackageDBwithVanillaLib withProfLib withSharedLib withStaticLib withDynExewithFullyStaticExe withProfExewithProfLibDetailwithProfExeDetailwithOptimization withDebugInfo withGHCiLib splitSections splitObjs stripExes stripLibs exeCoverage libCoverage progPrefix progSuffix relocatablelocalComponentId localPackage localUnitIdlocalCompatPackageKeycomponentNameTargets' unitIdTarget'componentNameCLBIsallTargetsInBuildOrder'withAllTargetsInBuildOrder'neededTargetsInBuildOrder'withNeededTargetsInBuildOrder' testCoveragecomponentNameTargets unitIdTargetallTargetsInBuildOrderwithAllTargetsInBuildOrderneededTargetsInBuildOrderwithNeededTargetsInBuildOrder$fBinaryLocalBuildInfo$fGenericLocalBuildInfo$fReadLocalBuildInfo$fShowLocalBuildInfocomponentBuildDir withLibLBI withExeLBI withBenchLBI withTestLBIenabledTestLBIsenabledBenchLBIswithAllComponentsInBuildOrderallComponentsInBuildOrderdepLibraryPaths allLibModulesabsoluteComponentInstallDirsabsoluteInstallCommandDirs"prefixRelativeComponentInstallDirsTestLogsTestLog GroupLogstestOptionsReturned testResult TestSuiteLog testSuiteNametestLogslogFile PackageLogplatformlocalPackageLogcountTestResults suitePassed suiteFailed suiteErrortestSuiteLogPathsummarizePackage summarizeTestsummarizeSuiteFinishsummarizeSuiteStart$fReadTestLogs$fShowTestLogs $fEqTestLogs$fReadTestSuiteLog$fShowTestSuiteLog$fEqTestSuiteLog$fReadPackageLog$fShowPackageLog$fEqPackageLogcombineObjectFilescreateArLibArchiveWayVanillaProfDynmixDirtixDir tixFilePathhtmlDirguessWay markupTest markupPackage $fBoundedWay $fEnumWay$fEqWay $fReadWay $fShowWay QualLevelQL1QL2QL3BuildTargetProblemBuildTargetExpectedBuildTargetNoSuchBuildTargetAmbiguousUserBuildTargetProblemUserBuildTargetUnrecognised BuildTargetBuildTargetComponentBuildTargetModuleBuildTargetFileUserBuildTargetreadTargetInfosbuildTargetComponentNamereadBuildTargetsreadUserBuildTargetsreportUserBuildTargetProblemsshowUserBuildTargetshowBuildTargetresolveBuildTargetsreportBuildTargetProblems$fBinaryBuildTarget $fMonadMatch$fApplicativeMatch$fFunctorMatch$fMonadPlusMatch$fAlternativeMatch$fShowUserBuildTarget$fEqUserBuildTarget$fOrdUserBuildTarget$fEqBuildTarget$fShowBuildTarget$fGenericBuildTarget$fShowUserBuildTargetProblem$fShowBuildTargetProblem$fEnumQualLevel$fShowQualLevel$fEqComponentKind$fOrdComponentKind$fShowComponentKind$fShowMatchError$fEqMatchError $fShowMatch$fShowMaybeAmbiguoussrcPref hscolourPrefhaddockDirName haddockPrefautogenPackageModulesDirautogenComponentModulesDir cppHeaderNameautogenPathsModuleName haddockNamegetLibSourceFilesgetExeSourceFilesgetFLibSourceFilesgetSourceFiles exeBuildDir flibBuildDirmkGenericStaticLibName mkLibName mkProfLibNamemkGenericSharedLibNamemkSharedLibNamemkStaticLibNamemkGenericSharedBundledLibName exeExtension objExtension dllExtensionstaticLibExtension configuregetInstalledPackagesbuildLibbuildExe installLibregisterPackageinplacePackageDbPathCheckPackageContentOps doesFileExistdoesDirectoryExistgetDirectoryContentsgetFileContents PackageCheckPackageBuildImpossiblePackageBuildWarningPackageDistSuspiciousPackageDistSuspiciousWarnPackageDistInexcusable explanation checkPackagecheckConfiguredPackagecheckPackageFilescheckPackageContentcheckPackageFileNames$fShowPackageCheck$fEqPackageCheck$fOrdPackageCheckgeneratePathsModule pkgPathEnvVarrunTeststubName stubFilePathwriteSimpleTestStubsimpleTestStubstubMain stubWriteLoggenerateCabalMacrosHeadergeneratePackageVersionMacroscomputeComponentIdcomputeCompatPackageKeyConfiguredComponentMapConfiguredComponent cc_ann_id cc_component cc_public cc_exe_deps cc_includescc_cidcc_pkgidcc_namedispConfiguredComponenttoConfiguredComponentextendConfiguredComponentMaptoConfiguredComponentsnewPackageDepsBehaviourComponentsWithDepsComponentsGraphdispComponentsWithDepsmkComponentsGraphcomponentsGraphToListcomponentCycleMsg hstoolVersionnumericVersiongetCompilerVersion getExtensions getLanguages initPackageDB packageDbOptGhcEnvironmentFileEntryGhcEnvFileCommentGhcEnvFilePackageIdGhcEnvFilePackageDbGhcEnvFileClearPackageDbStackghcPlatformAndVersionStringsimpleGhcEnvironmentFilewriteGhcEnvironmentFilerenderGhcEnvironmentFile ParseErrorExcparseGhcEnvironmentFilereadGhcEnvironmentFile getGhcInfogetPackageDBContents getLibDirgetGlobalPackageDB getInstalledPackagesMonitorFilesreplLibstartInterpreter buildFLibreplFLibreplExe libAbiHashcomponentGhcOptionscomponentCcGhcOptions installExe installFLib isDynamic hcPkgInforunCmd mkBuildInfoinstall ModuleShapemodShapeProvidesmodShapeRequiresemptyModuleShapeshapeInstalledPackage$fModSubstModuleShape$fBinaryModuleShape$fEqModuleShape$fShowModuleShape$fGenericModuleShapePreModuleShapepreModShapeProvidespreModShapeRequirestoPreModuleShaperenamePreModuleShapemixLinkPreModuleShape$fEqPreModuleShape$fShowPreModuleShape$fGenericPreModuleShapeLinkedComponentMapLinkedComponent lc_ann_id lc_component lc_exe_deps lc_public lc_includeslc_sig_includeslc_shapelc_cidlc_pkgidlc_uidlc_instsdispLinkedComponenttoLinkedComponenttoLinkedComponentsextendLinkedComponentMap$fPackageLinkedComponentModTime getModTimeposixSecondsToModTime getFileAge getCurTimecalibrateMtimeChangeDelay $fReadModTime $fShowModTime$fBinaryModTime$fBoundedModTime $fEqModTime $fOrdModTime!configureComponentLocalBuildInfos setupMessage'generateRegistrationInfocreatePackageDBdoesPackageDBExistdeletePackageDB invokeHcPkggeneralInstalledPackageInfoinplaceInstalledPackageInfoabsoluteInstalledPackageInfointernalPackageDBPathPPSuffixHandler PreProcessorplatformIndependentrunPreProcessormkSimplePreProcessorrunSimplePreProcessorpreprocessComponent ppGreenCardppUnlitppCppppCpp'ppHsc2hsppC2hsplatformDefinesppHappyppAlex ppSuffixesknownSuffixHandlerspreprocessExtras UserHooksreadDeschookedPreProcessorshookedProgramspreConfconfHookpostConfpreBuild buildHook postBuildpreReplreplHookpostReplpreClean cleanHook postCleanpreCopycopyHookpostCopypreInstinstHookpostInstpreRegregHookpostRegpreUnreg unregHook postUnreg preHscolour hscolourHook postHscolour preDoctest doctestHook postDoctest preHaddock haddockHook postHaddockpreTesttestHookpostTestpreBench benchHook postBenchArgsemptyUserHookstestbenchConfigStateFileErrorConfigStateFileNoHeaderConfigStateFileBadHeaderConfigStateFileNoParseConfigStateFileMissingConfigStateFileBadVersiongetConfigStateFiletryGetConfigStateFiletryGetPersistBuildConfiggetPersistBuildConfigmaybeGetPersistBuildConfigwritePersistBuildConfigcheckPersistBuildConfigOutdatedlocalBuildInfoFile findDistPreffindDistPrefOrDefaultgetInternalPackagescomputeEffectiveProfilinginterpretPackageDbFlagsccLdOptionsBuildInfoconfigCompilerAuxExconfigCompilerExcheckForeignDeps$fExceptionConfigStateFileError$fShowConfigStateFileErrorsdistlistPackageSources prepareTreeprepareSnapshotTreesnapshotPackagesnapshotVersiondateToSnapshotNumber createArchiveprintPackageProblems showBuildInforeplcreateInternalPackageDBinitialBuildStepscomponentInitialBuildStepswriteAutogenFileshaddockhaddockPackagePathshscolour$fSemigroupDirectory$fMonoidDirectory$fSemigroupHaddockArgs$fMonoidHaddockArgs$fReadDirectory$fShowDirectory $fEqDirectory$fOrdDirectory$fGenericHaddockArgsdoctest$fSemigroupDoctestArgs$fMonoidDoctestArgs$fShowDoctestArgs$fGenericDoctestArgsdefaultMainWithHooksdefaultMainWithHooksArgsdefaultMainNoReaddefaultMainWithHooksNoReaddefaultMainWithHooksNoReadArgssimpleUserHooksautoconfUserHooks byteSwap64 byteSwap32 byteSwap16 Data.BinarydecodeFileOrFail decodeFile encodeFile decodeOrFaildecodeencode GBinaryPutgput GBinaryGetggetData.Binary.PutputWord8PutData.Binary.GetgetWord8Data.Binary.Get.InternalGetopenBinaryTempFile openTempFileopenNewBinaryFileControl.Monad.Fail MonadFailData.SemigroupLastFirstGNFDataSnocList runSnocListfromMapgetShortPathNamecopyFilecopyFileChanged filesEqualcopyOrdinaryFilecopyExecutableFilesetDirOrdinarysetEnvunsetEnv lookupEnvgetEnvironmentbytestring-0.10.8.2Data.ByteString.Internal ByteString usageInfogetOptSystem.Console.GetOptArgOrdergetOpt' RequireOrderPermute ReturnInOrderOptionArgDescrNoArgtokenizeQuotedWordspatches _makePatchKeybsRemove bsReplacebsRemoveStarting StartCode LexState'parsec-3.1.13.0Text.Parsec.PrimStreamgetLexerWarnings setLexerModelines_Json JsonArrayJsonBoolJsonNull JsonNumber JsonObject JsonString renderJson hashToBase62GHC.IO.Handle.TexthPutStr GHC.IO.HandlehCloseData.ByteString.Short.InternalShortByteStringData.ByteString.Lazy.Internal Data.VersiondoesNotIntersect ShortTextLstmoduleRenamingParsecLinkPoint writePoint readPointfreshrepr equivalentparsecVerbosity verboseQuiet verboseFlag verboseNoFlag isVerboseFlag WithSource ModuleSourceModuleRequiresModuleProvides ModuleScopeemptyModuleScopeModuleWithSource FromMixinsFromBuildDependsFromExposedModulesFromOtherModulesFromSignaturesmodScopeProvidesmodScopeRequiresdispModuleSource unWithSource getSourceclassifyKnownExtensioncombineLibraryNamecomponentNameNotRequestedReasoncombineFlagValuesPpretty-1.1.3.6Text.PrettyPrint.HughesPJfsepvcatversion getBinDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameMarkWhen NormalMark TraceWhen AlwaysTraceioeSetVerbatimioeGetVerbatimverbatimUserErrordisplaySomeExceptionDocwrapTextVerbosity withTimestamp withMetadatawithTrailingNewlinewithCallStackPrefix traceWhen copyFilesWith readNubList formatMsgfindExecutablemarkupInvocationunionInvocation FinalMatchFinalLitGlobStem globMatchessplitConstantPrefixcheckExtextensionToFlagextensionToFlag' ghcSupportedghcjsVersionImplInfoghcVersionImplInfopackageDbArgsConfuserSpecifiedPathconfigurePrograms CommonFlag commandHelpparsecModSubstEntrydispModSubstEntryprogramDbPathsprogramDbOption TargetSet DepMapUnion DepTestRsltsimplifyWithSysParamsresolveWithFlagsaddBuildableConditionPDTaggedPDTaggedPDNulloverallDependenciesflattenTaggedTargetsBlockPSSyntaxsectionizeFields FromBuildInfoSectionS parseFields warnImport parseCondTreeparseCondTreeWithCommonStanzasprocessImportsBasicSpecLicenseLenientsetMaybePackageName<+> DepUniqueKey mkTargetInfo wipeMetadatahpcDirMatchmatchInexactly findMatchUserBuildTargetSingleUserBuildTargetDoubleUserBuildTargetTriplereadUserBuildTargetshowBuildTarget' matchPlusmatchPlusShadowing exactMatchesinexactMatchescheckBuildTargetsuhcLanguageExtensionsaddBuiltinVersionsinstalledPkgConfigisPkgDirmkInstalledPackageInfo checkSanitycheckAllGhcOptionscheckGhcOptionscheckCabalVersioncheckPackageVersionscheckPathsModuleExtensions"checkDevelopmentOnlyFlagsBuildInfo checkDevelopmentOnlyFlagsOptions checkTarPath checkPackageFilesPreDistributioncheckGlobFiles stubRunTestsgenerateToolVersionMacrosgenerateMacrosgenerateComponentIdMacrogenerateCurrentPackageVersionmkConfiguredComponenttoConfiguredComponent'fixFakePkgNameconfigureToolchainfilterGhciFlags ghcArchString ghcOsStringghcEnvironmentFileNamerenderGhcEnvironmentFileEntrytargetPlatformcomponentCxxGhcOptionscomponentAsmGhcOptionscomponentCmmGhcOptions mkGHCiLibNamemkGHCiProfLibNameghcLookupPropertygetHaskellObjectsmkGhcOptPackages substTopDircheckPackageDbEnvVarprofDetailLevelFlag BuildSources GBuildModegbuildgetUserPackageDBflibTargetName flibBuildNameexeMainModuleNamedecodeMainIsArg gbuildSourcesifNeedsRPathWorkaroundextractRtsInfocheckNeedsRecompilationgetObjectFileName getRPathspopThreadedFlagguessToolFromGhcPathguessGhcPkgFromGhcPathguessHsc2hsFromGhcPathguessHaddockFromGhcPathtoPackageIndexgetInstalledPackages'getCompilerArgs copyPackage copyComponentinstallDataFilesinstallIncludeFilesModuleProvidesU ModuleScopeU ModuleSubstU UnitIdUniqueUnitIdU'UnitIdUModuleUModuleU'UnifRefUnifEnv unify_uniq unify_reqsunify_self_cidunify_verbosity unify_ctxunify_db unify_errsUnifyM runUnifyMliftSTGHC.STST readUnifRef writeUnifRef getUnifEnv addErrContextaddErrContextMconvertModuleSubstconvertModuleSubstUemptyModuleScopeUconvertIncludeconvertModuleScopeUconvertModuleProvidesconvertModuleProvidesUModuleWithSourceU UnitIdThunkU ModuleVarUaddErrfailWith failIfErrstryM convertUnitId convertModuleconvertUnitIdUconvertModuleUmixLink linkProvision unifyModulePreExistingComponent pc_pkgname pc_compnameipiToPreExistingComponent pc_munged_idpc_uidpc_cid pc_open_uidpc_shapegetModificationTimeposixTimeToModTime time-1.8.0.2"Data.Time.Clock.Internal.POSIXTime POSIXTimeInstMInstSIndefiniteComponentindefc_requiresindefc_providesindefc_includesInstantiatedComponent instc_instsinstc_insts_depsinstc_providesinstc_includesReadyComponent rc_open_uidrc_cid rc_component rc_exe_deps rc_publicrc_irc_uidrc_pkgid rc_depends rc_munged_idtoReadyComponents rc_ann_iddispReadyComponentWrappedPreProcessorExtrasPreProcessorExtraspreprocessFileknownExtrasHandlersExternalDependencyInternalDependencydispConfigStateFileErrorcurrentCabalIdcurrentCompilerId parseHeader showHeadercheckDeprecatedFlagscheckExactConfigurationdependencySatisfiableconfigureFinalizedPackagecheckCompilerProblemsconfigureDependenciesconfigureCoverageconfigureProfilingselectDependencyconfigureRequiredProgramcheckPackageProblemscheckRelocatableCreateArchiveFun!listPackageSourcesMaybeExecutablelistPackageSourcesOrdinary findSetupFilemaybeCreateDefaultSetupScriptfindMainExeFilefindModDefFilefindIncludeFilefilterAutogenModulesallSourcesBuildInfo tarBallNameoverwriteSnapshotPackageDescaddExtraCSourcesaddExtraCxxSourcesaddExtraCmmSourcesaddExtraAsmSourcestestSuiteExeV10AsExebenchmarkExeV10asExetestSuiteLibV09AsLibAndExe Directory HaddockArgsargInterfaceFileargPackageNameargHideModulesargIgnoreExports argLinkSourceargLinkedSource argQuickJump argCssFile argContents argOutput argInterfaces argOutputDirargTitle argPrologue argGhcOptions argGhcLibDir argReexports argTargets runHaddock mkHaddockArgs fromLibraryfromExecutablefromForeignLib getInterfaces hscolour' DoctestArgsallSuffixHandlerstryGetBuildConfiggetBuildConfig