úÎÉFÓÿ?      !"#$%&'( ) *+ , - ./ 0123456789:;< =>?@ABCDEFGHIJKLM NOPQRS TUVW XYZ[ \]^_`a b!cdefg"h#i$j$k$l$m$n%o&p'qrs(tu)vwx*y*z*{*|*}~+,€ -‚ƒ.„…/†‡0ˆ0‰0Š0‹0Œ11Ž23‘3’3“3”•–—$˜$™$š$›$œ$$ž$Ÿ$ $¡$¢$£$¤$¥$¦$§$¨$©$ª$«$¬$­$®$¯$°$±%²&³%´%µ%¶%·%¸&¹%º&» ¼½¾¿!À!Á!Â&ÃÄÅÆÇÈ,É,ÊËÌ2Í2Î Ï Ð ÑÒ4ÓÔ!Õ!Ö×Ø&Ù&Ú&Û&Ü$Ý$Þ$ß$à$á$â$ã$ä$å$æ$ç$è$é$ê$ë$ì$íîïðñòóôõö÷øùúûüýþÿ     55        !"#$%&'()*+,-./0 1 2 3456789:;<=> ? @ A B C D E F)G H I J KLMNOPQRS6T7U7VWXYZ[8\8]8^8_8`8a8b8c8d8e9f9g9hijk,l,m,n,o,p,q,r,s,tuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«)¬)­.®:¯:°.±.²;³;´;µ;¶5·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊ-Ë-Ì-ÍÎÏÐÑÒÓÔ Õ Ö × ØÙÚÛ Ü Ý Þß<à<á<â<ã=ä=å=æ=ç=è=é=ê=ë=ì=í=î=ï=ð=ñ=ò=ó=ô=õ=ö=÷=ø=ù=ú=û=ü=ý=þ=ÿ==========      !"#$%&'()*+,-./0123)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P)Q)R)S)T)U)V)W)X)Y)Z)[)\)])^)_)`)a)b)c)d)e)f>g>h>i>j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}?~??€??‚?ƒ?„?…?†?‡?ˆ?‰?Š?‹?Œ??Ž???‘?’?“?”?•?–?—?˜?™@š@›@œ@@ž@Ÿ@ @¡@¢@£@¤@¥@¦@§@¨@©@ª@«@¬@­@®@¯@°A±A²A³A´AµA¶A·A¸A¹AºA»A¼A½A¾A¿AÀAÁAÂAÃAÄAÅAÆAÇAÈAÉAÊËÌÍÎÏÐÑÒ)Ó)ÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçè1é1ê1ë1ì1í1î1ï1ð1ñòóôõ0ö0÷øù0ú4û4ü4ý4þBÿBCCCCCCC C C C C CCCCCCCCCCCCCCCCCC !"#$%&'()*+,-./012345161718191:1;1<1=1>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1VDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfDgDhDiDjDkDlDmDnDoDpDqDrDsDtDuDvDwDxDyDzD{D|D}D~DD€DD‚DƒD„D…D†D‡DˆD‰DŠD‹DŒDDŽDDD‘D’D“D”D•D–D—D˜D™DšD›DœDDžDŸD D¡D¢D£D¤D¥D¦D§D¨D©DªD«D¬D­D®D¯D°D±D²D³D´DµD¶D·D¸D¹DºD»D¼D½D¾D¿DÀDÁDÂDÃDÄDÅDÆDÇDÈDÉDÊDËDÌDÍDÎDÏDÐDÑDÒDÓDÔDÕDÖD×DØDÙDÚDÛDÜDÝDÞDßDàDáDâDãDäDåDæDçDèDéDêDëDìDíDîDïDðDñDòDóDôDõDöD÷DøDùDúDûDüDýDþDÿDDDDDDDDDD 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@DADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQDRDSDTDUDVDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfDgDhDiDjDkDlDmDnDoDpDqDrDsDtDuDvDwDxDyDzD{D|D}D~DD€DD‚DƒD„D…D†D‡DˆD‰DŠD‹DŒDDŽDDD‘D’D“D”D•D–D—D˜D™DšD›DœDDžDŸD D¡D¢D£D¤D¥D¦D§D¨D©DªD«D¬D­D®D¯D°D±D²D³D´Dµ/¶/·/¸/¹/º/»/¼/½/¾/¿/À/Á/Â/Ã/Ä/Å/Æ/Ç/È/É/Ê/Ë/Ì/Í/Î/Ï/Ð/Ñ/ÒEÓEÔEÕEÖE×EØEÙEÚEÛEÜEÝEÞEßEàEáEâEãEä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ÿ       222 2 2 2 2 22222222))))) !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]H^%_%`%a%b%c%d%e%f%g%h%i&j&k&l&m&n&o&p&q&r&s&t&u&v&w$x$y$z${$|$}$~$$€$$‚$ƒ$„$…$†$‡$ˆ$‰$Š$‹$Œ$$Ž$$$‘$’$“$”$•$–$—$˜$™$š$›$œ$$ž$Ÿ$ $¡$¢$£$¤$¥$¦$§$¨$©$ª$«$¬$­$®$¯$°$±$²$³$´$µ$¶$·$¸$¹$º$»$¼$½$¾$¿$À$Á$Â$Ã$Ä$Å$Æ$Ç$È$É$Ê$Ë$Ì$Í$Î$Ï$Ð$Ñ$Ò$Ó$Ô$Õ$Ö$×$Ø$Ù$Ú$Û$Ü$Ý$Þ$ß$à$á$â$ã$ä$å$æ$ç$è$é$ê$ë$ì$í$î$ï$ð$ñ$ò$ó$ô$õ$ö$÷$ø$ù$ú$û$ü$ý$þ$ÿ$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$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$nopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß"à"á"â"ã"ä"å"æ"ç"è"é"ê"ë"ì"í"î"ï"ð"ñ"ò"ó"ô"õ"ö"÷"ø"ù"ú"û"ü"ý"þ"ÿ"""""""""" " " " " """"""""""""""""III I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7!8!9!:!;!<!=!>!?!@JABC!D!EF!G!H!I!J!K!L!M!NO!P!Q!RSJTJUJVJWJXJYJZJ[J\J]J^J_J`JaJbJcJdJeJfJgJhJiJjJkJlJmJnJoJpJqrstuvwxyz{|}~€‚ƒK„…K†‡ˆ‰Š‹.Œ::ŽL‘’“”•–—M˜M™MšM›NœNNžNŸN N¡N¢N£N¤O¥N¦P§N¨N©NªN«N¬N­Q®Q¯Q°Q±Q²Q³Q´QµQ¶Q·Q¸Q¹QºQ»Q¼Q½Q¾Q¿QÀQÁQÂQÃQÄQÅQÆQÇQÈQÉQÊQËQÌQÍQÎQÏQÐQÑQÒQÓQÔQÕQÖR×RØRÙRÚRÛRÜRÝRÞRßRàRáRâRãRäRåRæRçRèRéRêRëRìRíRîMïMðMñMòMóMôSõSöS÷TøTùTúTûTüTýTþTÿTTTTTTTTTT T T T T TTTTTTTTTTTTTTUUUUU U!U"U#U$U%U&V'V(V)V*V+V,V-V.V/V0V1V2V3V4V5V6W7V8K9X:X;X<=>?@ABCDEFGHIJKLMNOPQRSTUYVYWYXYYYZY[Y\Y]Y^Y_Z`ZaZbZc[d[e[f[g[h[i[j[k[l[m[n[o\p\q\r\s\t\u\v\w\x\y\z\{]|]}]~]]€]]‚]ƒ]„]…]†^‡^ˆ^‰^Š^‹^Œ__Ž___‘_’_“_”_•_–_—`˜`™`š`›`œ``ž`Ÿ` `¡`¢a£a¤a¥a¦a§a¨a©aªa«a¬a­a®a¯a°a±a²a³a´aµa¶a·a¸b¹bºb»b¼b½b¾b¿bÀcÁcÂcÃcÄcÅcÆcÇcÈcÉcÊcËcÌcÍcÎcÏcÐcÑcÒcÓcÔcÕcÖc×cØcÙcÚcÛcÜcÝdÞeßeàfáfâfãfäfåfæfçfèféfêfëfìfífîfïfðfñfòfófôfõföf÷føfùfúfûfüfýfþfÿf f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f !f "f #f $f %f &f 'f (f )f *f +f ,f -f .f /f 0f 1f 2f 3f 4f 5f 6f 7f 8f 9f :f ;f <f =f >f ?f @f Af Bf Cf Df Ef Ff Gf Hf If Jf Kf Lf Mf Nf Of Pf Qf Rf Sf Tf Uf Vf Wf Xf Yf Zf [f \f ]f ^f _f `f ag bg cg dg eg fg gg hg ig jg kg lg mg ng og ph qh rh sh th uh vh wh xh yh zh {h |h }h ~h h €h h ‚h ƒh „h …h †h ‡h ˆh ‰h Šh ‹h Œh h Žh h h ‘h ’h “h ”h •h –h —h ˜h ™h šh ›h œh h žh Ÿh  h ¡h ¢h £h ¤h ¥h ¦h §h ¨h ©h ªh «h ¬h ­h ®h ¯h °h ±h ²h ³h ´h µh ¶h ·h ¸h ¹h ºh »h ¼h ½h ¾h ¿h Àh Áh Âh Ãh Äh Åh Æh Çh Èh Éh Êh Ëh Ìh Íh Îh Ïh Ðh Ñh Òh Óh Ôh Õh Öh ×h Øh Ùh Úh Ûh Üh Ýh Þh ßh àh áh âh ãh äh åh æh çh èh éh êh ëh ìh íh îh ïh ðh ñh òh óh ôh õh öh ÷h øh ùh úh ûh üh ýh þh ÿh h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h !h "h #h $h %h &h 'h (h )h *h +h ,h -h .h /h 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 Kh Lh Mh Nh Oh Ph Qh Rh Sh Th Uh Vh Wh Xh Yh Zh [h \h ]h ^h _h `h ah bh ch dh eh fh gh hh ih jh kh lh mh nh oh ph qh rh sh th uh vh wh xh yh zh {h |h }h ~h h €h h ‚h ƒh „h …h †h ‡h ˆh ‰h Šh ‹h Œh h Žh h h ‘h ’h “h ”h •h –h —h ˜h ™h šh ›h œh h žh Ÿh  h ¡i ¢i £i ¤i ¥i ¦i § ¨ © ª « ¬ ­ ® ¯ °j ±j ²j ³j ´j µj ¶j ·j ¸j ¹j ºj »j ¼j ½j ¾j ¿j Àj Ák Âj Ãj Äl Ål Æl Çl Èk Ék Êk Ëk Ìj Ík Îk Ïj Ðj Ñj Òk Ó Ôk Õk Öj ×j Øj Ùj Új Ûk Ük Ýj Þj ßj àj áj âj ãj äj åj æj çj èj éj êj ëj ìm ím îj ïj ðj ñj òm óm ôm õm öm ÷m øm ùm úm ûm üm ým þm ÿm m                                 ! " # $ % & ' ( ) * + , - .K /K 0K 1K 2K 3K 4K 5K 6K 7K 8K 9K :K ;K <K =K >K ?K @K AK BK CK DK EK FK GK HK IK JK KK LK MK NK OK PK QK RK SK TK UL VL WL XL YL Z9 [S \S ]S ^S _S `S aS bS cS dS eS fS gS hS iS jS kS l6 m6 n6 o6 p6 q6 r6 s6 t6 u6 v6 w6 x6 y z { | }V ~V V €n 8 ‚8 ƒ8 „8 …8 †8 ‡8 ˆ8 ‰8 Šo ‹o Œo o Žo i i ‘i ’i “i ”i •i –i —i ˜i ™i ši ›i œi i ži Ÿi  j ¡j ¢j £j ¤j ¥j ¦j §k ¨j ©V ªV «V ¬V ­V ®V ¯ °V ±V ²V ³ ´V µW ¶W ·W ¸W ¹W ºW »W ¼W ½W ¾p ¿p Àp Áp Âp Ãp Äp Åp Æp ÇV ÈV ÉV ÊV ËV ÌV ÍV ÎV ÏV ÐV ÑV ÒV ÓV ÔV ÕV ÖV ×V ØV ÙV ÚV ÛV ÜV ÝV ÞV ßV àV áV âV ãV äV åV æV çV è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þB ÿB B                 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 - . / 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# {# |# }# ~# # €# # ‚# ƒ# „# …# †# ‡# ˆ# ‰# Š# ‹# Œ# # Ž# # # ‘# ’# “# ”# •# –# —# ˜# ™# š# ›r œs s žs Ÿs  s ¡s ¢s £s ¤s ¥s ¦s §s ¨s © ª « ¬t ­t ®t ¯t °t ±t ²t ³t ´t µt ¶t ·t ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æu Çv Èv Év Êv Ëv Ìv Ív Îv Ïv Ðv Ñv Òv Óv Ôv Õv Öv ×v Øv Ùv Úv Ûv Üv Ýv Þv ßv àv áv âv ãv äv åv æv çv èv év êv ëv ìv ív îv ïv ðv ñv òv óv ôv õv öv ÷v øv ùv úv ûv üv ýv þv ÿv v v v v v v v v > > > w w w w w l l l x x x x X X X X y y y y y y !y "y #y $y %z &z 'z (z )z *z +z ,z -z .z /z 0z 1z 2z 3z 4z 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„MNOPQRSTUVWXYZ[\]^_…`…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…{…|…}…~……€……‚…ƒ…„………†…‡…ˆ…‰…Š…‹…Œ……Ž………‘…’…“…”…•…–…—…˜…™…š…›…œ……ž…Ÿ… …¡…¢…£…¤…¥…¦…§…¨…©…ª…«…¬…­…®…¯…°…±…²…³…´…µ…¶…·…¸…¹…º…»†¼†½†¾†¿†À†Á††ÆĆņƆdžȇɇʇˇ͇̇·χЇчÒ‡Ó‡Ô‡Õ‡Ö‡ׇ؇Ù‡Ú‡Û‡܇݇Þ‡߇à‡á‡â‡ã‡ä‡å‡æ‡ç‡è‡é‡ê‡ë‡ì‡í‡î‡ï‡ð‡ñ‡ò‡ó‡ô‡õ‡öˆ÷ˆøˆùˆúˆûˆüˆýˆþˆÿˆˆˆˆˆˆˆˆˆˆ ˆ ‰ ‰ ‰ ‰ŠŠŠŠ‹‹‹‹‹‹‹‹‹‹kkkk k!k"k#k$k%k&k'Œ(Œ)Œ*Œ+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑŽÒŽÓŽÔŽÕŽÖŽ׎ØŽÙŽÚŽÛŽÜŽÝŽÞŽߎàŽáŽâŽãŽäŽåŽæŽçŽèŽéŽêŽëŽìŽíŽîŽïŽðŽñŽòŽóŽôŽõŽöŽ÷ŽøŽùŽúŽûŽüŽýŽþŽÿŽŽŽŽŽŽŽŽŽŽ Ž Ž Ž Ž ŽŽŽŽŽŽŽŽŽŽŽŽŽŽŽŽŽ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëì‘í‘î‘ï‘ð‘ñ‘ò‘ó‘ô‘õ‘ö‘÷‘ø‘ù‘ú‘û‘ü‘ý‘þ‘ÿ’’’’’’’’’’ ’ ’ ’ ’ ’’’’’’’’’’’’’’’’’’’ ’!’"’#’$’%’&“'“(“)“*“+“,“-“.“/“0“1“2“3“4“5“6“7“8“9“:“;“<“=“>“æ”"(c) The University of Glasgow 2015see libraries/ghc-prim/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy+,FQVT I  The empty ¾.J  Push a call-site onto the stack.(This function has no effect on a frozen ¾.¾¾Zs are a lightweight method of obtaining a partial call-stack at any point in the program..A function can request its call-site with the '( constraint. For example, we can define 2errorWithCallStack :: HasCallStack => String -> a as a variant of errorC that will get its call-site. We can access the call-stack inside errorWithCallStack with •. {errorWithCallStack :: HasCallStack => String -> a errorWithCallStack msg = error (msg ++ "n" ++ prettyCallStack callStack) Thus, if we call errorWithCallStackA we will get a formatted call-stack alongside our error message.errorWithCallStack "die"*** Exception: dieCallStack (from HasCallStack):F errorWithCallStack, called at <interactive>:2:1 in interactive:Ghci1 GHC solves ' constraints in three steps: If there is a ¾3 in scope -- i.e. the enclosing function has a 'E constraint -- GHC will append the new call-site to the existing ¾.If there is no ¾ in scope -- e.g. in the GHCi session above -- and the enclosing definition does not have an explicit type signature, GHC will infer a 'W constraint for the enclosing definition (subject to the monomorphism restriction).If there is no ¾^ in scope and the enclosing definition has an explicit type signature, GHC will solve the '" constraint for the singleton ¾+ containing just the current call-site.¾Ds do not interact with the RTS and do not require compilation with -prof>. On the other hand, as they are built up explicitly via the 'v constraints, they will generally not contain as much information as the simulated call-stacks maintained by the RTS.A ¾ is a [(String, SrcLoc)]. The String/ is the name of function that was called, the [ is the call-site. The list is ordered with the most recently called function at the head.(NOTE: The intrepid user may notice that '- is just an alias for an implicit parameter ?callStack :: CallStack(. This is an implementation detail and  should not be considered part of the ¾@ API, we may decide to change the implementation in the future.%A single location in the source code.?Freeze the stack at the given  CallStack?, preventing any further call-sites from being pushed onto it.' Request a CallStack.NOTE: The implicit parameter ?callStack :: CallStack" is an implementation detail and  should not be considered part of the ¾@ API, we may decide to change the implementation in the future.(&Extract a list of call-sites from the ¾.(The list is ordered by most recent call.) "Convert a list of call-sites to a ¾.* KFreeze a call-stack, preventing any further call-sites from being appended.NpushCallStack callSite (freezeCallStack callStack) = freezeCallStack callStackIJ¾@A?Ó !"#$%&'()*¾@A?Ó !"#$%&–((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions) Trustworthy,-DFQVú,,/ stops execution and displays an error message.-  A variant of ,% that does not produce a stack trace..A special case of ,ƒ. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which . appears.BPUsed for compiler-generated error message; encoding saves bytes of string junk.,-.B—((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)UnsafeCDQVÏ`_'A list producer that can be fused with . This function is merely  augment g xs = g (:) xs?but GHC's simplifier will transform an expression of the form  k z ( g xs)&, which may arise after inlining, to g k ( k z xs)., which avoids producing an intermediate list.Append two lists, i.e., q[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]>If the first list is not finite, the result is the first list.'A list producer that can be fused with . This function is merely  build g = g (:) []?but GHC's simplifier will transform an expression of the form  k z ( g)%, which may arise after inlining, to g k z/, which avoids producing an intermediate list.®, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left: @foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)CThis /M equality predicate is used when desugaring pattern-matches against strings. is defined as the value Ê/. It helps to make guards more readable. eg. - f x | x < 0 = ... | otherwise = ...#If the first argument evaluates to Ê9, then the result is the second argument. Otherwise an AssertionFailed$ exception is raised, containing a /6 with the source file and line number of the call to .ŽAssertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-assertsL option is given). When assertions are turned off, the first argument to @ is ignored, and the second argument is returned as the result. f xs" is the list obtained by applying f to each element of xs, i.e., [map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]OApplication operator. This operator is redundant, since ordinary application (f x) means the same as (f  x) . However, p has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:  f $ g $ h x = f (g (h x))6It is also useful in higher-order situations, such as  ( 0) xs, or r˜ () fs xs.+‹Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a do expression.RAs part of the MonadFail proposal (MFP), this function is moved to its own class  MonadFail (see Control.Monad.FailN for more details). The definition here will be removed in a future release.,hSequentially compose two actions, passing any value produced by the first as an argument to the second.-šSequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages./%Inject a value into the monadic type.F Identity of GGAn associative operationHJFold a list using the monoid. For most types, the default definition for H† will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.MThe M function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.NSequential application.,A few functors support an implementation of N. that is more efficient than the default one.O Lift a value.P=Sequence actions, discarding the value of the first argument.WThe W+ class defines the basic operations over a monad2, a concept from a branch of mathematics known as category theory^. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's doI expressions provide a convenient syntax for writing monadic expressions. Instances of W# should satisfy the following laws: / a , k = k a m , / = m m , (\x -> k x , h) = (m , k) , hFurthermore, the W and f% operations should relate as follows: O = / (N) = EThe above laws imply: . f xs = xs , / . f (-) = (P) and that O and (N') satisfy the applicative functor laws.The instances of W for lists, ,™ and š defined in the Prelude satisfy these laws.YThe Y? class is used for types that can be mapped over. Instances of Y# should satisfy the following laws: 1fmap id == id fmap (f . g) == fmap f . fmap gThe instances of Y for lists, ,™ and š satisfy these laws.f3A functor with application, providing operations toembed pure expressions (O), and1sequence computations and combine their results (N and 8).>A minimal complete definition must include implementations of O and of either N or 8S. If it defines both, then they must behave the same as their default definitions:(N) = 8 G 8 f x y = f <$> x N y3Further, any definition must satisfy the following: identity O G N v = v composition O (.) N u N v N w = u N (v N w) homomorphism O f N O x = O (f x) interchange u N O y = O ( y) N uThe other methods have the following default definitions, which may be overridden with equivalent specialized implementations: u P v = (G : u) N v u 9 v = 8 H u v$As a consequence of these laws, the Y instance for f will satisfy . f x = O f N x'It may be useful to note that supposing !forall x y. p (q x y) = f x . g yit follows from the above that 8 p (8 q u v) = 8 f u . 8 g vIf f is also a W, it should satisfy O = / (N) = E(which implies that O and N' satisfy the applicative functor laws).r†The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws: mappend mempty x = x mappend x mempty = x 1mappend x (mappend y z) = mappend (mappend x y) z  mconcat =  mappend memptygThe method names refer to the monoid of lists under concatenation, but there are many other instances.Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of r, e.g. Sum and Product.The 8 type encapsulates an optional value. A value of type  a! either contains a value of type a (represented as É a#), or it is empty (represented as È ). Using h is a good way to deal with errors or exceptional cases without resorting to drastic measures such as ,.The a type is also a monad. It is a simple kind of error monad, where all errors are represented by È0. A richer error monad can be built using the 2› type./A /K is a list of characters. String constants in Haskell are values of type /.0,Monads that also support choice and failure.1the identity of 2'. It should also satisfy the equations +mzero >>= f = mzero v >> mzero = mzero2an associative operation3!A monoid on applicative functors. If defined, 6 and 71 should be the least solutions of the equations:  some v = (:) <$> v N many v many v = some v 5 O []4The identity of 55An associative binary operation6 One or more.7 Zero or more.8"Lift a binary function to actions.+Some functors support an implementation of 8A that is more efficient than the default one. In particular, if .8 is an expensive operation, it is likely better to use 8 than to .! over the structure and then use N.9>Sequence actions, discarding the value of the second argument.:SReplace all locations in the input with the same value. The default definition is . . H<, but this may be overridden with a more efficient version.; A variant of N with the arguments reversed.<FLift a function to actions. This function may be used as a value for . in a Y instance.=#Lift a ternary function to actions.>Same as ,&, but with the arguments interchanged.?Conditional execution of f expressions. For example, !when debug (putStrLn "Debugging")will output the string  Debugging if the Boolean value debug is Ê, and otherwise do nothing.DREvaluate each action in the sequence from left to right, and collect the results.EE f is equivalent to D .  f.@Promote a function to a monad.A`Promote a function to a monad, scanning the monadic arguments from left to right. For example, N liftM2 (+) [0,1] [0,2] = [0,2,1,3] liftM2 (+) (Just 1) Nothing = NothingBWPromote a function to a monad, scanning the monadic arguments from left to right (cf. A).CWPromote a function to a monad, scanning the monadic arguments from left to right (cf. A).DWPromote a function to a monad, scanning the monadic arguments from left to right (cf. A).EIn many situations, the @' operations can be replaced by uses of E&, which promotes function application. ' return f `ap` x1 `ap` ... `ap` xnis equivalent to  liftMn f x1 x2 ... xnFThe œ method restricted to the type ).GIdentity function.Hconst x( is a unary function which evaluates to x for all inputs. For instance,map (const 42) [0..3] [42,42,42,42]IFunction composition.JJ f9 takes its (first) two arguments in the reverse order of f.K´Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.LL p f yields the result of applying f until p holds.MM! is a type-restricted version of H™. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.F Returns the tag_ of a constructor application; this function is used by the deriving code for Eq, Ord and Enum.¯The primitive dataToTag# requires an evaluated constructor application as its argument, so we provide getTag as a wrapper that performs the evaluation before calling dataToTag. We could have dataToTagÿD evaluate its argument, but we prefer to do it this way because (a) dataToTag# can be an inline primop if it doesn't need to do any evaluation, and (b) we want to expose the evaluation to the simplifier, because it might be possible to eliminate the evaluation in the case when the argument is already known to be evaluated.NVShift the argument left by the specified number of bits (which must be non-negative).O]Shift the argument right by the specified number of bits (which must be non-negative). The RL} means "right, logical" (as opposed to RA for arithmetic) (although an arithmetic right shift wouldn't make sense for Word#)PVShift the argument left by the specified number of bits (which must be non-negative).QfShift the argument right (signed) by the specified number of bits (which must be non-negative). The RA9 means "right, arithmetic" (as opposed to RL for logical)RhShift the argument right (unsigned) by the specified number of bits (which must be non-negative). The RL9 means "right, logical" (as opposed to RA for arithmetic)GLift a semigroup into  forming a r according to  #http://en.wikipedia.org/wiki/Monoid: "Any semigroup S= may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and  e*s = s = s*e for all s " SC." Since there used to be no "Semigroup" typeclass providing just G , we use r instead.HIJKLMNOPQRSTUVWX YFor tuples, the r constraint on a7 determines how the first values merge. For example, /s concatenate: <("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017)Z [\]^_`ab c deÿOCfghijklmnopqrs tMS(W,-/+Y.:[)fONP98rFGHuvwxtÅÊyzuÃ{vÄ|wÆ}xÇ~ÈÉ€‚€ÎÏЃƒ„……†‡ˆ‰Š†‹Œ‡ËŽ‘’“‘’“”íîïðñòóôõö÷ø•ùúûüýþ–ÿ”•±²»–—˜™¼š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹ÔºÕ»¼½¾Ö     ׿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ,-.B/01235746;<=>?DE@ABCDEFGHIJKLMF    NOPQRW,-/+Y.:fON8P9rFGHÈÉ”•01234567 50,1-1N4P45394:4;4>1I9 K07 Trustworthyé6TOStart attributing ticks to cost centres. This is called by the RTS on startup.UNStop attributing ticks to cost centres. Allocations will still be attributed.TUUTž,(c) 2001-2011 The Data Parallel Haskell teamsee libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyDHë¯  Ÿ'(c) The University of Glasgow 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyD÷í !Conversion from an }B. An integer literal represents the application of the function !" to the appropriate value of type }, so such literals have type (Z a) => a.*Unary negation.ZBasic numeric class.XAbsolute value.Y!Sign of a number. The functions X and Y should satisfy the law: abs x * signum x == xFor real numbers, the Y is either -1 (negative), 0 (zero) or 1 (positive).Z the same as J (").Because -/ is treated specially in the Haskell grammar, (- e)D is not a section, but an application of prefix negation. However, (Z exp)) is equivalent to the disallowed section.5 !"#$%&'()*+,-./012345ZWV"*!XY}6789:;<=ZZV"W*XY!"6V6W7 "(c) The University of Glasgow 2008see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeD)å [An [¤ (pronounced "em-var") is a synchronising variable, used for communication between concurrent threads. It can be thought of as a a box, which may be empty or full.\ Create an [ which is initially empty.] Create an [# which contains the supplied value.^Return the contents of the [ . If the [ is currently empty, ^& will wait until it is full. After a ^, the [ is left empty..There are two further important properties of ^:^K is single-wakeup. That is, if there are multiple threads blocked in ^ , and the [w becomes full, only one thread will be woken up. The runtime guarantees that the woken thread completes its ^ operation.(When multiple threads are blocked on an [{, they are woken up in FIFO order. This is useful for providing fairness properties of abstractions built using [s._#Atomically read the contents of an [ . If the [ is currently empty, _ will wait until its full. _# is guaranteed to receive the next `._A is multiple-wakeup, so when multiple readers are blocked on an [,, all of them are woken up at the same time.Compatibility note: Prior to base 4.7, _ was a combination of ^ and `B. This mean that in the presence of other threads attempting to `, _ could block. Furthermore, _ would not receive the next `3 if there was already a pending thread blocked on ^K. The old behavior can be recovered by implementing 'readMVar as follows: l readMVar :: MVar a -> IO a readMVar m = mask_ $ do a <- takeMVar m putMVar m a return a `Put a value into an [ . If the [ is currently full, `" will wait until it becomes empty..There are two further important properties of `:`K is single-wakeup. That is, if there are multiple threads blocked in ` , and the [x becomes empty, only one thread will be woken up. The runtime guarantees that the woken thread completes its ` operation.(When multiple threads are blocked on an [{, they are woken up in FIFO order. This is useful for providing fairness properties of abstractions built using [s.aA non-blocking version of ^. The a% function returns immediately, with È if the [ was empty, or É a if the [ was full with contents a . After a, the [ is left empty.bA non-blocking version of `. The b% function attempts to put the value a into the [ , returning Ê if it was successful, or Å otherwise.cA non-blocking version of _. The c% function returns immediately, with È if the [ was empty, or É a if the [ was full with contents a.dCheck whether a given [ is empty.êNotice that the boolean value returned is just a snapshot of the state of the MVar. By the time you get to react on its result, the MVar may have been filled (or emptied) - so be extremely careful when using this operation. Use a instead if possible.>Add a finalizer to an [ (GHC only). See Foreign.ForeignPtr and System.Mem.Weak for more about finalizers.? [@\]^_`abcd>[@¡'(c) The University of Glasgow 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeDdÆe!This is the "back door" into the † monad, allowing †D computation to be performed at any time. For this to be safe, the †O computation should be free of side effects and independent of its environment."If the I/O computation wrapped in eŠ performs side effects, then the relative order in which those side effects take place (relative to the main I/O trunk, or other calls to e-) is indeterminate. Furthermore, when using eÿ to cause side-effects, you should take the following precautions to ensure the side effects are performed as many times as you expect them to be. Note that these precautions are necessary for GHC, but may not be sufficient, and other compilers may require different precautions:Use {-# NOINLINE foo #-} as a pragma on any function foo that calls eK. If the call is inlined, the I/O may be performed more than once.Use the compiler flag -fno-cseã to prevent common sub-expression elimination being performed on the module, which might combine two side effects that were meant to be separate. A good example is using multiple global variables (like test in the example below).7Make sure that the either you switch off let-floating (-fno-full-laziness), or that the call to eJ cannot float outside a lambda. For example, if you say: 8 f x = unsafePerformIO (newIORef []) I you may get only one reference cell shared between all calls to f". Better would be 9 f x = unsafePerformIO (newIORef [x]) 7 because now it can't float outside the lambda.It is less well known that e is not type safe. For example: ´ test :: IORef [a] test = unsafePerformIO $ newIORef [] main = do writeIORef test [42] bang <- readIORef test print (bang :: [Char])ÝThis program will core dump. This problem with polymorphic references is well known in the ML community, and does not arise with normal monadic use of references. There is no easy way to make it impossible once you use e#. Indeed, it is possible to write coerce :: a -> b with the help of e. So be careful!fThis version of e{ is more efficient because it omits the check that the IO is only being performed by a single thread. Hence, when you use fÿ], there is a possibility that the IO action may be performed multiple times (on a multiprocessor), and you should therefore ensure that it gives the same results each time. It may even happen that one of the duplicated IO actions is only run partially, and then interrupted in the middle without an exception being raised. Therefore, functions like bracket cannot be used safely within f.gg allows an †@ computation to be deferred lazily. When passed a value of type IO a, the †. will only be performed when the value of the a@ is demanded. This is used to implement lazy file reading, see ¢.AA allows an †@ computation to be deferred lazily. When passed a value of type IO a, the †. will only be performed when the value of the a is demanded.œThe computation may be performed multiple times by different threads, possibly at the same time. To ensure that the computation is performed only once, use g instead.BÎEnsures that the suspensions under evaluation by the current thread are unique; that is, the current thread is not evaluating anything that is also under evaluation by another thread that has also executed B.,This operation is used in the definition of e[ to prevent the IO action from being executed multiple times, which is usually undesirable.efgAB£ TrustworthyDZeO¤"(c) The University of Glasgow 2012see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)NonejWChA monad that can execute GHCi statements by lifting them out of m into the IO monad. (e.g state monads)D"A monad that doesn't allow any IO.EFGHICJDCJDKL¥(c) Daniel Fischer 2010see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyDlMNOPQRSTUVWXYZ[\]^_`ab¦(c) Daniel Fischer 2010see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyDnýcdef§NoneDoWghijklgh¨ TrustworthyoÍ©(c) The University of Glasgowsee libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions) Trustworthyqê"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthyw³&Extract the first component of a pair.'Extract the second component of a pair.hh6 converts an uncurried function to a curried function.ii4 converts a curried function to a function on pairs.jSwap the components of a pair.hijhij,"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthy¶; kThe k3 function takes a default value, a function, and a  value. If the  value is Èh, the function returns the default value. Otherwise, it applies the function to the value inside the É and returns the result.Examples Basic usage:maybe False odd (Just 3)Truemaybe False odd NothingFalse$Read an integer from a string using  readMaybe;. If we succeed, return twice the integer; that is, apply (*2)8 to it. If instead we fail to parse an integer, return 0 by default:import Text.Read ( readMaybe )maybe 0 (*2) (readMaybe "5")10maybe 0 (*2) (readMaybe "")0Apply show to a  Maybe Int . If we have Just n", we want to show the underlying x n. But if we have ÈA, we return the empty string instead of (for example) "Nothing":maybe "" show (Just 5)"5"maybe "" show Nothing""lThe l function returns Ê" iff its argument is of the form Just _.Examples Basic usage:isJust (Just 3)TrueisJust (Just ())TrueisJust NothingFalse7Only the outer constructor is taken into consideration:isJust (Just Nothing)TruemThe m function returns Ê iff its argument is È.Examples Basic usage:isNothing (Just 3)FalseisNothing (Just ())FalseisNothing NothingTrue7Only the outer constructor is taken into consideration:isNothing (Just Nothing)FalsenThe n( function extracts the element out of a É) and throws an error if its argument is È.Examples Basic usage:fromJust (Just 1)12 * (fromJust (Just 10))202 * (fromJust Nothing)&*** Exception: Maybe.fromJust: NothingoThe o( function takes a default value and and  value. If the  is ÈS, it returns the default values; otherwise, it returns the value contained in the .Examples Basic usage:#fromMaybe "" (Just "Hello, World!")"Hello, World!"fromMaybe "" Nothing""$Read an integer from a string using  readMaybe5. If we fail to parse an integer, we want to return 0 by default:import Text.Read ( readMaybe )fromMaybe 0 (readMaybe "5")5fromMaybe 0 (readMaybe "")0pThe p, function returns an empty list when given È$ or a singleton list when not given È.Examples Basic usage:maybeToList (Just 7)[7]maybeToList Nothing[] One can use pW to avoid pattern matching when combined with a function that (safely) works on lists:import Text.Read ( readMaybe )!sum $ maybeToList (readMaybe "3")3 sum $ maybeToList (readMaybe "")0qThe q function returns È on an empty list or É a where a" is the first element of the list.Examples Basic usage:listToMaybe []NothinglistToMaybe [9]Just 9listToMaybe [1,2,3]Just 1 Composing p with q2 should be the identity on singleton/empty lists:maybeToList $ listToMaybe [5][5]maybeToList $ listToMaybe [][],But not on lists with more than one element:!maybeToList $ listToMaybe [1,2,3][1]rThe r function takes a list of !s and returns a list of all the É values.Examples Basic usage:#catMaybes [Just 1, Nothing, Just 3][1,3]When constructing a list of  values, rV can be used to return all of the "success" results (if the list is the result of a , then s would be more appropriate):import Text.Read ( readMaybe )4[readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ][Just 1,Nothing,Just 3]@catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ][1,3]sThe s function is a version of c which can throw out elements. In particular, the functional argument returns something of type  b. If this is È8, no element is added on to the result list. If it is É b, then b! is included in the result list.ExamplesUsing s f x is a shortcut for r $  f x in most cases:import Text.Read ( readMaybe )3let readMaybeInt = readMaybe :: String -> Maybe Int'mapMaybe readMaybeInt ["1", "Foo", "3"][1,3].catMaybes $ map readMaybeInt ["1", "Foo", "3"][1,3]If we map the É1 constructor, the entire list should be returned:mapMaybe Just [1,2,3][1,2,3] ÈÉklmnopqrs ÈÉklmnoqprsª'(c) The University of Glasgow 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyDV02Concatenate a list of lists.j, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e., !filter p xs = [ x | x <- xs, p x]‹ takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded. is right-lazy: zip [] _|_ = []t=Extract the first element of a list, which must be non-empty.uHDecompose a list into its head and tail. If the list is empty, returns È$. If the list is non-empty, returns É (x, xs) , where x is the head of the list and xs its tail.vGExtract the elements after the head of a list, which must be non-empty.wGExtract the last element of a list, which must be finite and non-empty.xSReturn all the elements of a list except the last one. The list must be non-empty.yTest whether a list is empty.zO(n). z+ returns the length of a finite list as an x). It is an instance of the more general r«6, the result type of which may be any kind of number.{{­, applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right: Efoldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xnThe list must be finite.|A strict version of {.}} is a variant of {S that has no starting value argument, and thus must be applied to non-empty lists.~A strict version of }The 7 function computes the sum of a finite list of numbers.€The €; function computes the product of a finite list of numbers. is similar to {A, but returns a list of successive reduced values from the left: @scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that $last (scanl f z xs) == foldl f z xs.‚‚ is a variant of % that has no starting value argument: .scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]ƒ#A strictly accumulating version of „„ is a variant of S that has no starting value argument, and thus must be applied to non-empty lists.…… is the right-to-left dual of  . Note that $head (scanr f z xs) == foldr f z xs.†† is a variant of …% that has no starting value argument.‡‡{ returns the maximum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of r¬G, which allows the programmer to supply their own comparison function.ˆˆ{ returns the minimum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of r­G, which allows the programmer to supply their own comparison function.‰‰ f x7 returns an infinite list of repeated applications of f to x: %iterate f x == [x, f x, f (f x), ...]ŠŠ x is an infinite list, with x the value of every element.‹‹ n x is a list of length n with xE the value of every element. It is an instance of the more general r® , in which n may be of any integral type.ŒŒ ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists., applied to a predicate p and a list xs2, returns the longest prefix (possibly empty) of xs of elements that satisfy p: ktakeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2] takeWhile (< 9) [1,2,3] == [1,2,3] takeWhile (< 0) [1,2,3] == []ŽŽ p xs$ returns the suffix remaining after  p xs: sdropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3] dropWhile (< 9) [1,2,3] == [] dropWhile (< 0) [1,2,3] == [1,2,3] n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > z xs: take 5 "Hello World!" == "Hello" take 3 [1,2,3,4,5] == [1,2,3] take 3 [1,2] == [1,2] take 3 [] == [] take (-1) [1,2] == [] take 0 [1,2] == []&It is an instance of the more general r¯ , in which n may be of any integral type. n xs returns the suffix of xs after the first n elements, or [] if n > z xs: drop 6 "Hello World!" == "World!" drop 3 [1,2,3,4,5] == [4,5] drop 3 [1,2] == [] drop 3 [] == [] drop (-1) [1,2] == [1,2] drop 0 [1,2] == [1,2]&It is an instance of the more general r° , in which n may be of any integral type.‘‘ n xs( returns a tuple where first element is xs prefix of length n1 and second element is the remainder of the list: ÿsplitAt 6 "Hello World!" == ("Hello ","World!") splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5]) splitAt 1 [1,2,3] == ([1],[2,3]) splitAt 3 [1,2,3] == ([1,2,3],[]) splitAt 4 [1,2,3] == ([1,2,3],[]) splitAt 0 [1,2,3] == ([],[1,2,3]) splitAt (-1) [1,2,3] == ([],[1,2,3])It is equivalent to ( n xs,  n xs) when n is not _|_ (splitAt _|_ xs = _|_). ‘$ is an instance of the more general r± , in which n may be of any integral type.’’, applied to a predicate p and a list xsM, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p1 and second element is the remainder of the list: {span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4]) span (< 9) [1,2,3] == ([1,2,3],[]) span (< 0) [1,2,3] == ([],[1,2,3])’ p xs is equivalent to ( p xs, Ž p xs)““, applied to a predicate p and a list xsM, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p1 and second element is the remainder of the list: ~break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4]) break (< 9) [1,2,3] == ([],[1,2,3]) break (> 9) [1,2,3] == ([1,2,3],[])“ p is equivalent to ’ ( . p).”” xs returns the elements of xs in reverse order. xs must be finite.••C returns the conjunction of a Boolean list. For the result to be Ê, the list must be finite; Å, however, results from a Å7 value at a finite index of a finite or infinite list.––C returns the disjunction of a Boolean list. For the result to be Å, the list must be finite; Ê, however, results from a Ê7 value at a finite index of a finite or infinite list.—#Applied to a predicate and a list, —X determines if any element of the list satisfies the predicate. For the result to be Å, the list must be finite; Ê, however, results from a Ê_ value for the predicate applied to an element at a finite index of a finite or infinite list.˜#Applied to a predicate and a list, ˜V determines if all elements of the list satisfy the predicate. For the result to be Ê, the list must be finite; Å, however, results from a Å_ value for the predicate applied to an element at a finite index of a finite or infinite list.™™I is the list membership predicate, usually written in infix form, e.g.,  x `elem` xs. For the result to be Å, the list must be finite; Ê-, however, results from an element equal to x6 found at a finite index of a finite or infinite list.šš is the negation of ™.››  key assocs' looks up a key in an association list.œ7Map a function over a list and concatenate the results.YList index (subscript) operator, starting from 0. It is an instance of the more general r²-, which takes an index of any integral type.žž@ takes three lists and returns a list of triples, analogous to .ŸŸ generalises i by zipping with the function given as the first argument, instead of a tupling function. For example, Ÿ (+)D is applied to two lists to produce the list of corresponding sums.Ÿ is right-lazy: zipWith f [] _|_ = [] The  ” function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to Ÿ.¡¡] transforms a list of pairs into a list of first components and a list of second components.¢The ¢I function takes a list of triples and returns three lists, analogous to ¡.6tuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢m™4š49 ³((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy0Dv%$`!Conversion of values to readable /s.Derived instances of `P have the following properties, which are compatible with derived instances of ´:The result of ¤ÿj is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.?If the constructor is defined to be an infix operator, then £4 will produce infix applications of the constructor.hthe representation will be enclosed in parentheses if the precedence of the top-level constructor in x is less than d* (associativity is ignored). Thus, if d is 0; then the result is never surrounded in parentheses; if d is 11N it is always surrounded in parentheses, unless it is an atomic expression.8If the constructor is defined using record syntax, then ¤p will produce the record-syntax form, with the fields given in the same order as the original declaration.#For example, given the declarations 8infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree athe derived instance of ` is equivalent to ÿ~instance (Show a) => Show (Tree a) where showsPrec d (Leaf m) = showParen (d > app_prec) $ showString "Leaf " . showsPrec (app_prec+1) m where app_prec = 10 showsPrec d (u :^: v) = showParen (d > up_prec) $ showsPrec (up_prec+1) u . showString " :^: " . showsPrec (up_prec+1) v where up_prec = 5!Note that right-associativity of :^: is ignored. For example,¤ (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string  "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".£Convert a value to a readable /.£ should satisfy the law 0showsPrec d x r ++ s == showsPrec d x (r ++ s)Derived instances of ´ and ` satisfy the following:(x,"") is an element of (µ d (£ d x "")). That is, µ parses the string produced by £, and delivers the value that £ started with.¤A specialised variant of £<, using precedence context zero, and returning an ordinary /.¥ The method ¥‰ is provided to allow the programmer to give a specialised way of showing lists of values. For example, this is used by the predefined ` instance of the u type, where values of type /H should be shown in double quotes, rather than between square brackets.¦The shows7 functions return a function that prepends the output / to an existing /R. This allows constant-time concatenation of results using function composition.§equivalent to £ with a precedence of 0.¨utility function converting a uB to a show function that simply prepends the character unchanged.©utility function converting a /? to a show function that simply prepends the string unchanged.ªSutility function that surrounds the inner show function with parentheses when the t parameter is Ê.«Convert a character to a string using only printable characters, using Haskell source-language escape conventions. For example: !showLitChar '\n' s = "\\n" ++ snSame as «ÿO, but for strings It converts the string to a string using Haskell escape conventions for non-printable characters. Does not add double-quotes around the whole thing; the caller should do that. The main difference from showLitChar (apart from the fact that the argument is a string not a list) is that we must escape double-quotesoLike n¤ (expand escape characters using Haskell escape conventions), but * break the string into multiple lines * wrap the entire thing in double quotes Example: (showMultiLineString "hellongoodbyenblah" returns %[""hello\n\", "\goodbyen\", "\blah""]¬ Convert an x in the range 0..15$ to the corresponding single digit uU. This function fails on other inputs, and generates lower-case hexadecimal digits.pqrstuvwxyz{|}~ €  ‚ƒ„…†£Athe operator precedence of the enclosing context (a number from 0 to 11(). Function application has precedence 10.the value to be converted to a /`£¤¥¦‡ˆ‰§¨©ªŠ‹«noŒ¬Ž`£¤¥¶((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeDQVŽ- ­;The strict state-transformer monad. A computation of type ­ s a* transforms an internal state indexed by s, and returns a value of type a. The s parameter is either7an uninstantiated type variable (inside invocations of ±), orƒ (inside invocations of ·¸).CIt serves to keep the internal states of different invocations of ±3 separate from each other and from invocations of ·¸.The , and -^ operations are strict in the state (though not in values stored in the state). For example, ± (writeSTRef _|_ v >>= f) = _|_®® allows an ­B computation to be deferred lazily. When passed a value of type ST a, the ­; computation will only be performed when the value of the a is demanded.¯ ¯ allows an ­B computation to be deferred lazily. When passed a value of type ST a, the ­; computation will only be performed when the value of the a is demanded.wThe computation may be performed multiple times by different threads, possibly at the same time. To prevent this, use ® instead.°oAllow the result of a state transformer computation to be used (lazily) inside the computation. Note that if f is strict, ° f = _|_.±CReturn the value computed by a state transformer computation. The forall- ensures that the internal state used by the ­9 computation is inaccessible to the rest of the program.‘’ “”•­–—®¯°±“”­–¹((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeD“ß²a value of type  STRef s a' is a mutable variable in state thread s, containing a value of type a³ Build a new ² in the current state thread´Read the value of an ²µWrite a new value into an ²˜²™³´µ²™º TrustworthyDK” š›œžŸ ›œž¡5 TrustworthyD•ß¶The » method restricted to the type ).¶¶¼((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions) Trustworthy0D·ò)$!Used in Haskell's translation of [n..].%!Used in Haskell's translation of [n,n'..].&!Used in Haskell's translation of [n..m].'!Used in Haskell's translation of  [n,n'..m].QThe Q? class is used to name the upper and lower limits of a type. [ is not a superclass of QP since types that are not totally ordered may also have upper and lower bounds.The Q1 class may be derived for any enumeration type; »( is the first constructor listed in the data declaration and ¼ is the last. QV may also be derived for single-constructor datatypes whose constituent types are in Q.RClass R2 defines operations on sequentially ordered types.The enumFromG... methods are used in Haskell's translation of arithmetic sequences. Instances of Rœ may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by º from 0 through n-1. See Chapter 10 of the Haskell Report for more details.*For any type that is an instance of class Q as well as R, the following should hold: The calls · ¼ and ¸ »% should result in a runtime error.º and ¹m should give a runtime error if the result value is not representable in the result type. For example, ¹ 7 :: t is an error.$ and %3 should be defined with an implicit bound, thus: Ï enumFrom x = enumFromTo x maxBound enumFromThen x y = enumFromThenTo x y bound where bound | fromEnum y >= fromEnum x = maxBound | otherwise = minBound·.the successor of a value. For numeric types, · adds 1.¸0the predecessor of a value. For numeric types, ¸ subtracts 1.¹Convert from an x.ºConvert to an x'. It is implementation-dependent what ºA returns when applied to a value that is too large to fit in an x.¢£¤¥¦§¨©ª«¬ ­ ® ¯ °±²³´µ¶·¸¹º»¼½¾¿ÀQ»¼R¹º$%'&·¸ÁÂÃÄÅÆQ»¼R·¸¹º$%&'½((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyDè-#Conversion from a ‚ (that is  }4). A floating literal stands for an application of # to a value of type ‚, so such literals have type (U a) => a.8$general coercion from integral types9$general coercion to fractional types:conversion to };@the rational equivalent of its real argument with full precisionU-Fractional numbers, supporting real division.V.Integral numbers, supporting integer division._#Extracting components of fractions.9Rational numbers, with numerator and denominator of some V type.‚EArbitrary-precision rational numbers, represented as a ratio of two }: values. A rational number may be constructed using the Ê operator.½ The function ½ takes a real fractional number x and returns a pair (n,f) such that x = n+f, and:n- is an integral number with the same sign as x; andf. is a fraction with the same type and sign as x', and with absolute value less than 1.The default definitions of the À, Á, ¾ and ¿ functions are in terms of ½.¾¾ x returns the integer nearest x between zero and x¿¿ x returns the nearest integer to x; the even integer if x$ is equidistant between two integersÀÀ x) returns the least integer not less than xÁÁ x/ returns the greatest integer not greater than xÂfractional divisionÃreciprocal fractionÄ&integer division truncated toward zeroÅinteger remainder, satisfying !(x `quot` y)*y + (x `rem` y) == xÆ3integer division truncated toward negative infinityÇinteger modulus, satisfying  (x `div` y)*y + (x `mod` y) == xÈ simultaneous Ä and ÅÉ simultaneous Æ and ÇÇǘ is a subsidiary function used only in this module. It normalises a ratio by dividing both numerator and denominator by their greatest common divisor.Ê(Forms the ratio of two integral numbers.ËŠExtract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.ÌŒExtract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.ÍConverts a possibly-negative ] value to a string.Ð/raise a number to a non-negative integral powerÑ#raise a number to an integral powerÒÒ x y$ is the non-negative factor of both x and y" of which every common factor of x and y is also a factor; for example Ò 4 2 = 2, Ò (-4) 6 = 2, Ò 0 4 = 4. Ò 0 0 = 0U. (That is, the common divisor that is "greatest" in the divisibility preordering.)2Note: Since for signed fixed-width integer types, X » < 09, the result may be negative if one of the arguments is »& (and necessarily is if the other is 0 or ») for such types.ÓÓ x y, is the smallest positive integer that both x and y divide.ÈÉÊËÌÍÎÏÐÑÒÓÔÍ(a function that can show unsigned values'the precedence of the enclosing contextthe value to show789UÃÂ#VÉÈÇÆÅÄ:];_ÁÀ¿¾½Õ‚Ö×ØÙÚÛÜÇÊËÌÝÞßàÍÎÏÐÑáâÒÓãäåæçèUÂÃ#VÄÅÆÇÈÉ:];_½¾¿ÀÁÕÂ7Ä7Å7Æ7Ç7Ê7Ð8Ñ8¾((c) The University of Glasgow, 1994-2000see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)UnsafeDG@9+aThe a’ class is used to map a contiguous subrange of values in a type onto integers. It is used primarily for array indexing (see the array package).The first argument (l,u)q of each of these operations is a pair specifying the lower and upper bounds of a contiguous subrange of values.SAn implementation is entitled to assume the following laws about these operations:Ö (l,u) i == ™ i (Ô (l,u))  Ô (l,u)  Õ (l,u) i == i, when Ö (l,u) i (Õ (l,u)) (Ô (l,u))) == [0..× (l,u)-1]  × (l,u) == z (Ô (l,u))  é)Mutable, boxed, non-strict arrays in the ­, monad. The type arguments are as follows:s&: the state variable argument for the ­ typei8: the index type of the array (should be an instance of a)e : the element type of the array.êAThe type of immutable non-strict (boxed) arrays with indices in i and elements in e.Ô>The list of values in the subrange defined by a bounding pair.Õ,The position of a subscript in the subrange.ëLike Õ2, but without checking that the value is in range.ÖReturns ÊB the given subscript lies in the range defined the bounding pair.×4The size of the subrange defined by a bounding pair.ìlike ×9, but without checking that the upper bound is in range.íjConstruct an array with the specified bounds and containing values for given indices within these bounds.ÿuThe array is undefined (i.e. bottom) if any index in the list is out of bounds. The Haskell 2010 Report further specifies that if any two associations in the list have the same index, the value at that index is undefined (i.e. bottom). However in GHC's implementation, the value at such an index is the value part of the last association with that index in the list.6Because the indices must be checked for these errors, í¥ is strict in the bounds argument and in the indices of the association list, but non-strict in the values. Thus, recurrences such as the following are possible: >a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i <- [2..100]])°Not every index within the bounds of the array need appear in the association list, but the values associated with indices that do not appear will be undefined (i.e. bottom).®If, in any dimension, the lower bound is greater than the upper bound, then the array is legal, but empty. Indexing an empty array always gives an array-bounds error, but î? still yields the bounds with which the array was constructed.ïNConstruct an array from a pair of bounds and a list of values in index order.ð)The value at the given index in an array.î/The bounds with which an array was constructed.ñ$The number of elements in the array.ò3The list of indices of an array in ascending order.ó0The list of elements of an array in index order.ôA right fold over the elementsõA left fold over the elementsö%A strict right fold over the elements÷$A strict left fold over the elementsø4A left fold over the elements with no starting valueù5A right fold over the elements with no starting valueú4The list of associations of an array in index order.ûThe ûH function deals with repeated indices in the association list using an accumulating functionz which combines the values of associations with the same index. For example, given a list of values of some index type, hist\ produces a histogram of the number of occurrences of each index within a specified range: xhist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b hist bnds is = accumArray (+) 0 bnds [(i, 1) | i<-is, inRange bnds i]-If the accumulating function is strict, then ûv is strict in the values, as well as the indices, in the association list. Thus, unlike ordinary arrays built with í9, accumulated arrays should not in general be recursive.ü‘Constructs an array identical to the first argument except that it has been updated by the associations in the right argument. For example, if m is a 1-origin, n by n matrix, then m//[((i,i), 0) | i <- [1..n]]4is the same matrix, except with the diagonal zeroed.<Repeated indices in the association list are handled as for í’: Haskell 2010 specifies that the resulting array is undefined (i.e. bottom), but GHC's implementation uses the last association for each index.ýý f{ takes an array and an association list and accumulates pairs from the list into the array with the accumulating function f. Thus û can be defined using ý: <accumArray f z b = accum f (array b [(i, z) | i <- range b])þþ¦ allows for transformations on array indices. It may be thought of as providing function composition on the right with the mapping that the original array embodies.?A similar transformation of array values may be achieved using . from the ê instance of the Y class.ÿ     í a pair of bounds¤, each of the index type of the array. These bounds are the lowest and highest indices in the array, in that order. For example, a one-origin vector of length '10'' has bounds '(1,10)', and a one-origin '10' by '10'% matrix has bounds '((1,1),(10,10))'. a list of  associations of the form (index, valueƒ). Typically, this list will be expressed as a comprehension. An association '(i, x)' defines the value of the array at index i to be x.ûaccumulating function initial valuebounds of the arrayassociation list>aÔÕÖ×ëìéêíïðîñòóôõö÷øùúû ü!ý"#þ$%&'()*+,-./01aÔÕëÖ×ìéêð9 ü9 "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable Trustworthy_«ØAn infix synonym for ..,The name of this operator is an allusion to $-. Note the similarities between their types: Y ($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f bWhereas $ is function application, Ø( is function application lifted over a Y.ExamplesConvert from a Maybe Int to a Maybe String using show:show <$> NothingNothingshow <$> Just 3Just "3"Convert from an Either Int Int to an Either Int String using show:show <$> Left 17Left 17show <$> Right 17 Right "17"Double each element of a list:(*2) <$> [1,2,3][2,4,6]Apply even! to the second element of a pair:even <$> (2,2)(2,True)ÙFlipped version of :.ExamplesReplace the contents of a Maybe Int with a constant String:Nothing $> "foo"NothingJust 90210 $> "foo" Just "foo"Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:Left 8675309 $> "foo" Left 8675309Right 8675309 $> "foo" Right "foo"/Replace each element of a list with a constant String:[1,2,3] $> "foo"["foo","foo","foo"]5Replace the second element of a pair with a constant String:(1,2) $> "foo" (1,"foo")ÚÚ valueO discards or ignores the result of evaluation, such as the return value of an š action.ExamplesReplace the contents of a Maybe Int with unit: void NothingNothing void (Just 3)Just ()Replace the contents of an Either Int Int with unit, resulting in an Either Int '()':void (Left 8675309) Left 8675309void (Right 8675309)Right ()*Replace every element of a list with unit: void [1,2,3] [(),(),()]/Replace the second element of a pair with unit: void (1,2)(1,())Discard the result of an š action:mapM print [1,2]12[(),()]void $ mapM print [1,2]12Y:.ØÙÚY.::ÙØÚØ4Ù4 GNils Anders Danielsson 2006 , Alexander Berntsen 20144BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimentalportable TrustworthykÛÛ f* is the least fixed point of the function f, i.e. the least defined x such that f x = x.Ü(*) `on` f = \x y -> f x * f y.Typical usage: r¿ (compare `on` fst).Algebraic properties: (*) `on` G = (*) (if  (*) " {"¥, H "¥}) &((*) `on` f) `on` g = (*) `on` (f . g) J on f . J on g = J on (g . f)ÝÝ™ is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator , which allows Ý to be nested in .GHIJÛÜÝGHIJÝÛÜÜ0Ý1 "(c) The University of Glasgow 2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable TrustworthymŸS(S( "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableUnsafeoà » »À Trustworthypî234567 89:;<=>?@ABCD89:;<=>?@ABC"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthy{¿ÞCase analysis for the t type. Þ x y p evaluates to x when p is Å, and evaluates to y when p is Ê.This is equivalent to if p then y else x[; that is, one can think of it as an if-then-else construct with its arguments reordered.Examples Basic usage:bool "foo" "bar" True"bar"bool "foo" "bar" False"foo" Confirm that Þ x y p and if p then y else x are equivalent:"let p = True; x = "bar"; y = "foo" bool x y p == if p then y else xTrue let p = False bool x y p == if p then y else xTruetÅÊÞtÅÊÞ<4BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimental not portableSafe,-FST€šß1Type-level "not". An injective type family since 4.10.0.0.àType-level "or"áType-level "and"â Type-level If.  If True a b ==> a;  If False a b ==> bßàáââáàßà2á3="(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable TrustworthyDè§'ãThe ã9 class denotes types with a finite, fixed number of bits.äoReturn the number of bits in the type of the argument. The actual value of the argument is ignored. Moreover, ä* is total, in contrast to the deprecated õ function it replaces. ä = õ ô = É . ä åACount number of zero bits preceding the most significant set bit. å (î :: a) = finiteBitSize (î :: a) å& can be used to compute log base 2 via  logBase2 x = ä x - 1 - å x ÅNote: The default implementation for this method is intentionally naive. However, the instances provided for the primitive integral types are implemented using CPU specific machine instructions.æBCount number of zero bits following the least significant set bit. æ (î :: a) = finiteBitSize (î :: a) æ . * = æ  The related  +http://en.wikipedia.org/wiki/Find_first_setfind-first-set operation can be expressed in terms of æ as follows findFirstSet x = 1 + æ x ÅNote: The default implementation for this method is intentionally naive. However, the instances provided for the primitive integral types are implemented using CPU specific machine instructions.çThe ç6 class defines bitwise operations over integral types.GBits are numbered from 0 with bit 0 being the least significant bit.è Bitwise "and"é Bitwise "or"ê Bitwise "xor"ë%Reverse all the bits in the argument ìì x i shifts x left by i bits if i" is positive, or right by -i‡ bits otherwise. Right shifts perform sign extension on signed number types; i.e. they fill the top bits with 1 if the x* is negative and with 0 otherwise.+An instance can define either this unified ì or ÷ and ùJ, depending on which is more convenient for the type in question. íí x i rotates x left by i bits if i" is positive, or right by -i bits otherwise.For unbounded types like }, í is equivalent to ì.+An instance can define either this unified í or û and üJ, depending on which is more convenient for the type in question. îî" is the value with all bits unset.<The following laws ought to hold (for all valid bit indices n): ñ î n == î ð î n == ï n ó î n == False ý î == 0This method uses ñ (ï 0) 0A as its default implementation (which ought to be equivalent to î% for types which possess a 0th bit).ïbit i is a value with the i$th bit set and all other bits clear.Can be implemented using þ if a is also an instance of Z. See also î.ð x `setBit` i is the same as  x .|. bit iñx `clearBit` i is the same as x .&. complement (bit i)òx `complementBit` i is the same as  x `xor` bit ióReturn Ê if the nth bit of the argument is 1Can be implemented using ÿ if a is also an instance of Z.ô·Return the number of bits in the type of the argument. The actual value of the argument is ignored. Returns Nothing for types that do not have a fixed bitsize, like }.õ{Return the number of bits in the type of the argument. The actual value of the argument is ignored. The function õG is undefined for types that do not have a fixed bitsize, like }.öReturn ÊX if the argument is a signed type. The actual value of the argument is ignored ÷]Shift the argument left by the specified number of bits (which must be non-negative).'An instance can define either this and ù or the unified ìJ, depending on which is more convenient for the type in question. ø§Shift the argument left by the specified number of bits. The result is undefined for negative shift amounts and shift amounts greater or equal to the õ. Defaults to ÷* unless defined explicitly by an instance.ù­Shift the first argument right by the specified number of bits. The result is undefined for negative shift amounts and shift amounts greater or equal to the õ.nRight shifts perform sign extension on signed number types; i.e. they fill the top bits with 1 if the x* is negative and with 0 otherwise.'An instance can define either this and ÷ or the unified ìJ, depending on which is more convenient for the type in question. ú’Shift the first argument right by the specified number of bits, which must be non-negative an smaller than the number of bits in the type.nRight shifts perform sign extension on signed number types; i.e. they fill the top bits with 1 if the x* is negative and with 0 otherwise. Defaults to ù* unless defined explicitly by an instance.û^Rotate the argument left by the specified number of bits (which must be non-negative).'An instance can define either this and ü or the unified íJ, depending on which is more convenient for the type in question. ü_Rotate the argument right by the specified number of bits (which must be non-negative).'An instance can define either this and û or the unified íJ, depending on which is more convenient for the type in question. ý{Return the number of set bits in the argument. This number is known as the population count or the Hamming weight.Can be implemented using  if a is also an instance of Z.þDefault implementation for ï. Note that: bitDefault i = 1 ÷ iÿDefault implementation for ó. Note that: 'testBitDefault x i = (x .&. bit i) /= 0Default implementation for ý.zThis implementation is intentionally naive. Instances are expected to provide an optimized implementation for their size.Attempt to convert an V type a to an V type b- using the size of the types as measured by ç methods.&A simpler version of this function is: ªtoIntegral :: (Integral a, Integral b) => a -> Maybe b toIntegral x | toInteger x == y = Just (fromInteger y) | otherwise = Nothing where y = toInteger x$This version requires going through }&, which can be inefficient. However, toIntegralSized\ is optimized to allow GHC to statically determine the relative type sizes (as measured by ô and ö) and avoid going through }+ for many types. (The implementation uses 8+, which is itself optimized with rules for base types but may go through } for some type pairs.)EÊ if the size of a is <= the size of b, where size is measured by ô and ö. Interpret t as 1-bit bit-fieldãäåæçèéêëìíîïðñòóôõö÷ùøúûüýþÿçèéêëìíîïðñòóôõö÷øùúûüýãäåæþÿãäåæçèéêëìíîïðñòóôõö÷øùúûüý è7é5ê6ì8í8÷8ù8û8ü8Ái(c) The University of Glasgow 1994-2002 Portions obtained from hbc (c) Lennart Augusstsonsee libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy D/K'T=Trigonometric and hyperbolic functions and related functions.^TEfficient, machine-independent access to the components of a floating-point number. Ga constant function, returning the radix of the representation (often 2) 8a constant function, returning the number of digits of   in the significand Ua constant function, returning the lowest and highest values the exponent may assume  The function  R applied to a real floating-point number returns the significand expressed as an }+ and an appropriately scaled exponent (an x). If   x yields (m,n), then x is equal in value to m*b^^n, where b7 is the floating-point radix, and furthermore, either m and n are both zero or else  b^(d-1) <= X m < b^d, where d is the value of   x. In particular,   0 = (0,0).. If the type contains a negative zero, also   (-0.0) = (0,0).  The result of   x is unspecified if either of  x or  x is Ê.   performs the inverse of   in the sense that for finite x with the exception of -0.0, uncurry   (  x) = x.   m nD is one of the two closest representable floating-point numbers to m*b^^n (or  ±Infinity2 if overflow occurs); usually the closer, but if mK contains too many bits, the result may be rounded in the wrong direction.( corresponds to the second component of  .  0 = 0 and for finite nonzero x,  x = snd (  x) +   x. If x= is a finite floating-point number, it is equal in value to  x * b ^^  x, where bL is the floating-point radix. The behaviour is unspecified on infinite or NaN values.The first component of  ', scaled to lie in the open interval (-1,1 ), either 0.0 or of absolute value >= 1/b , where bK is the floating-point radix. The behaviour is unspecified on infinite or NaN values.Cmultiplies a floating-point number by an integer power of the radixÊ6 if the argument is an IEEE "not-a-number" (NaN) valueÊ9 if the argument is an IEEE infinity or negative infinityÊE if the argument is too small to be represented in normalized formatÊ) if the argument is an IEEE negative zeroÊ1 if the argument is an IEEE floating point numberUa version of arctangent taking two real floating-point arguments. For real floating x and y,  y x\ computes the angle (from the positive x-axis) of the vector from the origin to the point (x,y).  y x returns a value in the range [-pi, pi\]. It follows the Common Lisp semantics for the origin when signed zeroes are supported.  y 1, with y in a type that is ^", should return the same value as " y. A default definition of K is provided, but implementors can provide a more accurate implementation.) ) x computes  (1 + x)D, but provides more precise results for small (absolute) values of x if possible.* * x computes  x - 1D, but provides more precise results for small (absolute) values of x if possible.+ + x computes  (1 +  x)1, but provides more precise results if possible. Examples:if x is a large negative number,  (1 +  x)/ will be imprecise for the reasons given in ).if  x is close to -1,  (1 +  x)/ will be imprecise for the reasons given in *., , x computes  (1 -  x)1, but provides more precise results if possible. Examples:if x is a large negative number,  (1 -  x)/ will be imprecise for the reasons given in ).if  x is close to 1,  (1 -  x)/ will be imprecise for the reasons given in *.-Show a signed ^k value to full precision using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise...! takes a base and a non-negative ^K number, and returns a list of digits and an exponent. In particular, if x>=0, and *floatToDigits base x = ([d1,d2,...,dn], e)then  n >= 1 x = 0.d1d2...dn * (base**e) 0 <= di <= base-1/ Converts a ‚ value into any type in class ^.FGHIJKLMNOPQRSTUV(a function that can show unsigned values'the precedence of the enclosing contextthe value to show‰WXT !"#$%&'()*+,^     {vÄ|wÆúû_`abYZ[\]^_`abcdefghij-klm./nopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨V©T !"#$%&'()*+,^     Y[\Z8 TrustworthyNÓªA mapping from keys k to priorites p.«E k p binds the key k with the priority p.¬O(1)# The number of elements in a queue.­O(1) True if the queue is empty.®O(log n)L The priority and value of a given key, or Nothing if the key is not bound.¯O(1) Build a queue with one element.°O(log n)· Insert a new key, priority and value in the queue. If the key is already present in the queue, the associated priority and value are replaced with the supplied priority and value.±O(log n)† Delete a key and its priority and value from the queue. When the key is not a member of the queue, the original queue is returned.²O(log n)œ Update a priority at a specific key with the result of the provided function. When the key is not a member of the queue, the original queue is returned.³ O(n*log n)! Build a queue from a list of keypriorityvalue tuples. If the list contains more than one priority and value for the same key, the last priority and value for the key is retained.´O(n) Convert to a list of keypriority value tuples.µO(n) Convert to an ascending list.¶O(n) Convert to a descending list.·O(1)& The element with the lowest priority.¸O(log n)] Delete the element with the lowest priority. Returns an empty queue if the queue is empty.¹O(log n)c Retrieve the binding with the least priority, and the rest of the queue stripped of that binding.ºO(r*(log n - log r))H Return a list of elements ordered by key whose priorities are at most pt.»Balance factor¼¶Take two pennants and returns a new pennant that is the union of the two with the precondition that the keys in the ûrst tree are strictly smaller than the keys in the second tree.½ A version of ¼c that can be used if the shape of the tree has not changed or if the tree is known to be balanced.¾¿Àª«ÁÂÃĬ­®Å¯°±²³´µ¶·¸¹ºÆÇÈÉÊËÌÍÎÏ¿ÐÑ«ÁÃÄÂÒ5M(C) 2015 David Luposchainsky, (C) 2015 Herbert Valerio Riedel BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable Trustworthy[qd When a value is bound in do1-notation, the pattern on the left hand side of <-K might not match. In this case, this class provides a function to recover.A W without a d° instance may only be used in conjunction with pattern that always match, such as newtypes, tuples, data types with only a single data constructor, and irrefutable patterns (~pat). Instances of d# should satisfy the following law: fail s should be a left zero for >>=, fail s >>= f = fail s If your W is also  MonadPlus, a popular definition is fail _ = mzero 0 1 2 d1d1d1Ã#(c) The University of Glasgow, 2003see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions) Trustworthy0¯ 33¦Unicode General Categories (column 2 of the UnicodeData table) in the order they are listed in the Unicode standard (the Unicode Character Database, in particular).Examples Basic usage::t OtherLetterOtherLetter :: GeneralCategoryS instance:"UppercaseLetter == UppercaseLetterTrue"UppercaseLetter == LowercaseLetterFalse[ instance:NonSpacingMark <= MathSymbolTrueR instance:.enumFromTo ModifierLetter SpacingCombiningMark@[ModifierLetter,OtherLetter,NonSpacingMark,SpacingCombiningMark]Read instance:)read "DashPunctuation" :: GeneralCategoryDashPunctuationread "17" :: GeneralCategory%*** Exception: Prelude.read: no parse` instance:show EnclosingMark"EnclosingMark"Q instance:minBound :: GeneralCategoryUppercaseLettermaxBound :: GeneralCategory NotAssigneda instance:import Data.Ix ( index )&index (OtherLetter,Control) FinalQuote12"index (OtherLetter,Control) Format#*** Exception: Error in array index4Lu: Letter, Uppercase5Ll: Letter, Lowercase6Lt: Letter, Titlecase7Lm: Letter, Modifier8Lo: Letter, Other9Mn: Mark, Non-Spacing:Mc: Mark, Spacing Combining;Me: Mark, Enclosing<Nd: Number, Decimal=Nl: Number, Letter>No: Number, Other?Pc: Punctuation, Connector@Pd: Punctuation, DashAPs: Punctuation, OpenBPe: Punctuation, CloseCPi: Punctuation, Initial quoteDPf: Punctuation, Final quoteEPo: Punctuation, OtherFSm: Symbol, MathGSc: Symbol, CurrencyHSk: Symbol, ModifierISo: Symbol, OtherJZs: Separator, SpaceKZl: Separator, LineLZp: Separator, ParagraphMCc: Other, ControlNCf: Other, FormatOCs: Other, SurrogatePCo: Other, Private UseQCn: Other, Not AssignedRCThe Unicode general category of the character. This relies on the R instance of 3`, which must remain in the same order as the categories are presented in the Unicode standard.Examples Basic usage:generalCategory 'a'LowercaseLettergeneralCategory 'A'UppercaseLettergeneralCategory '0' DecimalNumbergeneralCategory '%'OtherPunctuationgeneralCategory '&e' OtherSymbolgeneralCategory '\31'ControlgeneralCategory ' 'SpaceSiSelects the first 128 characters of the Unicode character set, corresponding to the ASCII character set.TxSelects the first 256 characters of the Unicode character set, corresponding to the ISO 8859-1 (Latin-1) character set.UCSelects ASCII lower-case letters, i.e. characters satisfying both S and b.VCSelects ASCII upper-case letters, i.e. characters satisfying both S and a.WReturns Ê> for any Unicode space character, and the control characters \t, \n, \r, \f, \v.XSelects ASCII digits, i.e. '0'..'9'.Y!Selects ASCII octal digits, i.e. '0'..'7'.Z(Selects ASCII hexadecimal digits, i.e. '0'..'9', 'a'..'f', 'A'..'F'.[dSelects Unicode punctuation characters, including various kinds of connectors, brackets and quotes.This function returns Ê+ if its argument has one of the following 3s, or Å otherwise:?@ABCDE"These classes are defined in the  @http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character Database_, part of the Unicode standard. The same document defines what is and is not a "Punctuation".Examples Basic usage:isPunctuation 'a'FalseisPunctuation '7'FalseisPunctuation '&e'FalseisPunctuation '"'TrueisPunctuation '?'TrueisPunctuation ' 'True\PSelects Unicode symbol characters, including mathematical and currency symbols.This function returns Ê+ if its argument has one of the following 3s, or Å otherwise:FGHI"These classes are defined in the  @http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character DatabaseZ, part of the Unicode standard. The same document defines what is and is not a "Symbol".Examples Basic usage: isSymbol 'a'False isSymbol '6'False isSymbol '='TrueaThe definition of "math symbol" may be a little counter-intuitive depending on one's background: isSymbol '+'True isSymbol '-'False]°Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters). This function is equivalent to )Ä.^7Selects alphabetic or numeric digit Unicode characters.[Note that numeric digits outside the ASCII range are selected by this function but not by Xk. Such digits may be part of identifiers but are not used by the printer and reader to represent numbers._dSelects control characters, which are the non-printing characters of the Latin-1 subset of Unicode.`aSelects printable Unicode characters (letters, numbers, marks, punctuation, symbols and spaces).a§Selects upper-case or title-case alphabetic Unicode characters (letters). Title case is used by a small number of letter ligatures like the single-character form of Lj.b;Selects lower-case alphabetic Unicode characters (letters).clConvert a letter to the corresponding lower-case letter, if any. Any other character is returned unchanged.dlConvert a letter to the corresponding upper-case letter, if any. Any other character is returned unchanged.eÏConvert a letter to the corresponding title-case or upper-case letter, if any. (Title case differs from upper case only for a small number of ligature letters.) Any other character is returned unchanged.43M456789:;<=>?@ABCDEFGHIJKLNOPQÓRSTUVWXYZ[\]^_`abcde3456789:;<=>?@ABCDEFGHIJKLMNOPQÅ((c) The University of Glasgow, 1998-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)Unsafe0Dç4fBA weak pointer object with a key and a value. The value has type v.AA weak pointer expresses a relationship between two objects, the key and the valueŒ: if the key is considered to be alive by the garbage collector, then the value is also alive. A reference from the value to the key does not keep the key alive.1A weak pointer may also have a finalizer of type IO ()ÿ; if it does, then the finalizer will be run at most once, at a time after the key has become unreachable by the program ("dead"). The storage manager attempts to run the finalizer(s) for an object soon after the object dies, but promptness is not guaranteed.ÿ+It is not guaranteed that a finalizer will eventually run, and no attempt is made to run outstanding finalizers when the program exits. Therefore finalizers should not be relied on to clean up resources - other methods (eg. exception handlers) should be employed, possibly in addition to finalizers.îReferences from the finalizer to the key are treated in the same way as references from the value to the key: they do not keep the key alive. A finalizer may therefore ressurrect the key, perhaps by storing it in the same data structure.„The finalizer, and the relationship between the key and the value, exist regardless of whether the program keeps a reference to the f object or not.ÿœThere may be multiple weak pointers with the same key. In this case, the finalizers for each of these weak pointers will all be run in some arbitrary order, or perhaps concurrently, when the key dies. If the programmer specifies a finalizer that assumes it has the only reference to an object (for example, a file that it wishes to close), then the programmer must ensure that there is only one such finalizer.‰If there are no other threads to run, the runtime system will check for runnable finalizers before declaring the system to be deadlocked.ÿ“WARNING: weak pointers to ordinary non-primitive Haskell types are particularly fragile, because the compiler is free to optimise away or duplicate the underlying data structure. Therefore attempting to place a finalizer on an ordinary Haskell type may well result in the finalizer running earlier than you expected. This is not a problem for caches and memo tables where early finalization is benign. Finalizers canS be used reliably for types that are created explicitly and have identity, such as IORef and MVar{. However, to place a finalizer on one of these types, you should use the specific operation provided for that type, e.g.  mkWeakIORef and addMVarFinalizer† respectively (the non-uniformity is accidental). These operations attach the finalizer to the primitive object inside the box (e.g. MutVar# in the case of IORefp), because attaching the finalizer to the box itself fails when the outer box is optimised away by the compiler.gEstablishes a weak pointer to k , with value v and a finalizer.?This is the most general interface for building a weak pointer.h>Dereferences a weak pointer. If the key is still alive, then É v is returned (where v is the value! in the weak pointer), otherwise È is returned.The return value of h@ depends on when the garbage collector runs, hence it is in the † monad.iMCauses a the finalizer associated with a weak pointer to be run immediately.gkeyvalue finalizerreturns: a weak pointer objectfÔghiÕfÔ?"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional-non-portable (local universal quantification) Trustworthy3DQV!-kA parser for a type a*, represented as a function that takes a /* and returns a list of possible parses as (a,/) pairs.qNote that this kind of backtracking parser is very inefficient; reading a large structure may be quite slow (cf j).lLConsumes and returns the next character. Fails if there is no input left.mPLook-ahead: returns the part of the input that is left, without consuming it.n Always fails.oSymmetric choice.p}Local, exclusive, left-biased choice: If left parser locally produces any result at all, then right parser is not used.qzTransforms a parser into one that does the same, but in addition returns the exact characters read. IMPORTANT NOTE: q] gives a runtime error if its first argument is built using any occurrences of readS_to_P.rTConsumes and returns the next character, if it satisfies the specified predicate.s+Parses and returns the specified character.t'Succeeds iff we are at the end of inputu(Parses and returns the specified string.v±Parses the first zero or more characters satisfying the predicate. Always succeds, exactly once having consumed all the characters Hence NOT the same as (many (satisfy p))w¾Parses the first one or more characters satisfying the predicate. Fails if none, else succeeds exactly once having consumed all the characters Hence NOT the same as (many1 (satisfy p))x+Combines all parsers in the specified list.ySkips all whitespace.z count n p parses n occurrences of p/ in sequence. A list of results is returned.{between open close p parses open, followed by p and finally close. Only the value of p is returned.| option x p will either parse p or return x without consuming any input.} optional p optionally parses p and always returns ().~4Parses zero or more occurrences of the given parser.3Parses one or more occurrences of the given parser.€Like ~, but discards the result.Like , but discards the result.‚ sepBy p sep$ parses zero or more occurrences of p, separated by sep*. Returns a list of values returned by p.ƒ sepBy1 p sep# parses one or more occurrences of p, separated by sep*. Returns a list of values returned by p.„ endBy p sep$ parses zero or more occurrences of p, separated and ended by sep.… endBy p sep# parses one or more occurrences of p, separated and ended by sep.† chainr p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a right9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.‡ chainl p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a left9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.ˆLike †(, but parses one or more occurrences of p.‰Like ‡(, but parses one or more occurrences of p.ŠmanyTill p end$ parses zero or more occurrences of p, until end3 succeeds. Returns a list of values returned by p.‹hConverts a parser into a Haskell ReadS-style function. This is the main way in which you can "run" a j" parser: the expanded type is 1 readP_to_S :: ReadP a -> String -> [(a,String)] Œ¨Converts a Haskell ReadS-style function into a parser. Warning: This introduces local backtracking in the resulting parser, and therefore a possible inefficiency.Ž ‘’“” •–—#jklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ#jlmopqntrsuvwyxz{|}~€‚ƒ„…†‡‰ˆŠk‹ŒjÖ×ØÙÚÛÜo5p5@"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional0non-portable (uses Text.ParserCombinators.ReadP) Trustworthy/ÕœLift a precedence-insensitive j to a š.(Increases the precedence context by one.ž&Resets the precedence context to zero.Ÿ (prec n p)C checks whether the precedence context is less than or equal to n, and if not, failsif so, parses p in context n. LConsumes and returns the next character. Fails if there is no input left.¡PLook-ahead: returns the part of the input that is left, without consuming it.¢Symmetric choice.£}Local, exclusive, left-biased choice: If left parser locally produces any result at all, then right parser is not used.¤ Always fails.¥+Combines all parsers in the specified list.ª«¬ ­®¯™š›œžŸ ¡¢£¤¥¦§¨©š™›œŸž ¡¢£¤¥¦§¨©šÝA"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional0non-portable (uses Text.ParserCombinators.ReadP) Trustworthy:8°²Character literal³(String literal, with escapes interpreted´%Punctuation or reserved symbol, e.g. (, ::µHaskell identifier, e.g. foo, Baz¶Haskell symbol, e.g. >>, :%·ÞHaskell lexemes.Þ b is / () if b is Ê, and 1 if b is Å.¹º»¼¾¿?Haskell lexer: returns the lexed string, rather than the lexemeßThe special2 character class as defined in the Haskell Report.°±²¶³·´µ¸¹º»¼½¾¿ÀÁÂÃÄű²³´µ¶·¸°¹º¼»½¾¿ÁÂÃÄÅÀ°àá±²³´µ¶·¸Æ((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy0V K-\ Parsing of /s, producing values.Derived instances of \= make the following assumptions, which derived instances of Ç obey:KIf the constructor is defined to be an infix operator, then the derived \Y instance will parse only infix applications of the constructor (not the prefix form).aAssociativity is not used to reduce the occurrence of parentheses, although precedence may be.?If the constructor is defined using record syntax, the derived \‡ will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration. The derived \| instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.#For example, given the declarations 8infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree athe derived instance of \! in Haskell 2010 is equivalent to ÿ^instance (Read a) => Read (Tree a) where readsPrec d r = readParen (d > app_prec) (\r -> [(Leaf m,t) | ("Leaf",s) <- lex r, (m,t) <- readsPrec (app_prec+1) s]) r ++ readParen (d > up_prec) (\r -> [(u:^:v,w) | (u,s) <- readsPrec (up_prec+1) r, (":^:",t) <- lex s, (v,w) <- readsPrec (up_prec+1) t]) r where app_prec = 10 up_prec = 5!Note that right-associativity of :^: is unused.,The derived instance in GHC is equivalent to ÿZinstance (Read a) => Read (Tree a) where readPrec = parens $ (prec app_prec $ do Ident "Leaf" <- lexP m <- step readPrec return (Leaf m)) +++ (prec up_prec $ do u <- step readPrec Symbol ":^:" <- lexP v <- step readPrec return (u :^: v)) where app_prec = 10 up_prec = 5 readListPrec = readListPrecDefault Why do both Ê and Ì+ exist, and why does GHC opt to implement Ì in derived \ instances instead of Ê? The reason is that Ê is based on the k type, and although k\ is mentioned in the Haskell 2010 Report, it is not a very efficient parser data structure.Ì7, on the other hand, is based on a much more efficient šU datatype (a.k.a "new-style parsers"), but its definition relies on the use of the  RankNTypes language extension. Therefore, Ì (and its cousin, ÍB) are marked as GHC-only. Nevertheless, it is recommended to use Ì instead of Ê> whenever possible for the efficiency improvements it brings.As mentioned above, derived \" instances in GHC will implement Ì instead of Ê". The default implementations of Ê (and its cousin, Ë) will simply use Ì' under the hood. If you are writing a \: instance by hand, it is recommended to write it like so:  instance \ T where Ì = ... Í = Рʳattempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.Derived instances of \ and Ç satisfy the following:(x,"") is an element of (Ê d (È d x "")). That is, Ê parses the string produced by È, and delivers the value that È started with.Ë The method ˉ is provided to allow the programmer to give a specialised way of parsing lists of values. For example, this is used by the predefined \ instance of the u type, where values of type /K should be are expected to use double quotes, rather than square brackets.ÌProposed replacement for Ê$ using new-style parsers (GHC only).ÍProposed replacement for ËB using new-style parsers (GHC only). The default definition uses Ë. Instances that define Ì should also define Í as Ð.ÎÎ Ê p parses what p* parses, but surrounded with parentheses.Î Å p parses what p5 parses, but optionally surrounded with parentheses.Ï*A possible replacement definition for the ËK method (GHC only). This is only needed for GHC, and even then only for \ instances where Í isn't defined as Ð.Ð*A possible replacement definition for the Í method, defined using Ì (GHC only).ÑThe Ñ» function reads a single lexeme from the input, discarding initial white space, and returning the characters that constitute the lexeme. If the input string contains only white space, ÑO returns a single successful `lexeme' consisting of the empty string. (Thus Ñ "" = [("","")]G.) If there is no legal lexeme at the beginning of the input string, Ñ fails (i.e. returns [])._This lexer is not completely faithful to the Haskell lexical syntax in the following respects:(Qualified names are not handled properlyCOctal and hexadecimal numerics are not recognized as a single token!Comments are not treated properlyÒmRead a string representation of a character, using Haskell source-language escape conventions. For example: -lexLitChar "\\nHello" = [("\\n", "Hello")]ÓŸRead a string representation of a character, using Haskell source-language escape conventions, and convert it to the character that it encodes. For example: ,readLitChar "\\nHello" = [('\n', "Hello")]Ô+Reads a non-empty string of decimal digits.ÕParse a single lexemeâ (paren p) parses "(P0)" where p' parses "P0" in precedence context zeroÖ (parens p)0 parses "P", "(P0)", "((P0))", etc, where pc parses "P" in the current precedence context and parses "P0" in precedence context zeroã(list p)# parses a list of things parsed by p), using the usual square-bracket syntax.äeParse the specified lexeme and continue as specified. Esp useful for nullary constructors; e.g. )choose [("A", return A), ("B", return B)]R We match both Ident and Symbol because the constructor might be an operator eg (:~:)åæçèéêëìíîïðñòóôõö÷øùúûüýþÿÊAthe operator precedence of the enclosing context (a number from 0 to 11(). Function application has precedence 10.\ÊËÌÍkÎÏÐÑÒÓÔÕâÖãä\ÊËÌÍ"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable TrustworthyDÂð× Reads an unsigned V value in an arbitrary base.Ø*Read an unsigned number in octal notation.Ù,Read an unsigned number in decimal notation.Ú_Read an unsigned number in hexadecimal notation. Both upper or lower case letters are allowed.Û Reads an unsigned _2 value, expressed in decimal scientific notation.ÜReads a signed ]- value, given a reader for an unsigned value.ÝShow  non-negative V numbers in base 10.ÞShow a signed ^6 value using scientific (exponential) notation (e.g. 2.45e2, 1.5e-3). In the call Þ digs val, if digs is È,, the value is shown to full precision; if digs is É d, then at most d* digits after the decimal point are shown.ßShow a signed ^. value using standard decimal notation (e.g. 245000, 0.0015). In the call ß digs val, if digs is È,, the value is shown to full precision; if digs is É d, then at most d* digits after the decimal point are shown.àShow a signed ^Y value using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise. In the call à digs val, if digs is È,, the value is shown to full precision; if digs is É d, then at most d* digits after the decimal point are shown.áShow a signed ^. value using standard decimal notation (e.g. 245000, 0.0015).This behaves as ßH, except that a decimal point is always guaranteed, even if not needed.âShow a signed ^Y value using standard decimal notation for arguments whose absolute value lies between 0.1 and  9,999,999$, and scientific notation otherwise.This behaves as ßH, except that a decimal point is always guaranteed, even if not needed.ãShows a  non-negative Vr number using the base specified by the first argument, and the character representation specified by the second.äShow  non-negative V numbers in base 16.åShow  non-negative V numbers in base 8.×the base4a predicate distinguishing valid digits in this base4a function converting a valid digit character to an x+T !"#$%&'()*+,Í-./Ô×ØÙÚÛÜÝÞßàáâãäå+ÍãÝäåÞßàáâ-.Ü×ÙØÚÛÔ/T !"#$%&'()*+,É!(c) The FFI Task Force, 2000-2002see libraries/base/LICENSEffi@haskell.orginternalnon-portable (GHC Extensions)UnsafeDGõ¡ ŒA value of type Œ ax represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a. The type a% will often be an instance of class CÊâ which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.A value of type  aC is a pointer to a function callable from foreign code. The type a will normally be a  foreign type4, a function type with zero or more arguments wherethe argument types are marshallable foreign types , i.e. u, x, v, w, t, *Ë, *Ì, *Í, *Î, 0Ï, 0Ð, 0Ñ, 0Ò, Œ a,  a, Ó a( or a renaming of any of these using newtype.Ithe return type is either a marshallable foreign type or has the form † t where t# is a marshallable foreign type or ().A value of type  a† may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like Iforeign import ccall "stdlib.h &free" p_free :: FunPtr (Ptr a -> IO ())3or a pointer to a Haskell function created using a wrapper stub declared to produce a # of the correct type. For example: ntype Compare = Int -> Int -> Bool foreign import ccall "wrapper" mkCompare :: Compare -> IO (FunPtr Compare)Calls to wrapper stubs like  mkCompare2 allocate storage, which should be released with 1Ô when no longer required. To convert > values to corresponding Haskell functions, one can define a dynamic) stub for the specific foreign type, e.g. ltype IntFunction = CInt -> IO () foreign import ccall "dynamic" mkFun :: FunPtr IntFunction -> IntFunctionè The constant è# contains a distinguished value of Œ6 that is not associated with a valid memory location.éThe é3 function casts a pointer from one type to another.ê8Advances the given address by the given offset in bytes.ë9Given an arbitrary address and an alignment constraint, ëb yields the next higher address that fulfills the alignment constraint. An alignment constraint x+ is fulfilled by any address divisible by x . This operation is idempotent.ìTComputes the offset required to get from the second to the first argument. We have %p2 == p1 `plusPtr` (p2 `minusPtr` p1)í The constant í$ contains a distinguished value of 6 that is not associated with a valid memory location.îCasts a  to a  of a different type.ïCasts a  to a Œ.Note:Ü this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption.ðCasts a Œ to a .Note:Ü this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption. ŒçæèéêëìíîïðŒçæÕ((c) The University of Glasgow, 1992-2004see libraries/base/LICENSEffi@haskell.orginternalnon-portable (GHC Extensions)UnsafeDâ=Create a stable pointer referring to the given Haskell value.„A stable pointerÿ˜ is a reference to a Haskell expression that is guaranteed not to be affected by garbage collection, i.e., it will neither be deallocated nor will the value of the stable pointer itself change during garbage collection (ordinary references may be relocated during garbage collection). Consequently, stable pointers can be passed to foreign code, which can treat it as an opaque reference to a Haskell value.A value of type  StablePtr a5 is a stable pointer to a Haskell expression of type a.ñ|Dissolve the association between the stable pointer and the Haskell value. Afterwards, if the stable pointer is passed to ò or ñT, the behaviour is undefined. However, the stable pointer may still be passed to ó , but the 1Ö () value returned by ó8, in this case, is undefined (in particular, it may be 1×). Nevertheless, the call to ó is guaranteed not to diverge.ò}Obtain the Haskell value referenced by a stable pointer, i.e., the same value that was passed to the corresponding call to  makeStablePtr. If the argument to ò has already been freed using ñ, the behaviour of ò is undefined.ó—Coerce a stable pointer to an address. No guarantees are made about the resulting value, except that the original stable pointer can be recovered by ô. In particular, the address may not refer to an accessible memory location and any attempt to pass it to the member functions of the class CÊ leads to undefined behaviour.ôThe inverse of ó, i.e., we have the identity 0sp == castPtrToStablePtr (castStablePtrToPtr sp)for any stable pointer sp on which ñ( has not been executed yet. Moreover, ô> may only be applied to pointers that have been produced by ó.„ñòóô„"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy-„ñòóô„òñóôØ'(c) The University of Glasgow 1997-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeD–hiþÿ    Ù((c) The University of Glasgow, 1997-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyD#87ˆ8-bit unsigned integer type‰16-bit unsigned integer typeŠ32-bit unsigned integer type‹64-bit unsigned integer typeõSwap bytes in ‰.öReverse order of bytes in Š.ùReverse order of bytes in ‹.  !"#$%&'()*+,-./0123456789:;<-‡Ëˆ=‰>Š?‹@îïðñüýABCDEFGHIJKLõMNOPQRöSTUVWX÷øùˆ=‰>Š?‹@4 Trustworthy$ŒûúÒúÒúÒ0"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafe&ʇˆ‰Š‹õöù‡ˆ‰Š‹õöùÚ Trustworthy(‚YGReturn monotonic time in seconds, since some unspecified starting pointYÛ'(c) The University of Glasgow 1997-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy0D`1@4y8-bit signed integer typez16-bit signed integer type{32-bit signed integer type|64-bit signed integer typeZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰*xÇyŠz‹{Œ|ôõö÷øùŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥yŠz‹{Œ|Ü!(c) The FFI task force, 2000-2002see libraries/base/LICENSEffi@haskell.orginternalnon-portable (GHC Extensions) TrustworthyD42 ¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅC(c) The FFI task force 2001see libraries/base/LICENSEffi@haskell.org provisionalportable TrustworthyVh’ÿLThe member functions of this class facilitate writing values of primitive types to raw memory (which may have been allocated with the above mentioned routines) and reading values from blocks of raw memory. The class, furthermore, includes support for computing the storage requirements and alignment restrictions of storable types.3Memory addresses are represented as values of type Œ a , for some a which is an instance of class . The type argument to Œã helps provide some valuable type safety in FFI code (you can't mix pointers of different types without an explicit cast), while helping the Haskell type system figure out which marshalling method is needed for a given pointer.ÿgAll marshalling between Haskell and a foreign language ultimately boils down to translating Haskell data structures into the binary representation of a corresponding data structure of the foreign language and vice versa. To code this marshalling in Haskell, it is necessary to manipulate primitive data types stored in unstructured memory blocks. The class ˆ facilitates this manipulation on all types for which it is instantiated, which are the standard basic types of Haskell, the fixed size Int types (y, z, {, |), the fixed size Word types (ˆ, ‰, Š, ‹), „, all types from Foreign.C.Types , as well as Œ.eComputes the storage requirements (in bytes) of the argument. The value of the argument is not used.MComputes the alignment constraint of the argument. An alignment constraint x+ is fulfilled by any address divisible by x). The value of the argument is not used.ÿRead a value from a memory area regarded as an array of values of the same kind. The first argument specifies the start address of the array and the second the index into the array (the first element of the array has index 0!). The following equality holds, ^peekElemOff addr idx = IOExts.fixIO $ \result -> peek (addr `plusPtr` (idx * sizeOf result))vNote that this is only a specification, not necessarily the concrete implementation of the function.wWrite a value to a memory area regarded as an array of values of the same kind. The following equality holds: DpokeElemOff addr idx x = poke (addr `plusPtr` (idx * sizeOf x)) xoRead a value from a memory location given by a base address and offset. The following equality holds: 0peekByteOff addr off = peek (addr `plusPtr` off)nWrite a value to a memory location given by a base address and offset. The following equality holds: 4pokeByteOff addr off x = poke (addr `plusPtr` off) x ,Read a value from the given memory location.ßNote that the peek and poke functions might require properly aligned addresses to function correctly. This is architecture dependent; thus, portable code should ensure that when peeking or poking values of some type a!, the alignment constraint for a, as given by the function  is fulfilled. ^Write the given value to the given memory location. Alignment restrictions might apply; see  .          *"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthyk@xyz{|xyz{|F(C) 2014 Herbert Valerio Riedel, (C) 2011 Edward Kmettsee libraries/base/LICENSElibraries@haskell.orginternalnon-portable (GHC Extensions)UnsafeDK~ÓL ~<Type representing arbitrary-precision non-negative integers.+Operations whose result would be negative throw ( Underflow :: ArithException).in [0, maxBound::Word] in ]maxBound::Word, +inf[ Invariant:   is used iff value doesn't fit in  constructor.!6Test whether all internal invariants are satisfied by ~ valueNThis operation is mostly useful for test-suites and/or code which constructs } values directly.Æ Compute greatest common divisor.Ç compute least common multiplier.È~ AdditionÉ~ multiplicationÊ~ subtraction. May throw  Underflow."~ subtraction. Returns Ès for non-positive results.ËConvert Ì to ~ . Throws  Underflow if passed a Í.ÎConvert x to ~ . Throws  Underflow when passed a negative x.# Construct ~ from ‡ value.$Try downcasting ~ to ‡ value. Returns È if value doesn't fit in ‡.%"% b e m" computes base b raised to exponent e modulo m.&'()*+,- L~ !"#$% ~ !L#$"%~ +F(C) 2014 Herbert Valerio Riedel, (C) 2011 Edward Kmettsee libraries/base/LICENSElibraries@haskell.org provisionalportable Trustworthy¢~~Ý((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyƒÒ0See Þ01234012341(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy0:DK‘ú5EA signed integral type that can be losslessly converted to and from Ptr2. This type is also compatible with the C99 type intptr_t6, and can be marshalled to and from that type safely.7HAn unsigned integral type that can be losslessly converted to and from Ptr1. This type is also compatible with the C99 type  uintptr_t6, and can be marshalled to and from that type safely.9.Release the storage associated with the given Ð, which must have been obtained from a wrapper stub. This should be called whenever the return value from a foreign import wrapper function is no longer required; otherwise, the storage it uses will leak.:casts a Ptr to a WordPtr;casts a WordPtr to a Ptr<casts a Ptr to an IntPtr= casts an IntPtr to a PtrŒèéêëìíîïð56789:;<=Œèéêëìíîïð956<=78:;5678D(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy0:DK¨Ç^ Haskell type representing the C jmp_buf type._ Haskell type representing the C fpos_t type.` Haskell type representing the C FILE type.a Haskell type representing the C  suseconds_t type.c Haskell type representing the C  useconds_t type.e Haskell type representing the C time_t type.g Haskell type representing the C clock_t type.i Haskell type representing the C  sig_atomic_t type.k Haskell type representing the C wchar_t type.m Haskell type representing the C size_t type.o Haskell type representing the C  ptrdiff_t type.q Haskell type representing the C double type.s Haskell type representing the C float type.u  Haskell type representing the C bool type.w Haskell type representing the C unsigned long long type.y Haskell type representing the C  long long type.{ Haskell type representing the C  unsigned long type.} Haskell type representing the C long type. Haskell type representing the C  unsigned int type. Haskell type representing the C int type.ƒ Haskell type representing the C unsigned short type.… Haskell type representing the C short type.‡ Haskell type representing the C  unsigned char type.‰ Haskell type representing the C  signed char type.‹ Haskell type representing the C char type.7VWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ7‹Œ‰Š‡ˆ…†ƒ„‚€}~{|opmnklijyzwxuv\]Z[XYVWghefcdabstqr`_^VWXYZ[\]^Ï_Ð`Ñabcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ/4BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimental not portable Trustworthy&',-06;=>?AFQSTVÇÒ|Lifted, homogeneous equality. By lifted, we mean that it can be bogus (deferred type error). By homogeneous, the two types a and b must have the same kind.µLA type family to compute Boolean equality. Instances are provided only for open kinds, such as *o and function kinds. Instances are also provided for datatypes exported from base. A poly-kinded instance is notS provided, as a recursive definition for algebraic kinds is generally more useful.¶gThis class contains types where you can learn the equality of two types from information contained in terms=. Typically, only singleton types should inhabit this class.·$Conditionally prove the equality of a and b.¸ 9Kind heterogeneous propositional equality. Like '(:~:)', a :~~: b5 is inhabited by a terminating value if and only if a is the same type as b.ºPropositional equality. If a :~: b8 is inhabited by some terminating value, then the type a is the same as the type b:. To use this equality in practice, pattern-match on the a :~: b to get out the ReflI constructor; in the body of the pattern-match, the compiler knows that a ~ b.¼Symmetry of equality½Transitivity of equality¾,Type-safe cast, using propositional equality¿?Generalized form of type-safe cast using propositional equalityÀ+Apply one equality to another, respectivelyÁCExtract equality of the arguments from an equality of applied typesÂGExtract equality of type constructors from an equality of applied typesà ÄÅÆ Ç È ÉÊ Ë Ì Í Î…µ¶·¸¹º»¼½¾¿ÀÁº»…¸¹¼½¾¿ÀÁ¶·µ¶·¸¹º»µ4¸4º4E4BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimental not portableNone&',06;=FQSTV×òÒgThis class contains types where you can learn the equality of two types from information contained in terms=. Typically, only singleton types should inhabit this class.Ó5Conditionally prove the representational equality of a and b.ÔRepresentational equality. If  Coercion a b8 is inhabited by some terminating value, then the type a4 has the same underlying representation as the type b.7To use this equality in practice, pattern-match on the  Coercion a b to get out the  Coercible a b instance, and then use   to apply it.Ö/Type-safe cast, using representational equality× BGeneralized form of type-safe cast using representational equalityØ%Symmetry of representational equalityÙ)Transitivity of representational equalityÚEConvert propositional (nominal) equality to representational equalityÛÜÝÞ ßà ÒÓÔÕÖ×ØÙÚ ÔÕÖ×ØÙÚÒÓÒÓÔÕF(c) Ashley Yakeley 20074BSD-style (see the LICENSE file in the distribution)ashley@semantic.org experimentalportable Trustworthy&',FÝ™ ä9A class for categories. id and (.) must form a monoid.åthe identity morphismæmorphism compositionçRight-to-left compositionèLeft-to-right compositionéê ëìäåæçè äåæìëêéçèäåææ9 ç1è1G4BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimentalportable Trustworthy,Fç¶í‹A concrete, promotable proxy type, for use at the kind level There are no instances for this because it is intended at the kind level onlyï"A concrete, poly-kinded proxy typeññ! is a type-restricted version of H¤. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the tag of the second.ò óô õö÷øùúûüýíîïðñïðñíîíîïð "(c) The University of Glasgow 2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthyô ÿThe ÿG type allows you to reverse sort order conveniently. A value of type ÿ a contains a value of type a (represented as ÿ a). If a has an [Ò instance associated with it then comparing two values thus wrapped will give you the opposite of their normal sort order. This is particularly useful when sorting in generalised list comprehensions, as in: then sortWith by ÿ x Provides ` and \ instances (since: 4.7.0.0). %comparing p x y = compare (p x) (p y)2Useful combinator for use in conjunction with the xxxBy family of functions from  Data.List, for example:  ... sortBy (comparing fst) ...[)€ÎÏÐÿ[)€ÎÏÐÿÿ2"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthy ,-0FSTCf ŽThe Ž@ type represents values with two possibilities: a value of type Ž a b is either Ì a or Í b.The Že type is sometimes used to represent a value which is either correct or an error; by convention, the Ì4 constructor is used to hold an error value and the ÍV constructor is used to hold a correct value (mnemonic: "right" also means "correct").Examples The type Ž / x- is the type of values which can be either a / or an x. The Ì! constructor can be used only on / s, and the Í! constructor can be used only on xs:'let s = Left "foo" :: Either String Ints Left "foo"$let n = Right 3 :: Either String IntnRight 3:type ss :: Either String Int:type nn :: Either String IntThe . from our Y instance will ignore ÌG values, but will apply the supplied function to values contained in a Í:'let s = Left "foo" :: Either String Int$let n = Right 3 :: Either String Int fmap (*2) s Left "foo" fmap (*2) nRight 6The W instance for Ž¬ allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an x from a u , or fail.(import Data.Char ( digitToInt, isDigit ):{0 let parseEither :: Char -> Either String Int parseEither c, | isDigit c = Right (digitToInt c)* | otherwise = Left "parse error":}&The following should work, since both '1' and '2' can be parsed as xs.:{* let parseMultiple :: Either String Int parseMultiple = do x <- parseEither '1' y <- parseEither '2' return (x + y):} parseMultipleRight 3[But the following should fail overall, since the first operation where we attempt to parse 'm' as an x will fail::{* let parseMultiple :: Either String Int parseMultiple = do x <- parseEither 'm' y <- parseEither '2' return (x + y):} parseMultipleLeft "parse error"Case analysis for the Ž type. If the value is Ì a, apply the first function to a ; if it is Í b, apply the second function to b.ExamplesWe create two values of type Ž / x, one using the Ì# constructor and another using the Í* constructor. Then we apply "either" the length function (if we have a /.) or the "times-two" function (if we have an x):'let s = Left "foo" :: Either String Int$let n = Right 3 :: Either String Inteither length (*2) s3either length (*2) n6Extracts from a list of Ž all the Ì elements. All the Ì! elements are extracted in order.Examples Basic usage:Clet list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ] lefts list["foo","bar","baz"]Extracts from a list of Ž all the Í elements. All the Í! elements are extracted in order.Examples Basic usage:Clet list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ] rights list[3,7] Partitions a list of Ž into two lists. All the ÌY elements are extracted, in order, to the first component of the output. Similarly the Í? elements are extracted to the second component of the output.Examples Basic usage:Clet list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]partitionEithers list(["foo","bar","baz"],[3,7])The pair returned by   x should be the same pair as ( x,  x):Clet list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]2partitionEithers list == (lefts list, rights list)True Return Ê if the given value is a Ì-value, Å otherwise.Examples Basic usage:isLeft (Left "foo")TrueisLeft (Right 3)False Assuming a Ì1 value signifies some sort of error, we can use  ’ to write a very simple error-reporting function that does absolutely nothing in the case of success, and outputs "ERROR" if any error occurred.This example shows how  o might be used to avoid pattern matching when one does not care about the value contained in the constructor:import Control.Monad ( when )1let report e = when (isLeft e) $ putStrLn "ERROR"report (Right 1)report (Left "parse error")ERROR Return Ê if the given value is a Í-value, Å otherwise.Examples Basic usage:isRight (Left "foo")FalseisRight (Right 3)True Assuming a Ì1 value signifies some sort of error, we can use  i to write a very simple reporting function that only outputs "SUCCESS" when a computation has succeeded.This example shows how  o might be used to avoid pattern matching when one does not care about the value contained in the constructor:import Control.Monad ( when )4let report e = when (isRight e) $ putStrLn "SUCCESS"report (Left "parse error")report (Right 1)SUCCESS  Return the contents of a Ì$-value or a default value otherwise.Examples Basic usage:fromLeft 1 (Left 3)3fromLeft 1 (Right "foo")1  Return the contents of a Í$-value or a default value otherwise.Examples Basic usage:fromRight 1 (Right 3)3fromRight 1 (Left "foo")1 ŽÌÍ     ŽÌÍ     ŽÌÍ"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional0non-portable (uses Text.ParserCombinators.ReadP) TrustworthyLwequivalent to Ê with a precedence of 0.Parse a string using the \> instance. Succeeds if there is exactly one valid result. A Ì value indicates a parse error.Parse a string using the \: instance. Succeeds if there is exactly one valid result.The ] function reads input from a string, which must be completely consumed by the input process.)\ÊËÌÍk™š›œžŸ ¡¢£¤¥¦§¨©±²¶³·´µ¸ÎÏÐÑÕÖ\ÊËÌÍkÎѱ²³´µ¶·¸ÕÖÏÐ)"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthy„úConvert a single digit u to the corresponding x6. This function fails unless its argument satisfies ZK, but recognises both upper- and lower-case hexadecimal digits (that is, '0'..'9', 'a'..'f', 'A'..'F').Examples Characters '0' through '9' are converted properly to 0..9:map digitToInt ['0'..'9'][0,1,2,3,4,5,6,7,8,9]Both upper- and lower-case 'A' through 'F' are converted as well, to 10..15.map digitToInt ['a'..'f'][10,11,12,13,14,15]map digitToInt ['A'..'F'][10,11,12,13,14,15]"Anything else throws an exception:digitToInt 'G'/*** Exception: Char.digitToInt: not a digit 'G'digitToInt '&e'3*** Exception: Char.digitToInt: not a digit '\9829'±Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters). This function is equivalent to )ß.This function returns Ê+ if its argument has one of the following 3s, or Å otherwise:45678"These classes are defined in the  @http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character DatabaseZ, part of the Unicode standard. The same document defines what is and is not a "Letter".Examples Basic usage: isLetter 'a'True isLetter 'A'True isLetter '0'False isLetter '%'False isLetter '&e'FalseisLetter '\31'False Ensure that  and ] are equivalent.let chars = [(chr 0)..] let letters = map isLetter charslet alphas = map isAlpha charsletters == alphasTruelSelects Unicode mark characters, for example accents and the like, which combine with preceding characters.This function returns Ê+ if its argument has one of the following 3s, or Å otherwise:9:;"These classes are defined in the  @http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character DatabaseX, part of the Unicode standard. The same document defines what is and is not a "Mark".Examples Basic usage: isMark 'a'False isMark '0'FalseqCombining marks such as accent characters usually need to follow another character before they become printable:map isMark "o" [False,True]#Puns are not necessarily supported: isMark '''FalsefSelects Unicode numeric characters, including digits from various scripts, Roman numerals, et cetera.This function returns Ê+ if its argument has one of the following 3s, or Å otherwise:<=>"These classes are defined in the  @http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character DatabaseZ, part of the Unicode standard. The same document defines what is and is not a "Number".Examples Basic usage: isNumber 'a'False isNumber '%'False isNumber '3'TrueASCII '0' through '9' are all numbers:and $ map isNumber ['0'..'9']True-Unicode Roman numerals are "numbers" as well: isNumber '!h'True/Selects Unicode space and separator characters.This function returns Ê+ if its argument has one of the following 3s, or Å otherwise:JKL"These classes are defined in the  @http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_TableUnicode Character Database], part of the Unicode standard. The same document defines what is and is not a "Separator".Examples Basic usage:isSeparator 'a'FalseisSeparator '6'FalseisSeparator ' 'TrueDWarning: newlines and tab characters are not considered separators.isSeparator '\n'FalseisSeparator '\t'False1But some more exotic characters are (like HTML's &nbsp;):isSeparator '\160'True?uF«¬¶3M456789:;<=>?@ABCDEFGHIJKLNOPQRSTUVWXYZ[\]^_`abcdeÒÓ?u_Wba]^`XYZ[\STVU3456789:;<=>?@ABCDEFGHIJKLMNOPQRdce¬F¶«ÒÓà"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable TrustworthyDV 9Ø?The p function drops the largest suffix of a list in which the given predicate holds for all elements. For example: “dropWhileEnd isSpace "foo\n" == "foo" dropWhileEnd isSpace "foo bar" == "foo bar" dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefinedThe : function drops the given prefix from a list. It returns È6 if the list did not start with the prefix given, or É' the list after the prefix, if it does. šstripPrefix "foo" "foobar" == Just "bar" stripPrefix "foo" "foo" == Just "" stripPrefix "foo" "barfoo" == Nothing stripPrefix "foo" "barfoobaz" == Nothing The  W function returns the index of the first element in the given list which is equal (by () to the query element, or È if there is no such element.!The ! function extends  [, by returning the indices of all elements equal to the query element, in ascending order."The "m function takes a predicate and a list and returns the first element in the list matching the predicate, or È if there is no such element.#The #} function takes a predicate and a list and returns the index of the first element in the list satisfying the predicate, or È if there is no such element.$The $ function extends #Y, by returning the indices of all elements satisfying the predicate, in ascending order.%The %& function takes two lists and returns Ê/ iff the first list is a prefix of the second.&The && function takes two lists and returns ÊP iff the first list is a suffix of the second. The second list must be finite.'The '& function takes two lists and returns ÊR iff the first list is contained, wholly and intact, anywhere within the second.Example: fisInfixOf "Haskell" "I really like Haskell." == True isInfixOf "Ial" "I really like Haskell." == False(O(n^2). The ( function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name (, means `essence'.) It is a special case of )A, which allows the programmer to supply their own equality test.)The ) function behaves just like (O, except it uses a user-supplied equality predicate instead of the overloaded ( function.** x! removes the first occurrence of x& from its list argument. For example, delete 'a' "banana" == "bnana"It is a special case of +A, which allows the programmer to supply their own equality test.+The + function behaves like *0, but takes a user-supplied equality predicate.,The ,B function is list difference (non-associative). In the result of xs , ys+, the first occurrence of each element of ys( in turn (if any) has been removed from xs. Thus (xs ++ ys) \\ xs == ys.It is a special case of MA, which allows the programmer to supply their own equality test.-The -@ function returns the list union of the two lists. For example, "dog" `union` "cow" == "dogcw"¬Duplicates, and elements of the first list, are removed from the the second list, but if the first list contains duplicates, so will the result. It is a special case of .A, which allows the programmer to supply their own equality test..The .+ function is the non-overloaded version of -./The /A function takes the list intersection of two lists. For example, ([1,2,3,4] `intersect` [2,4,6,8] == [2,4]:If the first list contains duplicates, so will the result. ,[1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4]It is a special case of 0¯, which allows the programmer to supply their own equality test. If the element is found in both the first and the second list, the element from the first list will be used.0The 0+ function is the non-overloaded version of /.1The 1v function takes an element and a list and `intersperses' that element between the elements of the list. For example, &intersperse ',' "abcde" == "a,b,c,d,e"22 xs xss is equivalent to ( (1 xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.3The 3H function transposes the rows and columns of its argument. For example, 2transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]TIf some of the rows are shorter than the following rows, their elements are skipped: Ctranspose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]4The 4 function takes a predicate a list and returns the pair of lists of elements which do and do not satisfy the predicate, respectively; i.e., 4partition p xs == (filter p xs, filter (not . p) xs)5The 5( function behaves like a combination of  and {¶; it applies a function to each element of a list, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.6The 6( function behaves like a combination of  and ¶; it applies a function to each element of a list, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new list.7The 7ÿ function takes an element and a list and inserts the element into the list at the first position where it is less than or equal to the next element. In particular, if the list is sorted before the call, the result will also be sorted. It is a special case of 8G, which allows the programmer to supply their own comparison function.8The non-overloaded version of 7.9The 9¢ function takes a comparison function and a list and returns the greatest element of the list by the comparison function. The list must be finite and non-empty.:The :Ÿ function takes a comparison function and a list and returns the least element of the list by the comparison function. The list must be finite and non-empty.;The ;& function is an overloaded version of z+. In particular, instead of returning an x/, it returns any type which is an instance of Z'. It is, however, less efficient than z.<The <& function is an overloaded version of , which accepts any V) value as the number of elements to take.=The =& function is an overloaded version of , which accepts any V) value as the number of elements to drop.>The >& function is an overloaded version of ‘, which accepts any V) value as the position at which to split.?The ?& function is an overloaded version of , which accepts any V value as the index.@The @& function is an overloaded version of ‹, which accepts any V, value as the number of repetitions to make.AThe AK function takes four lists and returns a list of quadruples, analogous to .BThe BL function takes five lists and returns a list of five-tuples, analogous to .CThe CJ function takes six lists and returns a list of six-tuples, analogous to .DThe DN function takes seven lists and returns a list of seven-tuples, analogous to .EThe E’ function takes a function which combines four elements, as well as four lists and returns a list of their point-wise combination, analogous to Ÿ.FThe F’ function takes a function which combines five elements, as well as five lists and returns a list of their point-wise combination, analogous to Ÿ.GThe G function takes a function which combines six elements, as well as six lists and returns a list of their point-wise combination, analogous to Ÿ.HThe H” function takes a function which combines seven elements, as well as seven lists and returns a list of their point-wise combination, analogous to Ÿ.IThe IK function takes a list of quadruples and returns four lists, analogous to ¡.JThe JL function takes a list of five-tuples and returns five lists, analogous to ¡.KThe KJ function takes a list of six-tuples and returns six lists, analogous to ¡.LThe LN function takes a list of seven-tuples and returns seven lists, analogous to ¡.MThe MŒ function takes a predicate and two lists and returns the first list with the first occurrence of each element of the second list removed.NThe NÊ function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example, :group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]It is a special case of OA, which allows the programmer to supply their own equality test.OThe O+ function is the non-overloaded version of N.PThe PV function returns all initial segments of the argument, shortest first. For example, "inits "abc" == ["","a","ab","abc"] Note that P) has the following strictness property: #inits (xs ++ _|_) = inits xs ++ _|_In particular, inits _|_ = [] : _|_QThe QS function returns all final segments of the argument, longest first. For example, $tails "abc" == ["abc", "bc", "c",""] Note that Q) has the following strictness property: tails _|_ = _|_ : _|_RThe R? function returns the list of all subsequences of the argument. ;subsequences "abc" == ["","a","b","ab","c","ac","bc","abc"]ÓThe Ó] function returns the list of all subsequences of the argument, except for the empty list. @nonEmptySubsequences "abc" == ["a","b","ab","c","ac","bc","abc"]SThe S? function returns the list of all permutations of the argument. ;permutations "abc" == ["abc","bac","cba","bca","cab","acb"]TThe TJ function implements a stable sorting algorithm. It is a special case of UG, which allows the programmer to supply their own comparison function.oElements are arranged from from lowest to highest, keeping duplicates in the order they appeared in the input.UThe U+ function is the non-overloaded version of T.VRSort a list by comparing the results of a key function applied to each element. sortOn f is equivalent to sortBy (comparing f)8, but has the performance advantage of only evaluating f| once for each element in the input list. This is called the decorate-sort-undecorate paradigm, or Schwartzian transform.oElements are arranged from from lowest to highest, keeping duplicates in the order they appeared in the input.WThe W function is a `dual' to : while % reduces a list to a summary value, WO builds a list from a seed value. The function takes the element and returns È. if it is done producing the list or returns É (a,b), in which case, a is a prepended to the list and b@ is used as the next element in a recursive call. For example, *iterate f == unfoldr (\x -> Just (x, f x))In some cases, W can undo a  operation: unfoldr f' (foldr f z xs) == xsif the following holds: ,f' (f x y) = Just (x,y) f' z = NothingA simple use of unfoldr: Tunfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10 [10,9,8,7,6,5,4,3,2,1]XXr breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.¢Note that after splitting the string at newline characters, the last part of the string is considered a line even if it doesn't end with a newline. For example, µlines "" == [] lines "\n" == [""] lines "one" == ["one"] lines "one\n" == ["one"] lines "one\n\n" == ["one",""] lines "one\ntwo" == ["one","two"] lines "one\ntwo\n" == ["one","two"]Thus X s3 contains at least as many elements as newlines in s.YY is an inverse operation to XA. It joins lines, after appending a terminating newline to each.ZZO breaks a string up into a list of words, which were delimited by white space.[[ is an inverse operation to Z). It joins words with separating spaces.stuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ÔÕ,5"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafe =æstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[stwvxuyz”123RS{|}~„œ•–—˜€‡ˆƒ‚…†56‰Š‹ŒW‘Ž’“NPQ%&'™š›"4 !#$žABCDŸ EFGH¡¢IJKLXZY[(*,-/TV7)+M.0OU89:;<=>?@"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe E\WShow a list (using square brackets and commas), given a function for showing elements. `£¤¥¦§¨©ª\ ¦`£¤¥§¨©ª\HMalcolm Wallace 20064BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimentalportableUnsafeD Gd]]% Trustworthy+,-;<=CDFQSTV WnŽThis class gives the integer associated with a type-level natural. There are instances of the class for every concrete literal: 0, 1, 2, etc.³ Addition of type-level naturals.´&Multiplication of type-level naturals.µ&Exponentiation of type-level naturals.¶rComparison of type-level naturals, as a function. NOTE: The functionality for this function should be subsumed by ¹k, so this might go away in the future. Please let us know, if you encounter discrepancies between the two. ·#Subtraction of type-level naturals.¹1Comparison of type-level naturals, as a function.^3Comparison of type-level naturals, as a constraint._ 8This type represents unknown type-level natural numbers.a b c 6Convert an integer into an unknown type-level natural.daWe either get evidence that this function was instantiated with the same type-level numbers, or È.efghn±³´µ¶·¹^_`abcd±nab_`cd^¶³´µ·¹nÖ×ØÙÚ_`³6´7µ8¶4·6^4& Trustworthy+,-;<=CDFQSTV r_oŒThis class gives the string associated with a type-level symbol. There are instances of the class for every concrete literal: "hello", etc.¸0Comparison of type-level symbols, as a function.º The type-level equivalent of error.¿The polymorphic kind of this type allows it to be used in several settings. For instance, it can be used as a constraint, e.g. to provide a better error message for a non-existent instance, 1-- in a context instance TypeError (Text "Cannot `” functions." :$$: Text "Perhaps there is a missing argument?") => Show (a -> b) where showsPrec = error "unreachable" oIt can also be placed on the right-hand side of a type-level function to provide an error for an invalid case, Õtype family ByteSize x where ByteSize Word16 = 2 ByteSize Word8 = 1 ByteSize a = TypeError (Text "The type " :<>: ShowType a :<>: Text " is not exportable.")  $Concatenation of type-level symbols.ØShow the text as is.Ù4Put two pieces of error message next to each other.Ú8Stack two pieces of error message on top of each other.ÛPretty print the type. ShowType :: k -> ErrorMessagei%A description of a custom type error.j0This type represents unknown type-level symbols.klmnop6Convert an integer into an unknown type-level natural.q3Convert a string into an unknown type-level symbol.raWe either get evidence that this function was instantiated with the same type-level symbols, or È.stuvno±²³´µ¶·¸¹ºÂ^_`diØÙÚÛjklmnopqr±²nlnomo_`jkpqdr^¶³´µ·Â¹¸ºiØÛÙÚoÛÜÝÞßiØÛÙÚjkÙ6Ú5$B(c) Universiteit Utrecht 2010-2011, University of Oxford 2012-2014see libraries/base/LICENSElibraries@haskell.orginternal non-portable Trustworthy&',-036;<=DFKSTV Ô’yi^Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.jRepresentable types of kind * -> * (or kind k -> *, when  PolyKinds8 is enabled). This class is derivable in GHC with the  DeriveGeneric flag on.k,Class for datatypes that represent datatypesl4Class for datatypes that represent data constructorsm*Class for datatypes that represent records—-Void: used for datatypes without constructors˜-Unit: used for constructors without arguments™-Used for marking occurrences of the parameteršRecursive calls of kind * -> * (or kind k -> *, when  PolyKinds is enabled)›7Constants, additional parameters and recursion of kind *œ*Meta-information (constructor names, etc.)(Sums: encode choice between constructorsž3Products: encode multiple arguments to constructorsŸComposition of functors Tag for K1: recursion (of kind *)¡Tag for M1: datatype¢Tag for M1: constructor£Tag for M1: record selector¤-Type synonym for encoding recursion (of kind *)¥8Type synonym for encoding meta-information for datatypes¦;Type synonym for encoding meta-information for constructors§?Type synonym for encoding meta-information for record selectors¨Generic representation type©Generic representation typeª Constants of unlifted kinds« Type synonym for ª w¬ Type synonym for ª z­ Type synonym for ª {® Type synonym for ª |¯ Type synonym for ª }° Type synonym for ª àThe à class is essentially a kind° class. It classifies all kinds for which singletons are defined. The class supports converting between a singleton type and the base (unrefined) type which it is built from.áBGet a base type from a proxy for the promoted kind. For example, DemoteRep Bool will be the type Bool.â-Convert a singleton to its unrefined version.ãA ã‹ constraint is essentially an implicitly-passed singleton. If you need to satisfy this constraint with an explicit singleton, please see  withSingI.ä;Produce the singleton explicitly. You will likely need the ScopedTypeVariables0 extension to use this method the way you want.å'The singleton kind-indexed data family.w ;Datatype to represent metadata associated with a datatype (MetaData), constructor (MetaCons), or field selector (MetaSel).In MetaData n m p nt, n is the datatype's name, m4 is the module in which the datatype is defined, p9 is the package in which the datatype is defined, and nt is 'True if the datatype is a newtype.In MetaCons n f s, n is the constructor's name, f is its fixity, and s is 'True. if the constructor contains record selectors.In MetaSel mn su ss ds(, if the field uses record syntax, then mn is É the record name. Otherwise, mn is È. su and ssA are the field's unpackedness and strictness annotations, and ds4 is the strictness that GHC infers for the field.x/Convert from the datatype to its representationy/Convert from the representation to the datatypez/Convert from the datatype to its representation{/Convert from the representation to the datatype|The name of the selector} /The selector's unpackedness annotation (if any)~ -The selector's strictness annotation (if any) :The strictness that the compiler inferred for the selector€ qThe strictness that GHC infers for a field during compilation. Whereas there are nine different combinations of ‚ and à, the strictness that GHC decides will ultimately be one of lazy, strict, or unpacked. What GHC decides is affected both by what the user writes in the source code and by GHC flags. As an example, consider this data type: 9data E = ExampleConstructor {-# UNPACK #-} !Int !Int Int UIf compiled without optimization or other language extensions, then the fields of ExampleConstructor will have è, è , and ç, respectively.If compiled with  -XStrictData' enabled, then the fields will have è, è, and è, respectively.If compiled with -O2$ enabled, then the fields will have é, è, and ç, respectively. lThe strictness of a field as the user wrote it in the source code. For example, in the following data type: *data E = ExampleConstructor Int ~Int !Int The fields of ExampleConstructor have æ, ä, and å, respectively.‚ nThe unpackedness of a field as the user wrote it in the source code. For example, in the following data type: ddata E = ExampleConstructor Int {-# NOUNPACK #-} Int {-# UNPACK #-} Int The fields of ExampleConstructor have ã, â, and á, respectively.ƒ8Datatype to represent the associativity of a constructor„ This variant of … appears at the type level.…uDatatype to represent the fixity of a constructor. An infix | declaration directly corresponds to an application of ‡.ˆThe name of the constructor‰The fixity of the constructorŠ%Marks if this constructor is a record‹&The name of the datatype (unqualified)ŒAThe fully-qualified name of the module where the type is declared 9The package name of the module where the type is declaredŽ+Marks if the datatype is actually a newtype%Get the precedence of a fixity value.æ  Used for marking occurrences of ç  Used for marking occurrences of }è  Used for marking occurrences of |é  Used for marking occurrences of {ê  Used for marking occurrences of zë  Used for marking occurrences of wž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å ÆÇ È É Ê Ë Ì Í c d e f g h i ci¨z{j©xykŒ‹Žlˆ‰Šm|}~—˜œ™š›š˜™›–—œ”•’“ž‘Ÿ ¡¢£¤¥¦§ªìíîïðñòóôõö÷«¬­®¯°wêëì€çèéäåæ‚áâãƒÞßà„ÜÝ…†‡W—˜œ™š›š˜™›–—œ”•’“ž‘Ÿª«¬­®¯°¤ ¥¦§¡¢£k‹ŒŽlˆ‰Šm|}~…†‡„Ü݃Þßà‚ãâáæäå€çèéwêëìi¨z{j©xy$i¨z{j©xyk‹ŒŽlˆ‰Šm|}~˜œ™š›š˜™›–—œ”•’“ž‘Ÿàáâãäwêëì€çèéæäå‚ãâáƒÞßà„ÜÝ…†‡æñ÷çðöèïõéîôêíóëìòøùúûüýþÿ     5ž6Ÿ7‘6a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthy,6FKV çõn Monoid under 5.q7Maybe monoid returning the rightmost non-Nothing value.q a is isomorphic to † (t a), and thus to † (n  a)t6Maybe monoid returning the leftmost non-Nothing value.t a is isomorphic to n  a , but precedes it historically.wMonoid under multiplication.zMonoid under addition.}"Boolean monoid under disjunction ().€"Boolean monoid under conjunction ().ƒ.The monoid of endomorphisms under composition.†The dual of a r(, obtained by swapping the arguments of G.‰An infix synonym for G.Š‹ŒŽ‘’“”•–—˜™š› rFGHnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰ rFGH‰†‡ˆƒ„…€‚}~z{|wxytuvqrsnop nopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰6"Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimentalportable Trustworthy05;=STV Të1g#Data structures that can be folded.For example, given a data type 7data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)a suitable instance would be  instance Foldable Tree where foldMap f Empty = mempty foldMap f (Leaf x) = f x foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f rThis is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr: ‹instance Foldable Tree where foldr f z Empty = z foldr f z (Leaf x) = f x z foldr f z (Node l k r) = foldr f (f k (foldr f z r)) lFoldable6 instances are expected to satisfy the following laws: /foldr f z t = appEndo (foldMap (Endo . f) t ) z Dfoldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z fold = foldMap idsum, product, maximum, and minimum* should all be essentially equivalent to foldMap forms, such as sum = getSum . foldMap Sumbut may be less defined.If the type is also a Y instance, it should satisfy foldMap f = fold . fmap fwhich implies that $foldMap f . fmap g = foldMap (f . g)ß3Combine the elements of a structure using a monoid.àHMap each element of the structure to a monoid, and combine the results.á&Right-associative fold of a structure.In the case of lists, á³, when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left: @foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)ˆNote that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, á< can produce a terminating expression from an infinite list.For a general g5 structure this should be semantically identical to,  foldr f z =  f z . çâTRight-associative fold of a structure, but with strict application of the operator.ã%Left-associative fold of a structure.In the case of lists, ã³, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right: Efoldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xnyNote that to produce the outermost application of the operator the entire input list must be traversed. This means that ä) will diverge if given an infinite list.MAlso note that if you want an efficient left-fold, you probably want to use ä instead of ãO. The reason for this is that latter does not force the "inner" results (e.g. z f x1F in the above example) before applying them to the operator (e.g. to (f x2)"). This results in a thunk chain O(n)B elements long, which then must be evaluated from the outside-in.For a general g5 structure this should be semantically identical to,  foldl f z = { f z . çäRLeft-associative fold of a structure but with strict application of the operator.ÿThis ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g. é).For a general g5 structure this should be semantically identical to,  foldl f z = | f z . çå A variant of áN that has no base case, and thus may only be applied to non-empty structures. å f = „ f . çæ A variant of ãN that has no base case, and thus may only be applied to non-empty structures. æ f = } f . çç4List of elements of a structure, from left to right.è«Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.é4Returns the size/length of a finite structure as an x‰. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.ê(Does the element occur in the structure?ë-The largest element of a non-empty structure.ì+The least element of a non-empty structure.íThe í9 function computes the sum of the numbers of a structure.îThe î> function computes the product of the numbers of a structure.ïbMonadic fold over the elements of a structure, associating to the right, i.e. from right to left.ðaMonadic fold over the elements of a structure, associating to the left, i.e. from left to right.ñ¥Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see #á.òò is ñP with its arguments flipped. For a version that doesn't ignore the results see #â.for_ [1..4] print1234ó­Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see #ã.As of base 4.8.0.0, ó is just ñ, specialized to W.ôô is óP with its arguments flipped. For a version that doesn't ignore the results see #ä.As of base 4.8.0.0, ô is just ò, specialized to W.õ†Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see #å.öŽEvaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see #æ.As of base 4.8.0.0, ö is just õ, specialized to W.÷1The sum of a collection of actions, generalizing ù.ø1The sum of a collection of actions, generalizing ù. As of base 4.8.0.0, ø is just ÷, specialized to 0.ù>The concatenation of all the elements of a container of lists.úYMap a function over all the elements of a container and concatenate the resulting lists.ûûI returns the conjunction of a container of Bools. For the result to be Ê , the container must be finite; Å, however, results from a Å& value finitely far from the left end.üüI returns the disjunction of a container of Bools. For the result to be Å , the container must be finite; Ê, however, results from a Ê& value finitely far from the left end.ýHDetermines whether any element of the structure satisfies the predicate.þGDetermines whether all elements of the structure satisfy the predicate.ÿ\The largest element of a non-empty structure with respect to the given comparison function.ZThe least element of a non-empty structure with respect to the given comparison function. is the negation of ê.The { function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or È if there is no such element.      %gçáàèéãäæåíîëìêßâïðñòóôõö÷øùúûüýþÿ%gßàáâãäåæçèéêëìíîïðñòõ÷óôöøùúûüýþÿgßàáâãäåæçèéêëìíîê44I$Conor McBride and Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimentalportable Trustworthy,6FKV ]The  functor. !"#CThis instance would be equivalent to the derived instances of the  newtype if the runConst field were removed$CThis instance would be equivalent to the derived instances of the  newtype if the runConst field were removedç-(c) The University of Glasgow, CWI 2001--2011/BSD-style (see the file libraries/base/LICENSE) Trustworthy%&'+,-0;=DFQSTVdh ~>BQConstruct a representation for a type constructor applied at a monomorphic kind.INote that this is unsafe as it allows you to construct ill-kinded types.C2Construct a representation for a type application.GNote that this is known-key to the compiler, which uses it in desugar b evidence.Used to make `b instance for things of kind NatUsed to make `b# instance for things of kind SymbolFor compiler use.b The class b> allows a concrete representation of a type to be calculated.¿4A concrete representation of a (monomorphic) type. ¿( supports reasonably efficient equality.À"A non-indexed type representation.(A helper to satisfy the type checker in F.7OPattern match on a type constructor including its instantiated kind variables.8#Pattern match on a type constructor9#Pattern match on a type applicationCHelper to fully evaluate Ô for use as  NFData(rnf) implementationE Observe the ú of a type representationFUse a ¿ as b evidence.GAObserve the type constructor of a quantified type representation.H5Observe the type constructor of a type representationI  Type equalityJObserve the kind of a type.MTakes a value of type a5 and returns a concrete representation of that type.PHelper to fully evaluate ¿ for use as  NFData(rnf) implementationQ Helper to fully evaluate À for use as  NFData(rnf) implementationExquisitely unsafe.RExquisitely unsafe.@An internal function, to make representations for type literals.  package name module name the name of the type constructornumber of kind variableskind representation A unique Ô objectR package name module name the name of the type constructornumber of kind variableskind representation A unique ÔY object Used when the strings are dynamically allocated, eg from binary deserialisation package name module name tycon name7BCb¿ÀÁÔÕÖ     ×úÒ789:;<=>?@ABCDEFGHIJKLMNOPQRb¿ !ÀÁ"#$Ö!-(c) The University of Glasgow, CWI 2001--2017/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental2non-portable (requires GADTs and compiler support) Trustworthyd ‚v b¿ÀÁÔÕ¸¹º»789:;<=>?CDFGHIJKLMOPQ bKFº»¸¹¿L987:HPIJOÀÁMGQÔ=>?DÕ<;CJ-(c) The University of Glasgow, CWI 2001--2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthy &'+,FSTVd •ÕZ!A quantified type representation.[6Observe a type representation for the type of a value.\Takes a value of type a5 and returns a concrete representation of that type.]Show a type representation^The type-safe cast operation_*Extract a witness of equality of two types`8A flexible variation parameterised in a type constructora Cast over k1 -> k2b Cast over k1 -> k2 -> k3c,Applies a type to a function type. Returns: Just u6 if the first argument represents a function of type t -> u8 and the second argument represents a function of type t. Otherwise, returns Nothing.dBuild a function type.eˆSplits a type constructor application. Note that if the type constructor is polymorphic, this will not return the kinds that were used.f3Observe the argument types of a type representationgAObserve the type constructor of a quantified type representation.hTakes a value of type a5 and returns a concrete representation of that type.iForce a Z to normal form.+bÔ¸¹º»ïð=>?@DSTUVWXYZ[\]^_`abcdefghijklmnop+b[\º»¸¹^_`abïðZi]dcefghÔ=>?D@jklmnopYXWVUTSè((c) The University of Glasgow, 1998-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions) Trustworthy"#CDVd ÓÐ+The  SomeExceptionM type is the root of the exception type hierarchy. When an exception of type e6 is thrown, behind the scenes it is encapsulated in a  SomeException.qArithmetic exceptions.wx#This is thrown when the user calls ,. The String is the argument given to ,.zTAny type that you wish to throw or catch as an exception must be an instance of the  ExceptionJ class. The simplest case is a new exception type directly below the root: bdata MyException = ThisException | ThatException deriving Show instance Exception MyException&The default method definitions in the  ExceptionA class do what we need in this case. You can now throw and catch  ThisException and  ThatException as exceptions: n*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException)) Caught ThisException UIn more complicated examples, you may wish to define a whole hierarchy of exceptions: ÿë--------------------------------------------------------------------- -- Make the root exception type for all the exceptions in a compiler data SomeCompilerException = forall e . Exception e => SomeCompilerException e instance Show SomeCompilerException where show (SomeCompilerException e) = show e instance Exception SomeCompilerException compilerExceptionToException :: Exception e => e -> SomeException compilerExceptionToException = toException . SomeCompilerException compilerExceptionFromException :: Exception e => SomeException -> Maybe e compilerExceptionFromException x = do SomeCompilerException a <- fromException x cast a --------------------------------------------------------------------- -- Make a subhierarchy for exceptions in the frontend of the compiler data SomeFrontendException = forall e . Exception e => SomeFrontendException e instance Show SomeFrontendException where show (SomeFrontendException e) = show e instance Exception SomeFrontendException where toException = compilerExceptionToException fromException = compilerExceptionFromException frontendExceptionToException :: Exception e => e -> SomeException frontendExceptionToException = toException . SomeFrontendException frontendExceptionFromException :: Exception e => SomeException -> Maybe e frontendExceptionFromException x = do SomeFrontendException a <- fromException x cast a --------------------------------------------------------------------- -- Make an exception type for a particular frontend compiler exception data MismatchedParentheses = MismatchedParentheses deriving Show instance Exception MismatchedParentheses where toException = frontendExceptionToException fromException = frontendExceptionFromExceptionWe can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g.  IOException: #*Main> throw MismatchedParentheses catch€ e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses)) Caught MismatchedParentheses *Main> throw MismatchedParentheses catch€ e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException)) Caught MismatchedParentheses *Main> throw MismatchedParentheses catch€ e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException)) Caught MismatchedParentheses *Main> throw MismatchedParentheses catch[ e -> putStrLn ("Caught " ++ show (e :: IOException)) *** Exception: MismatchedParentheses }7Render this exception value in a human-friendly manner.Default implementation: ¤.€nThrow an exception. Exceptions may be thrown from purely functional code, but may only be caught within the † monad. Pretty print a .‚ Pretty print a ¾.%&'()*'¾Ó !"#$%&()+~+,-./0qrstuvwxyz{|}€1‚2+~qrstuvwxyz{|}xé'(c) The University of Glasgow 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeDQV Vú†PDescribes the behaviour of a thread when an asynchronous exception is received.‡7asynchronous exceptions are unmasked (the normal state)ˆthe state during “V: asynchronous exceptions are masked, but blocking operations may still be interrupted‰the state during •T: asynchronous exceptions are masked, and blocking operations may not be interruptedŠ,File and directory names are values of type /Ÿ, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.‹'Embed a strict state transformer in an † action. The ƒ: parameter indicates that the internal state used by the ­. computation is a special one supplied by the †= monad, and thus distinct from those used by invocations of ±.3 Convert an † action into an ­9 action. The type of the result is constrained to use a ƒ6 state, and therefore the result cannot be passed to ±.Œ Convert an † action to an ­ action. This relies on † and ­P having the same representation modulo the constraint on the type of the state. Convert an ­ action to an † action. This relies on † and ­P having the same representation modulo the constraint on the type of the state.6For an example demonstrating why this is unsafe, see Fhttps://mail.haskell.org/pipermail/haskell-cafe/2009-April/060719.html4Catch an exception in the † monad.Note that this function is strict in the action. That is, !catchException undefined b == _|_. See exceptions_and_strictness for details.ŽÿThis is the simplest of the exception-catching functions. It takes a single argument, runs it, and if an exception is raised the "handler" is executed, with the value of the exception passed as an argument. Otherwise, the result is returned as normal. For example: ¶ catch (readFile f) (\e -> do let err = show (e :: IOException) hPutStr stderr ("Warning: Couldn't open " ++ f ++ ": " ++ err) return "").Note that we have to give a type signature to e¥, or the program will not typecheck as the type is ambiguous. While it is possible to catch exceptions of any type, see the section "Catching all exceptions" (in Control.Exception3) for an explanation of the problems with doing so.%For catching exceptions in pure (non-†!) expressions, see the function –.Note that due to Haskell's unspecified evaluation order, an expression may throw one of several possible exceptions: consider the expression (error "urk") + (1 `div` 0). Does the expression throw ErrorCall "urk", or  DivideByZero?¤The answer is "it might throw either"; the choice is non-deterministic. If you are catching any type of exception then you might catch either. If you are calling catch with type .IO Int -> (ArithException -> IO Int) -> IO Int$ then the handler may get run with  DivideByZero as an argument, or an ErrorCall "urk"} exception may be propogated further up. If you call it again, you might get a the opposite behaviour. This is ok, because Ž is an † computation.5 Catch any z type in the † monad.Note that this function is strict in the action. That is, catchAny undefined b == _|_. See exceptions_and_strictness for details. A variant of €" that can only be used within the † monad. Although / has a type that is an instance of the type of €*, the two functions are subtly different: 9throw e `seq` x ===> throw e throwIO e `seq` x ===> x+The first example will cause the exception e8 to be raised, whereas the second one won't. In fact, G will only cause an exception to be raised when it is used within the † monad. The ) variant should be used in preference to €# to raise an exception within the †= monad because it guarantees ordering with respect to other † operations, whereas € does not. 7Allow asynchronous exceptions to be raised even inside “\, making the operation interruptible (see the discussion of "Interruptible operations" in êë).When called outside “ , or inside •, this function has no effect.‘ Returns the † for the current thread.’Like “, but does not pass a restore action to the argument.“9Executes an IO computation with asynchronous exceptions maskedX. That is, any thread which attempts to raise an exception in the current thread with LìC will be blocked until asynchronous exceptions are unmasked again.The argument passed to “É is a function that takes as its argument another function, which can be used to restore the prevailing masking state within the context of the masked computation. For example, a common way to use “. is to protect the acquisition of a resource: jmask $ \restore -> do x <- acquire restore (do_something_with x) `onException` release releaseThis code guarantees that acquire is paired with release, by masking asynchronous exceptions for the critical parts. (Rather than write this code yourself, it would be better to use Lí& which abstracts the general pattern).Note that the restore" action passed to the argument to “³ does not necessarily unmask asynchronous exceptions, it just restores the masking state to that of the enclosing context. Thus if asynchronous exceptions are already masked, “ÿB cannot be used to unmask exceptions again. This is so that if you call a library function with exceptions masked, you can be sure that the library call will not be able to unmask exceptions again. If you are writing library code and need to use asynchronous exceptions, the only way is to create a new thread; see kî.^Asynchronous exceptions may still be received while in the masked state if the masked thread blocks in certain ways; see Control.Exception#interruptible.Threads created by kï inherit the †5 from the parent; that is, to start a thread in the ˆ state, use mask_ $ forkIO ...É. This is particularly useful if you need to establish an exception handler in the forked thread before any asynchronous exceptions are received. To create a a new thread in an unmasked state use kî.”Like •, but does not pass a restore action to the argument.•Like “8, but the masked computation is not interruptible (see Control.Exception#interruptibleK). THIS SHOULD BE USED WITH GREAT CARE, because if a thread executing in •ÿU blocks for any reason, then the thread (and possibly the program, if this is the main thread) will be unresponsive and unkillable. This function should only be necessary if you need to mask exceptions around an interruptible operation, and you can guarantee that the interruptible operation will only block for a short period of time.–/Evaluate the argument to weak head normal form.–f is typically used to uncover any exceptions that a lazy value may contain, and possibly handle them.– only evaluates to weak head normal form'. If deeper evaluation is needed, the force function from Control.DeepSeq may be handy: evaluate $ force x%There is a subtle difference between – x and / K x', analogous to the difference between  and €. If the lazy value x throws an exception, / K x will fail to return an †- action and will throw an exception instead. – x), on the other hand, always produces an †3 action; that action will throw an exception upon  execution iff x throws an exception upon  evaluation.AThe practical implication of this difference is that due to the imprecise exceptions semantics, &(return $! error "foo") >> error "bar"may throw either "foo" or "bar"O, depending on the optimizations performed by the compiler. On the other hand, %evaluate (error "foo") >> error "bar"is guaranteed to throw "foo".The rule of thumb is to use –° to force or handle exceptions in lazy values. If, on the other hand, you are forcing a lazy value for efficiency reasons only and do not care about exceptions, you may use / K x.ŽThe computation to run+Handler to invoke if an exception is raised6-computation to run first ("acquire resource"),computation to run last ("release resource")computation to run in-between7computation to run first?computation to run afterward (even if an exception was raised)#8†‹9efgAB†‡ˆ‰Š:‹3Œ4Ž5;‘<’“”•67–†‡ˆ‰ð"(c) The University of Glasgow 2008see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeD [ƒ—A mutable variable in the † monad˜ Build a new —™Read the value of an —šWrite a new value into an —=—>˜™š?—>ñ((c) The University of Glasgow, 1992-2003see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)Unsafe0D Ð&@+A box around Weak#, private to this module.œÅA finalizer is represented as a pointer to a foreign function that, at finalisation time, gets as an argument a plain pointer variant of the foreign pointer that the finalizer is associated with.Note that the foreign function must use the ccall calling convention. The type Ð represents references to objects that are maintained in a foreign language, i.e., that are not part of the data structures usually managed by the Haskell storage manager. The essential difference between )s and vanilla memory references of type Ptr a, is that the former may be associated with  finalizers½. A finalizer is a routine that is invoked when the Haskell storage manager detects that - within the Haskell heap and stack - there are no more references left that are pointing to the †. Typically, the finalizer will, then, invoke routines in the foreign language that free the resources bound by the foreign object.The % is parameterised in the same way as Œ. The type argument of * should normally be an instance of class .AúTurns a plain memory reference into a foreign object by associating a finalizer - given by the monadic operation - with the reference. The storage manager will start the finalizer, in a separate thread, some time after the last reference to the  ForeignPtr… is dropped. There is no guarantee of promptness, and in fact there is no guarantee that the finalizer will eventually run at all.•Note that references from a finalizer do not necessarily prevent another object from being finalized. If A's finalizer refers to B (perhaps using £¦, then the only guarantee is that B's finalizer will never be started before A's. If both A and B are unreachable, then both finalizers will start together. See £ for more on finalizer ordering.ž"Allocate some memory and return a = to it. The memory will be released automatically when the  is discarded.ž is equivalent to 4 do { p <- malloc; newForeignPtr finalizerFree p }galthough it may be implemented differently internally: you may not assume that the memory returned by ž has been allocated with _ò. GHC notes: žo has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, so the ; does not require a finalizer to free the memory. Use of žD and associated functions is strongly recommended in preference to  newForeignPtr with a finalizer.ŸThis function is similar to žX, except that the size of the memory required is given explicitly as a number of bytes.BThis function is similar to Ÿf, except that the size and alignment of the memory required is given explicitly as numbers of bytes.C"Allocate some memory and return a = to it. The memory will be released automatically when the  is discarded. GHC notes: Cÿ$ has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, as for mallocForeignPtr. Unlike mallocForeignPtr, a ForeignPtr created with mallocPlainForeignPtr carries no finalizers. It is not possible to add a finalizer to a ForeignPtr created with mallocPlainForeignPtr. This is useful for ForeignPtrs that will live only inside Haskell (such as those created for packed strings). Attempts to add a finalizer to a ForeignPtr created this way, or to finalize such a pointer, will throw an exception.DThis function is similar to Ÿ£, except that the internally an optimised ForeignPtr representation with no finalizer is used. Attempts to add a finalizer will cause an exception to be thrown.EThis function is similar to B£, except that the internally an optimised ForeignPtr representation with no finalizer is used. Attempts to add a finalizer will cause an exception to be thrown. UThis function adds a finalizer to the given foreign object. The finalizer will run beforeN all other finalizers for the same object which have already been registered.¡Like ¡¹ but allows the finalizer to be passed an additional environment parameter to be passed to the finalizer. The environment passed to the finalizer is fixed by the second argument to ¡F,This function adds a finalizer to the given  ForeignPtr. The finalizer will run beforeN all other finalizers for the same object which have already been registered.This is a variant of addForeignPtrFinalizer', where the finalizer is an arbitrary IOF action. When it is invoked, the finalizer will run in a new thread.¾NB. Be very careful with these finalizers. One common trap is that if a finalizer references another finalized value, it does not prevent that value from being finalized. In particular, Handle?s are finalized objects, so a finalizer should not refer to a Handle (including stdout, stdin or stderr).¢gTurns a plain memory reference into a foreign pointer that may be associated with finalizers by using  .£…This function ensures that the foreign object in question is alive at the given place in the sequence of IO actions. In particular Pó does a £$ after it executes the user action.ZNote that this function should not be used to express dependencies between finalizers on )s. For example, if the finalizer for a  F1 calls £ on a second  F25, then the only guarantee is that the finalizer for F2+ is never started before the finalizer for F17. They might be started together if for example both F1 and F2d are otherwise unreachable, and in that case the scheduler might end up running the finalizer for F2 first.¼In general, it is not recommended to use finalizers on separate objects with ordering constraints between them. To express the ordering robustly requires explicit synchronisation using MVarÿs between the finalizers, but even then the runtime sometimes runs multiple finalizers sequentially in a single thread (for performance reasons), so synchronisation between finalizers could result in artificial deadlock. Another alternative is to use explicit reference counting.¤ˆThis function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to ¤© is the last usage occurrence of the given foreign pointer, then its finalizer(s) will be run, which potentially invalidates the plain pointer just obtained. Hence, £p must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence.TTo avoid subtle coding errors, hand written marshalling code should preferably use Pó rather than combinations of ¤ and £_. However, the latter routines are occasionally preferred in tool generated marshalling code.¥This function casts a . parameterised by one type into another type.¦ 8Advances the given address by the given offset in bytes.The new Á shares the finalizer of the original, equivalent from a finalization standpoint to just creating another reference to the original. That is, the finalizer will not be called before the new Ë is unreachable, nor will it be called an additional time due to this call, and the finalizer will be called with the same address that it would have had this call not happened, *not* the new address.§OCauses the finalizers associated with a foreign pointer to be run immediately.GHI›œJKLMNAžŸBCDE ¡F¢£¤¥¦§@OJKLMPQRSNô"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableUnsafe ís¨ÿ*Turns a plain memory reference into a foreign pointer, and associates a finalizer with the reference. The finalizer will be executed after the last reference to the foreign object is dropped. There is no guarantee of promptness, however the finalizer will be executed before the program exits.©—This is a way to look at the pointer living inside a foreign object. This function takes a function which is applied to that pointer. The resulting †ÿ action is then executed. The foreign object is kept alive at least during the whole action, even if it is not used directly inside. Note that it is not safe to return the pointer from the action and use it after the action completes. All uses of the pointer should be inside the ©? bracket. The reason for this unsafeness is the same as for ¤h below: the finalizer may run earlier than expected, because the compiler can only track usage of the  object, not a Œ object made from it.^This function is normally used for marshalling data to or from the object pointed to by the !, using the operations from the  class.ªThis variant of ¨° adds a finalizer that expects an environment in addition to the finalized pointer. The environment that will be passed to the finalizer is fixed by the second argument to ª.«This function is similar to aõc, but yields a memory area that has a finalizer attached that releases the memory area. As with žB, it is not guaranteed that the block of memory was allocated by _ò.¬This function is similar to aöc, but yields a memory area that has a finalizer attached that releases the memory area. As with žB, it is not guaranteed that the block of memory was allocated by _ò.›œžŸ ¡¢£¤¥¦§¨©ª«¬O"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableUnsafe ïΤ¤N"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy ñû›œžŸ ¡¢£¥§¨©ª«¬œ›¨¢ ª¡©§£¥žŸ«¬P"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy ô ›œžŸ ¡¢£¥¦§¨©ª«¬œ›¨¢ ª¡©§£¥¦žŸ«¬Q"(c) The University of Glasgow 2008see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy ž±AA mutable array of bytes that can be passed to foreign functions.ÿŠThe buffer is represented by a record, where the record contains the raw buffer and the start/end points of the filled portion. The buffer contents itself is mutable, but the rest of the record is immutable. This is a slightly odd mix, but it turns out to be quite practical: by making all the buffer metadata immutable, we can have operations on buffer metadata outside of the IO monad.8The "live" elements of the buffer are those between the ¶ and · offsets. In an empty buffer, ¶ is equal to ·s, but they might not be zero: for example, the buffer might correspond to a memory-mapped file and in which case ¶e will point to the next location to be written, which is not necessarily the beginning of the file.Ò2slides the contents of the buffer to the beginning(­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔ(±²³´µ¶·­®¯°¹ÏÐÑÎËÍÒÌÅÆÇÈÉÊÓÃÄÔº»¼¸½¾¿ÀÁ­®¯±²³´µ¶·R((c) The University of Glasgow, 2008-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyCV ;0 Ö׃Stopped because the input contains insufficient available elements, or all of the input sequence has been successfully translated.Ø>Stopped because the output contains insufficient free elementsÙ°Stopped because there are sufficient free elements in the output to output at least one encoded ASCII character, but the input contains an invalid or unrepresentable sequenceÚA Úk is a specification of a conversion scheme between sequences of bytes and sequences of Unicode characters.XFor example, UTF-8 is an encoding of Unicode characters into a sequence of bytes. The Ú for UTF-8 is utf8.Üa string that can be passed to mkTextEncoding to create an equivalent Ú.Ý‘Creates a means of decoding bytes into characters: the result must not be shared between several byte sequences or simultaneously across threadsÞ”Creates a means of encode characters into bytes: the result must not be shared between several character sequences or simultaneously across threadsæThe encode, function translates elements of the buffer from to the buffer to . It should translate as many elements as possible given the sizes of the buffers, including translating zero elements if there is either not enough room in to, or from1 does not contain a complete multibyte sequence.öIf multiple CodingProgress returns are possible, OutputUnderflow must be preferred to InvalidSequence. This allows GHC's IO library to assume that if we observe InvalidSequence there is at least a single element available in the output buffer.ÈThe fact that as many elements as possible are translated is used by the IO library in order to report translation errors at the point they actually occur, rather than when the buffer is translated.çThe recover‡ function is used to continue decoding in the presence of invalid or unrepresentable sequences. This includes both those detected by encode returning InvalidSequenceO and those that occur because the input byte sequence appears to be truncated.CProgress will usually be made by skipping the first element of the fromo buffer. This function should only be called if you are certain that you wish to do this skipping and if the tož buffer has at least one element of free space. Because this function deals with decoding failure, it assumes that the from buffer has at least one element.recover6 may raise an exception rather than skipping anything.#Currently, some implementations of recover` may mutate the input buffer. In particular, this feature is used to implement transliteration.èAResources associated with the encoding may now be released. The encode1 function may not be called again after calling close.é&Return the current state of the codec.ÿ Many codecs are not stateful, and in these case the state can be represented as '()'. Other codecs maintain a state. For example, UTF-16 recognises a BOM (byte-order-mark) character at the beginning of the input, and remembers thereafter whether to use big-endian or little-endian mode. In this case, the state of the codec would include two pieces of information: whether we are at the beginning of the stream (the BOM only occurs at the beginning), and if not, whether to use the big or little-endian encoding.ëÖ×ØÙÚÛÜÝÞßàáâãäåèæçéêäåæçèéêÚÛÜÝÞßàãáâÖ×ØÙÖ×ØÙÚÛÜÝÞäåæçèéêM"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable TrustworthyD U3îMake a f pointer to an —8, using the second argument as a finalizer to run when — is garbage-collectedïMutate the contents of an —.Be warned that ïI does not apply the function strictly. This means if the program calls ïè many times, but seldomly uses the value, thunks will pile up in memory resulting in a space leak. This is a common mistake made when using an IORef as a counter. For example, the following will likely produce a stack overflow: Tref <- newIORef 0 replicateM_ 1000000 $ modifyIORef ref (+1) readIORef ref >>= printTo avoid this problem, use ð instead.ðStrict version of ïñ'Atomically modifies the contents of an —."This function is useful for using —B in a safe way in a multithreaded program. If you only have one — , then using ñ7 to access and modify it will prevent race conditions.$Extending the atomicity to multiple —es is problematic, so it is recommended that if you need to do anything more complicated then using 8÷ instead is a good idea.ñš does not apply the function strictly. This is important to know even if all you are doing is replacing the value. For example, this will leak memory: Eref <- newIORef '1' forever $ atomicModifyIORef ref (\_ -> ('2', ()))Use ò or ó to avoid this problem.òStrict version of ñ-. This forces both the value stored in the — as well as the value returned.ó Variant of š1 with the "barrier to reordering" property that ñ has. —˜™šîïðñòó —˜™šïðñòóîø Trustworthy"# Z‹TinsertWith f k v table inserts k into table with value v. If k already appears in table with value v0, the value is updated to f v0 v and Just v0 is returned.U.Used to undo the effect of a prior insertWith.VDRemove the given key from the table and return its associated value.WXYTUVZ[\]^_`abcdWeù Trustworthy aËfpCopy part of the source array into the destination array. The destination array is resized if not large enough.gpCopy part of the source array into the destination array. The destination array is resized if not large enough.hBComputes the next-highest power of two for a particular integer, n. If n$ is already a power of two, returns n. If n@ is zero, returns zero, even though zero is not a power of two.ijklmnopqrstuvwxyfz{|i}ú"(c) The University of Glasgow 2008see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)UnsafeG il~An ~. is a mutable, boxed, non-strict array in the †+ monad. The type arguments are as follows:i8: the index type of the array (should be an instance of a)e : the element type of the array. Build a new ~€Read a value from an ~Write a new value into an ~‚Read a value from an ~ƒWrite a new value into an ~„~…€‚ƒ†~…T((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portable Trustworthy ž÷%A mode that determines the effect of hSeek  hdl mode i.øthe position of hdl is set to i.ùthe position of hdl is set to offset i from the current position.úthe position of hdl is set to offset i from the end of the file.û-Type of a device that can be used to back a Vû (see also Vü/). The standard libraries provide creation of Vû9s via Posix file operations with file descriptors (see Wý ) with FD being the underlying  instance.&Users may provide custom instances of 4 which are expected to conform the following rules:ü¾The standard libraries do not have direct support for this device type, but a user implementation is expected to provide a list of file names in the directory, in any order, separated by '\0' characters, excluding the "." and ".." names. See also þÿX. Seek operations are not supported on directories (other than to the zero position).ýBA duplex communications channel (results in creation of a duplex Vû?). The standard libraries use this device type when creating Vûs for open sockets.þ>A file that may be read or written, and also may be seekable.ÿA "raw" (disk) device which supports block binary read and write operations and may be seekable only to positions of certain granularity (block- aligned).+I/O operations required for implementing a Handle.ready dev write msecs returns Ê% if the device has data to read (if write is Å") or space to write new data (if write is Ê). msecs. specifies how long to wait, in milliseconds.Pcloses the device. Further operations on the device should produce exceptions.returns Ê( if the device is a terminal or console.returns Ê if the device supports  operations.+seek to the specified position in the data.(return the current position in the data.return the size of the data.change the size of the data. Kfor terminal devices, changes whether characters are echoed on the device. #returns the current echoing status. ¬some devices (e.g. terminals) support a "raw" mode where characters entered are immediately made available to the program. If available, this operations enables raw mode.  returns the û corresponding to this device. }duplicates the device, if possible. The new device is expected to share a file pointer with the original device (like Unix dup).dup2 source target¬ replaces the target device with the source device. The target device is closed first, if necessary, and then it is made into a duplicate of the first device (like Unix dup2).;A low-level I/O provider where the data is bytes in memory.ÿbRead up to the specified number of bytes, returning the number of bytes actually read. This function should only block if there is no data available. If there is not enough data available, then the function should just return the available data. A return value of zero indicates that the end of the data stream (e.g. end of file) has been reached.[Read up to the specified number of bytes, returning the number of bytes actually read, or È, if the end of the stream has been reached.$Write the specified number of bytes.iWrite up to the specified number of bytes without blocking. Returns the actual number of bytes written.÷øùúûüýþÿ          ûüýþÿ÷øùú÷øùúûüýþÿ     U"(c) The University of Glasgow 2008see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy ·zThe purpose of { is to provide a common interface for I/O devices that can read and write data through a buffer. Devices that implement f include ordinary files, memory-mapped files, and bytestrings. The underlying device implementing a Handle must provide .¢allocate a new buffer. The size of the buffer is at the discretion of the device; e.g. for a memory-mapped file the buffer will probably cover the entire file.œreads bytes into the buffer, blocking if there are no bytes available. Returns the number of bytes read (zero indicates end-of-file), and the new buffer.†reads bytes into the buffer without blocking. Returns the number of bytes read (Nothing indicates end-of-file), and the new buffer.ÿPrepares an empty write buffer. This lets the device decide how to set up a write buffer: the buffer may need to point to a specific location in memory, for example. This is typically used by the client when switching from reading to writing on a buffered read/write device.jThere is no corresponding operation for read buffers, because before reading the client will always call . Flush all the data from the supplied write buffer out to the device. The returned buffer should be empty, and ready for writing.!ŽFlush data from the supplied write buffer out to the device without blocking. Returns the number of bytes written and the remaining buffer.  !"#$%  !"#$% !((c) The University of Glasgow, 1994-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyCV &±Specifies the translation, if any, of newline characters between internal Strings and the external file or stream. Haskell Strings are assumed to represent newlines with the '\n'9 character; the newline mode specifies how to translate '\n'( on output, and what to translate into '\n' on input.('the representation of newlines on input)(the representation of newlines on output*?The representation of a newline in the external file or stream.+'\n','\r\n'-ªThree kinds of buffering are supported: line-buffering, block-buffering or no-buffering. These modes have the following effects. For output, items are written out, or flushed9, from the internal buffer according to the buffer mode:line-bufferingd: the entire output buffer is flushed whenever a newline is output, the buffer overflows, a $ is issued, or the handle is closed.block-buffering@: the entire buffer is written out whenever it overflows, a $ is issued, or the handle is closed. no-bufferingD: output is written immediately, and never stored in the buffer.°An implementation is free to flush the buffer more frequently, but not less frequently, than specified above. The output buffer is emptied as soon as it has been written out.DSimilarly, input occurs according to the buffer mode for the handle:line-bufferingÿ?: when the buffer for the handle is not empty, the next item is obtained from the buffer; otherwise, when the buffer is empty, characters up to and including the next newline character are read into the buffer. No characters are available until the newline character is available or the buffer is full.block-bufferingc: when the buffer for the handle becomes empty, the next block of data is read into the buffer. no-buffering4: the next input item is read and returned. The Y operation implies that even a no-buffered handle may require a one-character buffer.ÿThe default buffering mode when a handle is opened is implementation-dependent and may depend on the file system object which is attached to that handle. For most implementations, physical files will normally be block-buffered and terminals will normally be line-buffered.."buffering is disabled if possible./-line-buffering should be enabled if possible.0Jblock-buffering should be enabled if possible. The size of the buffer is n items if the argument is É n+ and is otherwise implementation-dependent.1jHaskell defines operations to read and write characters from and to files, represented by values of type Handle!. Each value of this type is a handle2: a record used by the Haskell run-time system to manageP I/O with file system objects. A handle has at least the following properties:+whether it manages input or output or both;whether it is open, closed or  semi-closed;whether the object is seekable;Cwhether buffering is disabled, or enabled on a line or block basis;$a buffer (whose length may be zero).Most handles will also have a current I/O position indicating where the next input or output operation will occur. A handle is readableE if it manages only input or both input and output; likewise, it is writableC if it manages only output or both input and output. A handle is openÈ when first allocated. Once it is closed it can no longer be used for either input or output, though an implementation cannot re-use its storage while references remain to it. Handles are in the ` and S¶ classes. The string produced by showing a handle is system dependent; it should include enough information to identify the handle for debugging. A handle is equal according to (e only to itself; no attempt is made to compare the internal state of different handles for equality.2<The native newline representation for the current platform: + on Unix systems, , on Windows.3Map '\r\n' into '\n' on input, and '\n'ª to the native newline represetnation on output. This mode can be used on any platform, and works with text files using any newline convention. The downside is that readFile >>= writeFile might yield a different file. wuniversalNewlineMode = NewlineMode { inputNL = CRLF, outputNL = nativeNewline }4>Use the native newline representation on both input and output ynativeNewlineMode = NewlineMode { inputNL = nativeNewline outputNL = nativeNewline }5!Do no newline translation at all. DnoNewlineTranslation = NewlineMode { inputNL = LF, outputNL = LF }‡ˆ‰7äåèæçéê&'()*+,-./0Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢1£¤¥¦§¨2345©&'()*+,-./0Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢1£¤#(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable Trustworthy6CDV 7›1ƒ,The Haskell 2010 type for exceptions in the †( monad. Any I/O operation may raise an ƒz instead of returning a result. For a more general type of exception, including also those that arise in pure code, see Lë.(In Haskell 2010, this is an opaque type.„Exceptions that occur in the IO monad. An  IOExceptionz records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.… Construct an ƒ0 value with a string describing the error. The + method of the † instance of the W class raises a …, thus: >instance Monad IO where ... fail s = ioError (userError s)8;An abstract type that contains a value for each variant of ƒ.91Defines the exit codes that a program can return.:!indicates successful termination;;Çindicates program failure with an exit code. The exact interpretation of the code is operating-system dependent. In particular, some values may be prohibited (e.g. 0 on a POSIX-compliant system).<(Exceptions generated by array operations=CAn attempt was made to index an array outside its declared bounds.>VAn attempt was made to evaluate an element of an array that had not been initialized.?Asynchronous exceptions.@ÎThe current thread's stack exceeded its limit. Since an exception has been raised, the thread's stack will certainly be below its limit again, but the programmer should take remedial action immediately.AThe program's heap is reaching its limit, and the program should take action to reduce the amount of live data it has. Notes:{It is undefined which thread receives this exception. GHC currently throws this to the same thread that receives C), but this may change in the future.ÿThe GHC RTS currently can only recover from heap overflow if it detects that an explicit memory limit (set via RTS flags). has been exceeded. Currently, failure to allocate memory from the operating system results in immediate termination of the program.B4This exception is raised by another thread calling kI, or by the system if it needs to terminate the thread for some reason.C³This exception is raised by default in the main thread of the program when the user requests to terminate the program via the usual mechanism(s) (e.g. Control-C in the console).D'Superclass for asynchronous exceptions.F was applied to Å.H †Compaction found an object that cannot be compacted. Functions cannot be compacted, nor can mutable objects or pinned objects. See .J5This thread has exceeded its allocation limit. See l and l.LBThere are no runnable threads, so the program is deadlocked. The Deadlock- exception is raised in the main thread only.N]The thread is waiting to retry an STM transaction, but there are no other references to any TVar&s involved, so it can't ever continue.PThe thread is blocked on an MVar,, but there are no other references to the MVar so it can't ever continue.RST Raise an ƒ in the † monad.ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿À Á Fƒ„ÃÄÅÆÇÈÉÊ…8ËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝ9:;<=>?@ABCDEFGHIJKLMNOPQÞßàáâãRSäåæTç „ÃÄÅÆÇÈÉ8ÌÍÎÏËÐÑÒÓÔÕÖ×ØÙÚÛÜÝ9:;<=>?@ABCDEFGHIJKLMNOPQY((c) The University of Glasgow, 2008-2011see libraries/base/LICENSElibraries@haskell.orginternal non-portable Trustworthy K.UThe U is used to construct  TextEncoding4s, and specifies how they handle illegal sequences.V6Throw an error when an illegal sequence is encounteredWDAttempt to ignore and recover if an illegal sequence is encounteredX?Replace with the closest visual match upon an illegal sequenceY_Use the private-use escape mechanism to attempt to allow illegal sequences to be roundtripped.èJIn transliterate mode, we use this character when decoding unknown bytes.4This is the defined Unicode replacement character: <http://www.fileformat.info/info/unicode/char/0fffd/index.htm[¦Some characters are actually "surrogate" codepoints defined for use in UTF-16. We need to signal an invalid character if we detect them when encoding a sequence of us into ˆ)s because they won't give valid Unicode._We may also need to signal an invalid character if we detect them when encoding a sequence of us into ˆs because the YN mode creates these to round-trip bytes through our internal UTF-16 encoding. UVWXYZ[\] UVWXYZ[\]UVWXYZ#(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyDZ Np`é byte to check lower bound upper bound_`ab_`ab[#(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyDZ Qdhj cdefghijklmn cdfeghkmijln\#(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyDZ Sìptv opqrstuvwxyz oprqstwyuvxz]#(c) The University of Glasgow, 2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyZ Vé|~ € {|}~€‚ƒ„… {|}~€‚ƒ„…^(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy au† Execute an † action, throwing a … if the predicate yields Ê, when applied to the result returned by the †J action. If no exception is raised, return the result of the computation.‡Like †, but discarding the resultˆ%Guards against negative result values‰Like ˆ, but discarding the resultŠGuards against null pointers‹Discard the return value of an † action†%error condition on the result of the † action9computes an error message from erroneous results of the † actionthe † action to be executed†‡ˆ‰Š‹†‡ˆ‰Š‹_(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable TrustworthyD ŒJ Œ.A pointer to a foreign function equivalent to –(, which may be used as a finalizer (cf P ) for storage allocated with , , ” or •.FAllocate a block of memory that is sufficient to hold values of type a7. The size of the area allocated is determined by the  method from the instance of  for the appropriate type.$The memory may be deallocated using – or Œ when no longer required.ŽLike / but memory is filled with bytes of value zero.¾Allocate a block of memory of the given number of bytes. The block of memory is sufficiently aligned for any of the basic foreign types that fits into a memory block of the allocated size.$The memory may be deallocated using – or Œ when no longer required.Llike / but memory is filled with bytes of value zero.‘‘ f executes the computation fo, passing as argument a pointer to a temporarily allocated block of memory sufficient to hold values of type a.The memory is freed when fM terminates (either normally or via an exception), so the pointer passed to f must not be used after this.’’ n f executes the computation fO, passing as argument a pointer to a temporarily allocated block of memory of n bytes. The block of memory is sufficiently aligned for any of the basic foreign types that fits into a memory block of the allocated size.The memory is freed when fM terminates (either normally or via an exception), so the pointer passed to f must not be used after this.”-Resize a memory area that was allocated with  or - to the size needed to store values of type b~. The returned pointer may refer to an entirely different memory area, but will be suitably aligned to hold values of type b¢. The contents of the referenced memory area will be the same as of the original pointer up to the minimum of the original size and the size of values of type b.If the argument to ” is è, ” behaves like .•-Resize a memory area that was allocated with  or ÿf to the given size. The returned pointer may refer to an entirely different memory area, but will be sufficiently aligned for any of the basic foreign types that fits into a memory block of the given size. The contents of the referenced memory area will be the same as of the original pointer up to the minimum of the original size and the given size.If the pointer argument to • is è, • behaves like . If the requested size is 0, • behaves like –.–/Free a block of memory that was allocated with , , ”, •, `  or any of the newX functions in Foreign.Marshal.Array or Foreign.C.String. ŒŽ‘’“”•– ‘’“Ž”•–Œ`(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy ¥‘ ê*Basic C routines needed for memory copying—LAllocate a block of memory and marshal a value into it (the combination of  and  8). The size of the area allocated is determined by the C  method from the instance of  for the appropriate type.$The memory may be deallocated using _  or _  when no longer required.˜˜ val f executes the computation fX, passing as argument a pointer to a temporarily allocated block of memory into which val) has been marshalled (the combination of ‘ and  ).The memory is freed when fM terminates (either normally or via an exception), so the pointer passed to f must not be used after this.™Convert a Haskell t to its numeric representationš>Convert a Boolean in numeric representation to a Haskell value›=Allocate storage and marshal a storable value wrapped into a the è is used to represent Èœ Converts a withXXX9 combinator into one marshalling a value wrapped into a , using è to represent È./Convert a peek combinator into a one returning È if applied to a è ž Replicates a withXXXJ combinator over a list of objects, yielding a list of marshalled objectsŸsCopies the given number of bytes from the second area (source) into the first (destination); the copied areas may not overlap oCopies the given number of bytes from the second area (source) into the first (destination); the copied areas may overlap¡>Fill a given number of bytes in memory area with a byte value. —˜™š›œžŸ ¡ ˜—™š›œžŸ ¡a(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable TrustworthyD ÆK¢LAllocate storage for the given number of elements of a storable type (like _ò, but for multiple elements).£Like ¢C, but add an extra position to hold a special termination element.¤Like ¢:, but allocated memory is filled with bytes of value zero.¥Like ¥;, but allocated memory is filled with bytes of value zero.¦CTemporarily allocate space for the given number of elements (like _, but for multiple elements).§Like ¦C, but add an extra position to hold a special termination element.¨Adjust the size of an array©KAdjust the size of an array including an extra position for the end marker.ª~Convert an array of given length into a Haskell list. The implementation is tail-recursive and so uses constant stack space.«GConvert an array terminated by the given end marker into a Haskell list¬/Write the list elements consecutive into memory­aWrite the list elements consecutive into memory and terminate them with the given marker element®jWrite a list of storable elements into a newly allocated, consecutive sequence of storable values (like ` , but for multiple elements).¯’Write a list of storable elements into a newly allocated, consecutive sequence of storable values, where the end is fixed by the given end marker°=Temporarily store a list of storable values in memory (like `, but for multiple elements).±Like °F, but the action gets the number of values as an additional parameter²Like °1, but a terminator indicates where the array ends³Like ±1, but a terminator indicates where the array ends´{Copy the given number of elements from the second array (source) into the first array (destination); the copied areas may not overlapµwCopy the given number of elements from the second array (source) into the first array (destination); the copied areas may overlap¶CReturn the number of elements in an array, excluding the terminator·?Advance a pointer into an array by the given number of elements¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¢£¦§¨©¤¥ª«¬­®¯°²±³´µ¶·b((c) The University of Glasgow, 2008-2011see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyV çU¸8Marshal a NUL terminated C string into a Haskell string.¹>Marshal a C string with explicit length into a Haskell string.º8Marshal a Haskell string into a NUL terminated C string.the Haskell string may not contain any NUL charactersPnew storage is allocated for the C string and must be explicitly freed using – or Œ.»aMarshal a Haskell string into a C string (ie, character array) with explicit length information.Pnew storage is allocated for the C string and must be explicitly freed using – or Œ.¼QMarshal a Haskell string into a NUL terminated C string using temporary storage.the Haskell string may not contain any NUL characters‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.½wMarshal a Haskell string into a C string (ie, character array) in temporary storage, with explicit length information.‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.¾eMarshal a list of Haskell strings into an array of NUL terminated C strings using temporary storage.the Haskell strings may not contain any NUL characters‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.¿>Determines whether a character can be accurately encoded in a ë.¬Pretty much anyone who uses this function is in a state of sin because whether or not a character is encodable will, in general, depend on the context in which it occurs.ìEncoding of CStringString in Haskell termsíEncoding of CString to createNull-terminate?String to encode/Worker that can safely use the allocated memoryîEncoding of CString to createNull-terminate?String to encode¸¹º»¼½¾¿¸¹º»¼½¾¿c(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy0!À<A wide character string with explicit length information in kWs instead of a terminating NUL (allowing NUL characters in the middle of the string).ÁSA C wide string is a reference to an array of C wide characters terminated by NUL.‡A string with explicit length information in bytes instead of a terminating NUL (allowing NUL characters in the middle of the string).ÃHA C string is a reference to an array of C characters terminated by NUL.Ä8Marshal a NUL terminated C string into a Haskell string.Å>Marshal a C string with explicit length into a Haskell string.Æ8Marshal a Haskell string into a NUL terminated C string.the Haskell string may not contain any NUL charactersPnew storage is allocated for the C string and must be explicitly freed using _  or _ .ÇaMarshal a Haskell string into a C string (ie, character array) with explicit length information.Pnew storage is allocated for the C string and must be explicitly freed using _  or _ .ÈQMarshal a Haskell string into a NUL terminated C string using temporary storage.the Haskell string may not contain any NUL characters‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.ÉwMarshal a Haskell string into a C string (ie, character array) in temporary storage, with explicit length information.‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.Ë\Convert a C byte, representing a Latin-1 character, to the corresponding Haskell character.ÌfConvert a Haskell character to a C character. This function is only safe on the first 256 characters.Í Convert a C  unsigned charL, representing a Latin-1 character, to the corresponding Haskell character.Î#Convert a Haskell character to a C  unsigned char:. This function is only safe on the first 256 characters.Ï Convert a C  signed charL, representing a Latin-1 character, to the corresponding Haskell character.Ð#Convert a Haskell character to a C  signed char:. This function is only safe on the first 256 characters.Ñ8Marshal a NUL terminated C string into a Haskell string.Ò>Marshal a C string with explicit length into a Haskell string.Ó8Marshal a Haskell string into a NUL terminated C string.the Haskell string may not contain any NUL charactersPnew storage is allocated for the C string and must be explicitly freed using _  or _ .ÔaMarshal a Haskell string into a C string (ie, character array) with explicit length information.Pnew storage is allocated for the C string and must be explicitly freed using _  or _ .ÕQMarshal a Haskell string into a NUL terminated C string using temporary storage.the Haskell string may not contain any NUL characters‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.ÖwMarshal a Haskell string into a C string (ie, character array) in temporary storage, with explicit length information.‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.×=Marshal a NUL terminated C wide string into a Haskell string.ØCMarshal a C wide string with explicit length into a Haskell string.Ù=Marshal a Haskell string into a NUL terminated C wide string.the Haskell string may not contain any NUL charactersUnew storage is allocated for the C wide string and must be explicitly freed using _  or _ .ÚkMarshal a Haskell string into a C wide string (ie, wide character array) with explicit length information.Unew storage is allocated for the C wide string and must be explicitly freed using _  or _ .ÛVMarshal a Haskell string into a NUL terminated C wide string using temporary storage.the Haskell string may not contain any NUL characters‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.܃Marshal a Haskell string into a C wide string (i.e. wide character array) in temporary storage, with explicit length information.‘the memory is freed when the subcomputation terminates (either normally or via an exception), so the pointer to the temporary storage must not be used after this.ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÃÂÄÅÆÇÈÉÊÌËÎÍÐÏÑÒÓÔÕÖÁÀ×ØÙÚÛÜd(c) The FFI task force 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableUnsafe?Ý|Sometimes an external entity is a pure function, except that it passes arguments and/or results via pointers. The function unsafeLocalState< permits the packaging of such entities as pure functions. :The only IO operations allowed in the IO action passed to unsafeLocalState are (a) local allocation (alloca,  allocaBytes and derived operations such as  withArray and  withCString), and (b) pointer operations (Foreign.Storable and  Foreign.Ptrè) on the pointers to local storage, and (c) foreign functions whose only observable effect is to read and/or write the locally allocated memory. Passing an IO operation that does not obey these rules results in undefined behaviour.TIt is expected that this operation will be replaced in a future revision of Haskell.ÝÝe"(c) The University of Glasgow 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisional#non-portable (requires concurrency) TrustworthyX+ÞúTurns a plain memory reference into a foreign object by associating a finalizer - given by the monadic operation - with the reference. The storage manager will start the finalizer, in a separate thread, some time after the last reference to the  ForeignPtr… is dropped. There is no guarantee of promptness, and in fact there is no guarantee that the finalizer will eventually run at all.•Note that references from a finalizer do not necessarily prevent another object from being finalized. If A's finalizer refers to B (perhaps using touchForeignPtr¦, then the only guarantee is that B's finalizer will never be started before A's. If both A and B are unreachable, then both finalizers will start together. See touchForeignPtr for more on finalizer ordering.ß,This function adds a finalizer to the given  ForeignPtr. The finalizer will run beforeN all other finalizers for the same object which have already been registered.This is a variant of )Foreign.ForeignPtr.addForeignPtrFinalizer', where the finalizer is an arbitrary IOF action. When it is invoked, the finalizer will run in a new thread.¾NB. Be very careful with these finalizers. One common trap is that if a finalizer references another finalized value, it does not prevent that value from being finalized. In particular, Handle?s are finalized objects, so a finalizer should not refer to a Handle (including stdout, stdin or stderr).ÞßÞßf(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportable Trustworthy…zàHaskell representation for errnof values. The implementation is deliberately exposed, to allow users to add their own definitions of à values. % FYield Ê if the given à6 value is valid on the system. This implies that the S instance of àE is also system dependent as it is only defined for valid values of à. GGet the current value of errno in the current thread. HReset the current thread's errno value to â. I Throw an ƒ' corresponding to the current value of  G. J Throw an ƒ' corresponding to the current value of  G if the result value of the †" action meets the given predicate. Kas  J!, but discards the result of the † action after error handling. Las  J, but retry the †' action when it yields the error code  O - this amounts to the standard retry loop for interrupted POSIX system calls. Mas  L;, but additionally if the operation yields the error code é or  D5, an alternative action is executed before retrying. Nas  L, but discards the result. Oas  M, but discards the result. P Throw an ƒ' corresponding to the current value of  G if the † action returns a result of -1. Qas  P, but discards the result. R Throw an ƒ' corresponding to the current value of  G if the † action returns a result of -13, but retries in case of an interrupted operation. Sas  P, but discards the result. Tas  R-, but checks for operations that would block. Uas  T, but discards the result. V Throw an ƒ' corresponding to the current value of  G if the † action returns è. W Throw an ƒ' corresponding to the current value of  G if the † action returns è1, but retry in case of an interrupted operation. Xas  W-, but checks for operations that would block. Yas  I9, but exceptions include the given path when appropriate. Zas  J<, but exceptions include the given path when appropriate. [as  K<, but exceptions include the given path when appropriate. \as  V<, but exceptions include the given path when appropriate. ]as  P<, but exceptions include the given path when appropriate. ^as  Q<, but exceptions include the given path when appropriate. _ Construct an ƒ based on the given àY value. The optional information can be used to improve the accuracy of error messages. ` I)textual description of the error location J/predicate to apply to the result value of the † operation#textual description of the locationthe † operation to be executed M/predicate to apply to the result value of the † operation#textual description of the locationthe † operation to be executedDaction to execute before retrying if an immediate retry would block _%the location where the error occurredthe error number)optional handle associated with the error+optional filename associated with the error€àáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ                           ! " # $ % & ' ( ) * + , - . / 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 [ \ ] ^ _€àáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H _ I J K L N P Q R S V W M O T U X Y Z [ \ ] ^àá(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe‹pÔVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _g(c) Sven Panne 2002-2004/BSD-style (see the file libraries/base/LICENSE)sven.panne@aedion.de provisionalportable Trustworthy¦ aA memory pool. bAllocate a fresh memory pool. cUDeallocate a memory pool and everything which has been allocated in the pool itself. d‰Execute an action with a fresh memory pool, which gets automatically deallocated (including its contents) after the action has finished. eiAllocate space for storable type in the given pool. The size of the area allocated is determined by the  method from the instance of  for the appropriate type. f:Allocate the given number of bytes of storage in the pool. g[Adjust the storage area for an element in the pool to the given size of the required type. hEAdjust the storage area for an element in the pool to the given size. iRAllocate storage for the given number of elements of a storable type in the pool. j–Allocate storage for the given number of elements of a storable type in the pool, but leave room for an extra element to signal the end of the array. k.Adjust the size of an array in the given pool. lAAdjust the size of an array with an end marker in the given pool. mXAllocate storage for a value in the given pool and marshal the value into this storage. nfAllocate consecutive storage for a list of values in the given pool and marshal these values into it. o‘Allocate consecutive storage for a list of values in the given pool and marshal these values into it, terminating the end with the given marker. a b c d e f g h i j k l m n o a b c d e f g h i j k l m n o aï(c) The FFI task force 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe¨qA†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶· a b c d e f g h i j k l m n o(c) The FFI task force 2003/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe«bA†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶· a b c d e f g h i j k l m n o(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe®S¡xyz{|„‡ˆ‰Š‹Œãäåæçèéêëìíîïðñòóôõö÷ùøúûüýþÿèéêëìíîïðñòóôõöù  56789:;<=›œžŸ ¡¢£¥¦§¨©ª«¬†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶· a b c d e f g h i j k l m n o(c) The FFI task force 2001/BSD-style (see the file libraries/base/LICENSE)ffi@haskell.org provisionalportableSafe²Ä¡xyz{|„‡ˆ‰Š‹Œãäåæçèéêëìíîïðñòóôõö÷ùøúûüýþÿèéêëìíîïðñòóôõöù  56789:;<=›œžŸ ¡¢£¥¦§¨©ª«¬†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶· a b c d e f g h i j k l m n oh"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy0:DK¹9   ƒ … ‡ ‰ ‹  9 p q r s t u v w x y z { | } ~  € ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ Ž ‘ ’ “ ” • – — ˜ ™ š › œ ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨9 § ¨ ¥ ¦ £ ¤ ¡ ¢ Ÿ   ž › œ ™ š — ˜ • – “ ” ‘ ’ Ž ‹ Œ ‰ Š ‡ ˆ … † ƒ „ ‚  € } ~ | { z y x w r s q v u t p } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž  ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨UnsafeCVÑãðEvent notification backend.ñhPoll backend for new events. The provided callback is called once per file descriptor with new events.ò[Register, modify, or unregister interest in the given events on the given file descriptor.óiRegister interest in new events on a given file descriptor, set to be deactivated after the first event.ô0A type alias for timeouts, specified in seconds.õA pair of an event and lifetimeVHere we encode the event in the bottom three bits and the lifetime in the fourth bit. ¡&The lifetime of an event registration. ¢3the registration will be active for only one event £,the registration will trigger multiple times ¤ An I/O event. ¥Data is available to be read. ¦/The file descriptor is ready to accept a write.ö*Another thread closed the file descriptor.÷The longer of two lifetimes.øReturns Ê) if the modification succeeded. Returns ÅL if this backend does not support event notifications on this type of file.ùReturns Ê) if the modification succeeded. Returns ÅL if this backend does not support event notifications on this type of file.ú Throw an IOError( corresponding to the current value of  G if the result value of the † action is -1 and  G is not  ". If the result value is -1 and  G returns  9 0 is returned. Otherwise the result value is returned.ûüýmappend# takes the longer of two lifetimes.þðôÿõ ¡ ¢ £ ¤ ¥ ¦öøùúð ñòó ôÿõ ¡ ¢ £ ¤  Trustworthy "#KÓ ((c) The University of Glasgow, 1992-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (requires POSIX) Trustworthy Õ[v !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„ TrustworthyKâ…Create a new epoll backend.†KChange the set of events we are interested in for a given file descriptor.‡NSelect a set of file descriptors which are ready for I/O operations and call fD for all ready file descriptors, passing the events that are ready.ˆ”Create a new epoll context, returning a file descriptor associated with the context. The fd may be used for subsequent calls to this epoll context.RThe size parameter to epoll_create is a hint about the expected number of handles.uThe file descriptor returned from epoll_create() should be destroyed via a call to close() after polling is finished‰‡statetimeout in milliseconds I/O callbackŠ…‹ŒŽ‘’“”•–—˜™š"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthy&'Vdh÷ND3Converts an arbitrary value into an object of type  §..The type of the object must be an instance of bN, which ensures that only monomorphically-typed objects may be converted to  §(. To convert a polymorphic object into  §6, give it a monomorphic type signature. For example:  toDyn (id :: Int -> Int) §A value of type  §2 is an object encapsulated together with its type.A  §P may only represent a monomorphic value; an attempt to create a value of type  §R from a polymorphically-typed expression will result in an ambiguity error (see D).`ing a value of type  §V returns a pretty-printed representation of the object's type; useful for debugging. © Converts a  §L object back into an ordinary Haskell value of the correct type. See also  ª. ª Converts a  §L object back into an ordinary Haskell value of the correct type. See also  ©. ® ¯ ©the dynamically-typed objecta default valuesreturns: the value of the first argument, if it has the correct type, otherwise the value of the second argument. ªthe dynamically-typed object returns: É a=, if the dynamically-typed object has the correct type (and a is its value), or È otherwise. Db § ¨ © ª « ¬ ­ § ¨D © ª « ¬ ­b § ¨m((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)Unsafe 0DQVå­; °@Shared memory locations that support atomic memory transactions. ².A monad supporting atomic memory transactions. µThe current status of a thread ¶+the thread is currently runnable or running ·the thread has finished ¸&the thread is blocked on some resource ¹)the thread received an uncaught exception » blocked on [ ¼6blocked on a computation in progress by another thread ½ blocked in  Ó ¾ blocked in  à in an STM transaction ¿currently in a foreign call À)blocked on some other resource. Without  -threaded , I/O and  threadDelay show up as  À, with  -threaded they show up as  ». ÁA  Á8 is an abstract type representing a handle to a thread.  Á is an instance of S, [ and ` , where the [6 instance implements an arbitrary total ordering over  Ás. The `/ instance lets you convert an arbitrary-valued  Á to string form; showing a  Áa value is occasionally useful when debugging or diagnosing the behaviour of a concurrent program.Note: in GHC, if you have a  Áƒ, you essentially have a pointer to the thread itself. This means the thread itself can't be garbage collected until you drop the  Á>. This misfeature will hopefully be corrected at a later date. ÄEvery thread has an allocation counter that tracks how much memory has been allocated by the thread. The counter is initialized to zero, and  Äa sets the current value. The allocation counter counts *down*, so in the absence of a call to  ÄU its value is the negation of the number of bytes of memory allocated by the thread.7There are two things that you can do with this counter:0Use it as a simple profiling mechanism, with  Å.!Use it as a resource limit. See  Æ.8Allocation accounting is accurate only to about 4Kbytes. ÅKReturn the current value of the allocation counter for the current thread. ÆÈEnables the allocation counter to be treated as a limit for the current thread. When the allocation limit is enabled, if the allocation counter counts down below zero, the thread will be sent the Jv asynchronous exception. When this happens, the counter is reinitialised (by default to 100K, but tunable with the +RTS -xq† option) so that it can handle the exception and perform any necessary clean up. If it exhausts this additional allowance, another JM exception is sent, and so forth. Like other asynchronous exceptions, the J3 exception is deferred while the thread is inside “ or an exception handler in Ž.,Note that memory allocation is unrelated to  live memory, also known as heap residency¢. A thread can allocate a large amount of memory and retain anything between none and all of it. It is better to think of the allocation limit as a limit on CPU time , rather than a limit on memory.bCompared to using timeouts, allocation limits don't count time spent blocked or in foreign calls. Ç;Disable allocation limit processing for the current thread. È Creates a new thread to run the †; computation passed as the first argument, and returns the  Á of the newly created thread.&The new thread will be a lightweight, unbound° thread. Foreign calls made by this thread are not guaranteed to be made by any particular OS thread; if you need foreign calls to be made by a particular OS thread, then use k instead.The new thread inherits the masked state of the parent (see L).OThe newly created thread has an exception handler that discards the exceptions P, N, and BD, and passes all other exceptions to the uncaught exception handler. ÉLike  È—, but the child thread is passed a function that can be used to unmask asynchronous exceptions. This function is typically used in the following way U ... mask_ $ forkIOWithUnmask $ \unmask -> catch (unmask ...) handler¶so that the exception handler in the child thread is established with asynchronous exceptions masked, meanwhile the main body of the child thread is executed in the unmasked state.¡Note that the unmask function passed to the child thread should only be used in that thread; the behaviour is undefined if it is invoked in a different thread. ÊLike  ÈL, but lets you specify on which capability the thread should run. Unlike a  È thread, a thread created by  Ê; will stay on the same capability for its entire lifetime ( ÈP threads can migrate between capabilities according to the scheduling policy).  Êl is useful for overriding the scheduling policy when you know in advance how best to distribute the threads.The x argument specifies a capability number (see  ͈). Typically capabilities correspond to physical processors, but the exact behaviour is implementation-dependent. The value passed to  ÊG is interpreted modulo the total number of capabilities as returned by  Í.9GHC note: the number of capabilities is specified by the +RTS -N_ option when the program is started. Capabilities can be fixed to actual processor cores with +RTS -qaº if the underlying operating system supports that, although in practice this is usually unnecessary (and may actually degrade performance in some cases - experimentation is recommended). ËLike  É<, but the child thread is pinned to the given CPU, as with  Ê. Ìthe value passed to the +RTS -N´ flag. This is the number of Haskell threads that can run truly simultaneously at any given time, and is typically set to the number of physical processor cores on the machine.&Strictly speaking it is better to use  Í<, because the number of capabilities might vary at runtime. ͘Returns the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. To change this value, use  Î. ÎSet the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. The number passed to  ÊF is interpreted modulo this value. The initial value is given by the +RTS -N runtime flag.ÿKThis is also the number of threads that will participate in parallel garbage collection. It is strongly recommended that the number of capabilities is not set larger than the number of physical processor cores, and it may often be beneficial to leave one or more cores free to avoid contention with other processes in the machine. Ï/Returns the number of CPUs that the machine has Ð>Returns the number of sparks currently in the local spark pool Ò Ò raises the B* exception in the given thread (GHC only). )killThread tid = throwTo tid ThreadKilled Ó Ó? raises an arbitrary exception in the target thread (GHC only).FException delivery synchronizes between the source and target thread:  Óÿµ does not return until the exception has been raised in the target thread. The calling thread can thus be certain that the target thread has received the exception. Exception delivery is also atomic with respect to other exceptions. Atomicity is a useful property to have when dealing with race conditions: e.g. if there are two threads that can kill each other, it is guaranteed that only one of the threads will get to kill the other.“Whatever work the target thread was doing when the exception was raised is not lost: the computation is suspended until required by another thread.jIf the target thread is currently making a foreign call, then the exception will not be raised (and hence  Óm will not return) until the call has completed. This is the case regardless of whether the call is inside a “= or not. However, in GHC a foreign call can be annotated as  interruptible, in which case a  Óg will cause the RTS to attempt to cause the call to return; see the GHC documentation for more details.!Important note: the behaviour of  ÓP differs from that described in the paper "Asynchronous exceptions in Haskell" ( =http://research.microsoft.com/~simonpj/Papers/asynch-exns.htm). In the paper,  Ó[ is non-blocking; but the library implementation adopts a more synchronous design in which  Ó› does not return until the exception is received by the target thread. The trade-off is discussed in Section 9 of the paper. Like any blocking operation,  Óm is therefore interruptible (see Section 5.3 of the paper). Unlike other interruptible operations, however,  Ó is always3 interruptible, even if it does not actually block.×There is no guarantee that the exception will be delivered promptly, although the runtime will endeavour to ensure that arbitrary delays don't occur. In GHC, an exception can only be raised when a thread reaches a  safe point¢, where a safe point is where memory allocation occurs. Some loops do not perform any memory allocation inside the loop and therefore cannot be interrupted by a  Ó.If the target of  Ó: is the calling thread, then the behaviour is the same as L¾, except that the exception is thrown as an asynchronous exception. This means that if there is an enclosing pure computation, which would be the case if the current IO operation is inside e or g‚, that computation is not permanently replaced by the exception, but is suspended as if it had received an asynchronous exception. Note that if  Óv is called with the current thread as the target, the exception will be thrown even if the thread is currently inside “ or •. Ô Returns the  Á" of the calling thread (GHC only). ÕThe  ÕÓ action allows (forces, in a co-operative multitasking implementation) a context-switch to any other currently runnable threads (if any), and is occasionally useful when implementing concurrency abstractions. Ö Öÿ stores a string as identifier for this thread if you built a RTS with debugging support. This identifier will be used in the debugging output to make distinction of different threads easier (otherwise you only have the thread state object's address in the heap).COther applications like the graphical Concurrent Haskell Debugger ( +http://www.informatik.uni-kiel.de/~fhu/chd/) may choose to overload  Ö for their purposes as well. Ù0Internal function used by the RTS to run sparks. ÛÞreturns the number of the capability on which the thread is currently running, and a boolean indicating whether the thread is locked to that capability or not. A thread is locked to a capability if it was created with forkOn. Ümake a weak pointer to a  ÁH. It can be important to do this if you want to hold a reference to a  Á1 while still allowing the thread to receive the BlockedIndefinitely family of exceptions (e.g. P). Holding a normal  Á) reference will prevent the delivery of BlockedIndefinitelyB exceptions because the reference could be used as the target of  Ó. at any time, which would unblock the thread. Holding a  Weak ThreadIdA, on the other hand, will not prevent the thread from receiving BlockedIndefinitely? exceptions. It is still possible to throw an exception to a  Weak ThreadId, but the caller must use  deRefWeak5 first to determine whether the thread still exists. Ý7Make a StablePtr that can be passed to the C function hs_try_putmvar(). The RTS wants a „ to the underlying ƒ, but a „B can only refer to lifted types, so we have to cheat by coercing. ÞXUnsafely performs IO in the STM monad. Beware: this is a highly dangerous thing to do.‘The STM implementation will often run transactions multiple times, so you need to be prepared for this if your IO has any side effects.’The STM implementation will abort transactions that are known to be invalid and need to be restarted. This may happen in the middle of  Þÿ, so make sure you don't acquire any resources that need releasing (exception handlers are ignored when aborting the transaction). That includes doing any IO using Handles, for example. Getting this wrong will probably lead to random deadlocks.ÿ5The transaction may have seen an inconsistent view of memory when the IO runs. Invariants that you expect to be true throughout your program may not be true inside a transaction, due to the way transactions are implemented. Normally this wouldn't be visible to the programmer, but using  Þ can expose it. ß+Perform a series of STM actions atomically.You cannot use  ß inside an e or gÀ. Any attempt to do so will result in a runtime error. (Reason: allowing this would effectively allow a transaction inside a transaction, depending on exactly when the thunk is evaluated.) However, see  ç, which can be called inside e4, and which allows top-level TVars to be allocated. àÿ1Retry execution of the current memory transaction because it has seen values in TVars which mean that it should not continue (e.g. the TVars represent a shared buffer that is now empty). The implementation may block the thread until one of the TVars that it has read from has been udpated. (GHC only) áÿCompose two alternative STM actions (GHC only). If the first action completes without retrying then it forms the result of the orElse. Otherwise, if the first action retries, then the second action is tried in its place. If both actions retry then the orElse as a whole retries. â A variant of €" that can only be used within the  ² monad.Throwing an exception in STM6 aborts the transaction and propagates the exception. Although  â/ has a type that is an instance of the type of €*, the two functions are subtly different: ;throw e `seq` x ===> throw e throwSTM e `seq` x ===> x+The first example will cause the exception e8 to be raised, whereas the second one won't. In fact,  âG will only cause an exception to be raised when it is used within the  ² monad. The  â) variant should be used in preference to €# to raise an exception within the  ²= monad because it guarantees ordering with respect to other  ² operations, whereas € does not. ã&Exception handling within STM actions.›ÿLow-level primitive on which always and alwaysSucceeds are built. checkInv differs form these in that (i) the invariant is not checked when checkInv is called, only at the end of this and subsequent transcations, (ii) the invariant failure is indicated by raising an exception. äÿ9alwaysSucceeds adds a new invariant that must be true when passed to alwaysSucceeds, at the end of the current transaction, and at the end of every subsequent transaction. If it fails at any of those points then the transaction violating it is aborted and the exception raised by the invariant is propagated. åÉalways is a variant of alwaysSucceeds in which the invariant is expressed as an STM Bool action that must return True. Returning False or raising an exception are both treated as invariant failures. æ*Create a new TVar holding a value supplied çIO version of  æ*. This is useful for creating top-level  °s using 9, because using  ß inside 9 isn't possible. èAReturn the current value stored in a TVar. This is equivalent to # readTVarIO = atomically . readTVarrbut works much faster, because it doesn't perform a complete transaction, it just reads the current value of the  °. é)Return the current value stored in a TVar ê$Write the supplied value into a TVar ò ó ô õ ö ÷ ø ù úB ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñB Á Â È É Ê Ë Ì Í Î Ï Ð Ñ Ô Ò Ó Ø × Ù Õ Ö Ü µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Ú Û Ý ´ Ä Å Æ Ç ² ³ ß à á â ã ä å ° ± æ ç é è ê Þ ë ì ð ñ ï î à í ° ± ² ³ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á  ×0 Ø0"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental"non-portable (extended exceptions) Trustworthy0D/Ñ# )Thrown when the program attempts to call  atomically , from the stm" package, inside another call to  atomically. ãThrown when the runtime system detects that the computation is guaranteed not to terminate. Note that there is no guarantee that the runtime system will notice whether any given computation is guaranteed to terminate or not.  yAn expression that didn't typecheck during compile time was called. This is only possible with -fdefer-type-errors. The String, gives details about the failed type check. ƒA class method without a definition (neither a default definition, nor a definition in the appropriate instance) was called. The String- gives information about which method it was. ÐA record update was performed on a constructor without the appropriate field. This can only happen with a datatype with multiple constructors, where some fields are in one constructor but not another. The StringC gives information about the source location of the record update. ,An uninitialised record field was used. The StringP gives information about the source location where the record was constructed. ÐA record selector was applied to a constructor without the appropriate field. This can only happen with a datatype with multiple constructors, where some fields are in one constructor but not another. The StringE gives information about the source location of the record selector. A pattern match failed. The String= gives information about the source location of the pattern.  The function   is like Ž., but it takes an extra argument which is an exception predicateI, a function which selects which type of exceptions we're interested in. ÒcatchJust (\e -> if isDoesNotExistErrorType (ioeGetErrorType e) then Just () else Nothing) (readFile f) (\_ -> do hPutStrLn stderr ("No such file: " ++ show f) return "")oAny other exceptions which are not matched by the predicate are re-raised, and may be caught by an enclosing Ž,  , etc.  A version of Žr with the arguments swapped around; useful in situations where the code for the handler is shorter. For example: D do handle (\NonTermination -> exitWith (ExitFailure 1)) $ ...  A version of  ) with the arguments swapped around (see  ). oThis function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".  Similar to Ž, but returns an Ž result which is (Í a) if no exception of type e was raised, or (Ì ex) if an exception of type e was raised and its value is exs. If any other type of exception is raised than it will be propogated up to the next enclosing exception handler. 0 try a = catch (Right `liftM` a) (return . Left)  A variant of  P that takes an exception predicate to select which exceptions are caught (c.f.  D). If the exception does not match the predicate, it is re-thrown. Like  Z, but only performs the final action if there was an exception raised by the computation. tWhen you want to acquire a resource, do some work with it, and then release the resource, it is a good idea to use   , because  ª will install the necessary exception handler to release the resource in the event that an exception is raised during the computation. If an exception is raised, then  = will re-raise the exception (after performing the release).#A common example is opening a file: Qbracket (openFile "filename" ReadMode) (hClose) (\fileHandle -> do { ... })The arguments to  < are in this order so that we can partially apply it, e.g.: 8withFile name mode = bracket (openFile name mode) hClose A specialised variant of  + with just a computation to run afterward.  A variant of  D where the return value from the first computation is not required. Like  e, but only performs the final action if there was an exception raised by the in-between computation.    ! " # $ % & ' ( ) * + , - Predicate to select exceptionsComputation to runHandler -computation to run first ("acquire resource"),computation to run last ("release resource")computation to run in-between computation to run first?computation to run afterward (even if an exception was raised) -computation to run first ("acquire resource"),computation to run last ("release resource")computation to run in-between_ +~qrstuvwxyz{|}€„†‡ˆ‰Ž‘’“”•–<=>?@ABCDEFGHIJKLMNOPQRST Ó                        _+~z{|}„qrstuvw<=>FGDE?@ABCRS    PQNOJKHILM      xy  €T ÓŽ      – “’•”†‡ˆ‰‘                      K"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable Trustworthys .The construct  . compV exposes IO errors which occur within a computation, and which are not fully handled.QNon-I/O exceptions are not caught by this variant; to catch all exceptions, use L from Control.Exception. / Construct an ƒÅ of the given type where the second argument describes the error location and the third and fourth argument contain the file handle and file path of the file involved in the error if applicable. 0An error indicating that an †? operation failed because one of its arguments already exists. 1An error indicating that an †? operation failed because one of its arguments does not exist. 2An error indicating that an †µ operation failed because one of its arguments is a single-use resource, which is already being used (for example, opening the same file twice for writing might give this error). 3An error indicating that an †. operation failed because the device is full. 4An error indicating that an †< operation failed because the end of file has been reached. 5An error indicating that an †] operation failed because the operation was not possible. Any computation which returns an † result may fail with  5‹. In some cases, an implementation will not be able to distinguish between the possible error causes. In this case it should fail with  5. 6An error indicating that an †s operation failed because the user does not have sufficient operating system privilege to perform that operation. 73A programmer-defined error value constructed using …. 8RI/O error where the operation failed because one of its arguments already exists. 9RI/O error where the operation failed because one of its arguments does not exist. :yI/O error where the operation failed because one of its arguments is a single-use resource, which is already being used. ;@I/O error where the operation failed because the device is full. <OI/O error where the operation failed because the end of file has been reached. =.I/O error where the operation is not possible. >…I/O error where the operation failed because the user does not have sufficient operating system privilege to perform that operation. ?%I/O error that is programmer-defined. @RI/O error where the operation failed because one of its arguments already exists. ARI/O error where the operation failed because one of its arguments does not exist. ByI/O error where the operation failed because one of its arguments is a single-use resource, which is already being used. C@I/O error where the operation failed because the device is full. DOI/O error where the operation failed because the end of file has been reached. E.I/O error where the operation is not possible. F…I/O error where the operation failed because the user does not have sufficient operating system privilege to perform that operation. G%I/O error that is programmer-defined. R Catch any ƒ> that occurs in the computation and throw a modified version. SIAdds a location description and maybe a file path and file handle to an ƒW. If any of the file handle or file path is not given the corresponding value in the ƒ remains unaltered. TThe  T3 function establishes a handler that receives any ƒ# raised in the action protected by  T. An ƒˆ is caught by the most recent handler established by one of the exception handling functions. These handlers are not selective: all ƒ‡s are caught. Exception propagation must be explicitly provided in a handler by re-raising any unwanted exceptions. For example, in Kf = catchIOError g (\e -> if IO.isEOFError e then return [] else ioError e) the function f returns []% when an end-of-file exception (cf.  4 ) occurs in gD; otherwise, the exception is propagated to the next outer handler.aWhen an exception propagates outside the main program, the Haskell system prints the associated ƒ value and exits the program.QNon-I/O exceptions are not caught by this variant; to catch all exceptions, use L from Control.Exception.+ƒ…8T . / 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+ƒ… / S 0 1 2 3 4 5 6 7 H J I K L M N O P Q8 8 9 : ; < = > ? @ A B C D E F GT T . RL"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental"non-portable (extended exceptions) TrustworthyCVˆŸ UYou need this when using  W. WYSometimes you want to catch two different sorts of exception. You could do something like wf = expr `catch` \ (ex :: ArithException) -> handleArith ex `catch` \ (ex :: IOException) -> handleIO exÿHowever, there are a couple of problems with this approach. The first is that having two exception handlers is inefficient. However, the more serious issue is that the second exception handler will catch exceptions in the first, e.g. in the example above, if  handleArith throws an  IOException1 then the second exception handler will catch it.Instead, we provide a function  W, which would be used thus: “f = expr `catches` [Handler (\ (ex :: ArithException) -> handleArith ex), Handler (\ (ex :: IOException) -> handleIO ex)] XWhen invoked inside “Ñ, this function allows a masked asynchronous exception to be raised, if one exists. It is equivalent to performing an interruptible operation (see #interruptible), but does not involve any actual blocking.When called outside “ , or inside •, this function has no effect. YY+~qrstuvwxyz{|}€„†‡ˆ‰Ž‘’“”•–<=>?@ABCDEFGHIJKLMNOPQRST Ó                       U V W XY+~z{|}„qrstuvw<=>FGDE?@ABCRS    PQNOJKHILM      xy  €T ÓŽ W U V     – “’•”†‡ˆ‰‘ X      U V9"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableUnsafe’¾ ZA slightly faster version of _ that may not be safe to use with multiple threads. The unsafety arises when used like this: = unsafeFixIO $ \r -> do forkIO (print r) return (...).In this case, the child thread will receive a NonTermination0 exception instead of waiting for the value of r to be computed.efg Zefg Z ((c) The University of Glasgow, 2008-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyZ˜ªœConstruct an iconv-based Ú" for the given character set and U. As iconv is missing in some minimal environments (e.g. #10298), this checks to ensure that iconv is working properly before returning the encoding, returning È if not.žœS((c) The University of Glasgow, 2008-2009see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyÙ´ô*The Unicode encoding of the current localeõuThe Unicode encoding of the current locale, but allowing arbitrary undecodable bytes to be round-tripped through it.This Úi is used to decode and encode command line arguments and environment variables on non-Windows platforms.´On Windows, this encoding *should not* be used if possible because the use of code pages is deprecated: Strings should be retrieved via the "wide" W-family of UTF-16 APIs insteadö…The Unicode encoding of the current locale, but where undecodable bytes are replaced with their closest visual match. Used for the CString marshalling functions in Foreign.C.String [ÈThe Latin1 (ISO8859-1) encoding. This encoding maps bytes directly to the first 256 Unicode code points, and is thus not a complete Unicode encoding. An attempt to write a character greater than '\255' to a Handle using the  [" encoding will result in an error. \The UTF-8 Unicode encoding ]yThe UTF-8 Unicode encoding, with a byte-order-mark (BOM; the byte sequence 0xEF 0xBB 0xBF). This encoding behaves like  \ƒ, except that on input, the BOM sequence is ignored at the beginning of the stream, and on output, the BOM sequence is prepended.pThe byte-order-mark is strictly unnecessary in UTF-8, but is sometimes used to identify the encoding of a file. ^WThe UTF-16 Unicode encoding (a byte-order-mark should be used to indicate endianness). _*The UTF-16 Unicode encoding (litte-endian) `(The UTF-16 Unicode encoding (big-endian) aWThe UTF-32 Unicode encoding (a byte-order-mark should be used to indicate endianness). b*The UTF-32 Unicode encoding (litte-endian) c(The UTF-32 Unicode encoding (big-endian) d e f gŸ  hµAn encoding in which Unicode code points are translated to bytes by taking the code point modulo 256. When decoding, bytes are translated directly into the equivalent code point.‹This encoding never fails in either direction. However, encoding discards information, so encode followed by decode is not the identity. i2Look up the named Unicode encoding. May fail withisDoesNotExistError if the encoding is unknownFThe set of known encodings is system-dependent, but includes at least: UTF-8UTF-16, UTF-16BE, UTF-16LEUTF-32, UTF-32BE, UTF-32LEjThere is additional notation (borrowed from GNU iconv) for specifying how illegal characters are handled: a suffix of //IGNORE, e.g.  UTF-8//IGNORE¢, will cause all illegal sequences on input to be ignored, and on output will drop all code points that have no representation in the target encoding. a suffix of  //TRANSLITN will choose a replacement character for illegal sequences or code points. a suffix of  //ROUNDTRIPÿ. will use a PEP383-style escape mechanism to represent any invalid bytes in the input as Unicode codepoints (specifically, as lone surrogates, which are normally invalid in UTF-32). Upon output, these special codepoints are detected and turned back into the corresponding original byte.MIn theory, this mechanism allows arbitrary data to be roundtripped via a /Q with no loss of data. In practice, there are two limitations to be aware of: ÿ\This only stands a chance of working for an encoding which is an ASCII superset, as for security reasons we refuse to escape any bytes smaller than 128. Many encodings of interest are ASCII supersets (in particular, you can assume that the locale encoding is an ASCII superset) but many (such as UTF-16) are not.ÿgIf the underlying encoding is not itself roundtrippable, this mechanism can fail. Roundtrippable encodings are those which have an injective mapping into Unicode. Almost all encodings meet this criteria, but some do not. Notably, Shift-JIS (CP932) and Big5 contain several different encodings of the same Unicode codepoint.AOn Windows, you can access supported code pages with the prefix CP; for example, "CP1250".&Ö×ØÙÚÛÜÝÞßàäåèæçéêôõö [ \ ] ^ _ ` a b c d e f g h i j k&äåæçèéêÚÛÜÝÞßàÖ×ØÙ [ j k \ ] ^ _ ` a b c gôõö d e f h i6"(c) The University of Glasgow 2011see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyDãàS Returns a [String]I representing the current call stack. This can be useful for debugging.The implementation uses the call-stack simulation maintained by the profiler, so it only works if the program was compiled with -prof7 and contains suitable SCC annotations (e.g. by using  -fprof-autoI). Otherwise, the list returned is likely to be empty or uninformative. w*Get the stack trace attached to an object.S l m n o p q r s t u v w xS w m l n o p q r s t u v x"(c) The University of Glasgow 2011see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) TrustworthyDQVì yLike the function ,F, but appends a stack trace to the error message if one is available. z &Pop the most recent call-site off the ¾.This function, like J, has no effect on a frozen ¾. { Return the current ¾.$Does *not* include the call-site of  {. | ;Perform some computation without adding new entries to the ¾.$IJ¾Ó !"#$%&'()*S‚ l m n o p q r s t u v w x y z { |$ yS w¾' {I*)( z‚J |Ó !"#$%& m l n o p q r s t u v x!((c) The University of Glasgow, 1994-2001see libraries/base/LICENSElibraries@haskell.orginternal non-portable Trustworthy"#QVZù‚¡ Just like æ, but interleaves calls to æ with calls to ç. in order to make as much progress as possible¢™syncs the file with the buffer, including moving the file pointer backwards in the case of a read buffer. This can fail on a non-seekable read Handle.£4flushes the Char buffer only. Works on all Handles. } makes a new 1 ~like  }, except that a 1ˆ is created with two independent buffers, one for reading and one for writing. Used for full-duplex streams, such as network sockets. }.the underlying IO device, which must support ,  and ba string describing the 1:, e.g. the file path for a file. Used in error messages.(¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¢£¹º»¼½¾ } ~¿ÀÁ ÂÃÄÅÆn TrustworthyþV € Computation  € is the "raw" version of getArgs, similar to argv° in other languages. It returns a list of the program's command line arguments, starting with the program name, and including those normally eaten by the RTS (+RTS ... -RTS). € €8"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (concurrency) TrustworthyDÒ Take a value from an [, put a new value into the [g and return the value taken. This function is atomic only if there are no other producers for this [. ‚ ‚D is an exception-safe wrapper for operating on the contents of an [T. This operation is exception-safe: it will replace the original contents of the [" if an exception is raised (see Control.ExceptionJ). However, it is only atomic if there are no other producers for this [. ƒLike  ‚ , but the IOQ action in the second argument is executed with asynchronous exceptions masked. „;An exception-safe wrapper for modifying the contents of an [ . Like  ‚,  …- will replace the original contents of the [| if an exception is raised during the operation. This function is only atomic if there are no other producers for this [. …A slight variation on  „' that allows a value to be returned (b+) in addition to the modified value of the [. †Like  „ , but the IOQ action in the second argument is executed with asynchronous exceptions masked. ‡Like  … , but the IOQ action in the second argument is executed with asynchronous exceptions masked. ‰Make a f pointer to an [8, using the second argument as a finalizer to run when [ is garbage-collected[\]^_`abcd ‚ ƒ „ … † ‡ ˆ ‰[\]^`_ abd ‚ ƒ „ … † ‡c ‰ ˆ" TrustworthyKõÇÈÉÊËÌÍÎÏÐÑÒÓÔo Trustworthy Š ‹ Œ Ž ‹ Š Œ Ž#UnsafeVÕ<The structure used to tell the IO manager thread what to do.Ö(Have this Control's fds been cleaned up?×dCreate the structure (usually a pipe) used for waking up the IO manager thread from another thread.Øÿ2Close the control structure used by the IO manager thread. N.B. If this Control is the Control whose wakeup file was registered with the RTS, then *BEFORE* the wakeup file is closed, we must call c_setIOManagerWakeupFd (-1), so that the RTS does not try to use the wakeup file after it has been closed.} ‹ÕÙÚÛÜÝÞß×ØàáâÕãÚÙäåÖÛÜÝÞ$ Trustworthy;=CV,P The event manager state.æAn edit to apply to a ç.ç5A priority search queue, with timeouts as priorities. #Callback invoked on timeout events. ‘A timeout registration cookie.èCreate a new event manager.é8Asynchronously shuts down the event manager, if running.êGStart handling events. This function loops until told to stop, using é.Note%: This loop can only be run once per  >, as it closes all of its control resources when it finishes.ëWake up the event manager. ’GRegister a timeout in the given number of microseconds. The returned  ‘… can be used to later unregister or update the timeout. The timeout is automatically unregistered after the given time has passed. “Unregister an active timeout. ”FUpdate an active timeout to fire in the given number of microseconds. ì ‘íèîéïðêñë ’ “ ” òóôõöì÷øùúû ‘ü% Trustworthy"#;=CVPk •The event manager state. –Callback invoked on I/O events. —&A file descriptor registration cookie. ™Create a new event manager.ý Create a new  • with the given polling backend.þ8Asynchronously shuts down the event manager, if running.ÿIAsynchronously tell the thread executing the event manager loop to exit.GStart handling events. This function loops until told to stop, using þ.Note%: This loop can only be run once per  •>, as it closes all of its control resources when it finishes.ÿ"To make a step, we first do a non-blocking poll, in case there are already events ready to handle. This improves performance because we can make an unsafe foreign C call, thereby avoiding forcing the current Task to release the Capability and forcing a context switch. If the poll fails to find events, we yield, putting the poll loop thread at end of the Haskell run queue. When it comes back around, we do one more non-blocking poll, in case we get lucky and have ready events. If that also returns no events, then we do a blocking poll.VRegister interest in the given events, without waking the event manager thread. The tE return value indicates whether the event manager ought to be woken.QNote that the event manager is generally implemented in terms of the platform's select or epollŽ system call, which tend to vary in what sort of fds are permitted. For instance, waiting on regular files is not allowed on many platforms. šregisterFd mgr cb fd evs lt" registers interest in the events evs on the file descriptor fd for lifetime lt. cbQ is called for each event that occurs. Returns a cookie that can be handed to  œ.Wake up the event manager. ›¡Drop a previous file descriptor registration, without waking the event manager thread. The return value indicates whether the event manager ought to be woken. œ-Drop a previous file descriptor registration. +Close a file descriptor in a race-safe way.ôClose a file descriptor in a race-safe way. It assumes the caller will update the callback tables and that the caller holds the callback table lock for the fd. It must hold this lock because this command executes a backend command on the fd.>Call the callbacks corresponding to the given file descriptor. ¡ ¢ £ ¤ ¥ ¦ • – — ˜ ™ýþÿ   š › œ  •   — ˜& Trustworthyw KSuspends the current thread for a given number of microseconds (GHC only).‹There is no guarantee that the thread will be rescheduled promptly when the delay has expired, but the thread will never continue to run earlier than specified.Set the value of returned TVar to True after a given number of microseconds. The caveats associated with threadDelay also apply. YBlock the current thread until data is available to read from the given file descriptor.This will throw an IOError if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with  , use !."SBlock the current thread until the given file descriptor can accept data to write.This will throw an IOError if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with ", use !.!2Close a file descriptor in a concurrency-safe way.9Any threads that are blocked on the file descriptor via   or "3 will be unblocked by having IO exceptions thrown.#ÿAllows a thread to use an STM action to wait for a file descriptor to be readable. The STM action will retry until the file descriptor has data ready. The second element of the return value pair is an IO action that can be used to deregister interest in the file descriptor.The STM action will throw an IOErrorˆ if the file descriptor was closed while the STM action is being executed. To safely close a file descriptor that has been used with #, use !.$ÿ4Allows a thread to use an STM action to wait until a file descriptor can accept a write. The STM action will retry while the file until the given file descriptor can accept a write. The second element of the return value pair is an IO action that can be used to deregister interest in the file descriptor.The STM action will throw an IOErrorˆ if the file descriptor was closed while the STM action is being executed. To safely close a file descriptor that has been used with $, use !. ž]Retrieve the system event manager for the capability on which the calling thread is running.This function always returns ÉE the current thread's event manager when using the threaded RTS and È otherwise.%The ioManagerLock protects the &H value: Only one thread at a time can start or shutdown event managers.!Action that performs the close.File descriptor to close.  "!'#$ ž Ÿ()'((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions) TrustworthyD”P ¢bBlock the current thread until data is available to read on the given file descriptor (GHC only).This will throw an IOError if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with  ¢, use  ¦. £\Block the current thread until data can be written to the given file descriptor (GHC only).This will throw an IOError if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with  £, use  ¦. ¤ÄReturns an STM action that can be used to wait for data to read from a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor. ¥ËReturns an STM action that can be used to wait until data can be written to a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor. ¦QClose a file descriptor in a concurrency-safe way (GHC only). If you are using  ¢ or  £ to perform blocking I/O, you mustS use this function to close file descriptors, or blocked threads may not be woken.9Any threads that are blocked on the file descriptor via  ¢ or  £3 will be unblocked by having IO exceptions thrown. §KSuspends the current thread for a given number of microseconds (GHC only).‹There is no guarantee that the thread will be rescheduled promptly when the delay has expired, but the thread will never continue to run earlier than specified. ¨Set the value of returned TVar to True after a given number of microseconds. The caveats associated with threadDelay also apply. ¦.Low-level action that performs the real close.File descriptor to close.   ¡ ¢ £ ¤ ¥ ¦ § ¨   ¡ § ¨ ¢ £ ¤ ¥ ¦(((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portable TrustworthyŸ *Open a file and make an +4 for it. Truncates the file to zero size when the 0 is 2.,Make a +i from an existing file descriptor. Fails if the FD refers to a directory. If the FD refers to a file, ,y locks the file according to the Haskell 2010 single writer/multiple reader locking semantics (this is why we need the 0 argument too).-./0* file to openmode in which to open the file#open the file in non-blocking mode?,is a socket (on Windows)is in non-blocking mode on Unix+123*,456789:;+123)((c) The University of Glasgow, 1992-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portable Trustworthy"#DZõ © Computation  © hdl t+ waits until input is available on handle hdl. It returns Ê" as soon as input is available on hdl, or Å! if no input is available within t milliseconds. Note that  © waits until one or more full  characterse are available, which means that it needs to do decoding, and hence may fail with a decoding error.If t is less than zero, then  hWaitForInput waits indefinitely.This operation may fail with: 4% if the end of file has been reached.ba decoding error, if the input begins with an invalid byte sequence in this Handle's encoding.'NOTE for GHC users: unless you use the  -threaded flag, hWaitForInput hdl t where t >= 0Y will block all other Haskell threads for the duration of the call. It behaves like a safe foreign call in this respect. ª Computation  ª hdl8 reads a character from the file or channel managed by hdl*, blocking until a character is available.This operation may fail with: 4% if the end of file has been reached. « Computation  « hdl3 reads a line from the file or channel managed by hdl.This operation may fail with: 48 if the end of file is encountered when reading the first character of the line.If  «Œ encounters end-of-file at any other point while reading in a line, it is treated as a line terminator and the (partial) line is returned. ¬ Computation  ¬ hdlh returns the list of characters corresponding to the unread portion of the channel or file managed by hdl+, which is put into an intermediate state,  semi-closed. In this state, hdl1 is effectively closed, but items are read from hdl: on demand and accumulated in a special list returned by  ¬ hdl.tAny operation that fails because a handle is closed, also fails if a handle is semi-closed. The only exception is hClose'. A semi-closed handle becomes closed:if hClose is applied to it;<if an I/O error occurs when reading an item from the handle;8or once the entire contents of the handle has been read.ÿ Once a semi-closed handle becomes closed, the contents of the associated list becomes fixed. The contents of this final list is only partially specified: it will contain at least all the items of the stream that were evaluated prior to the handle becoming closed.OAny I/O errors encountered while a handle is semi-closed are simply discarded.This operation may fail with: 4% if the end of file has been reached. ­ Computation  ­ hdl ch writes the character ch$ to the file or channel managed by hdl;. Characters may be buffered if buffering is enabled for hdl.This operation may fail with: 3 if the device is full; or 64 if another system resource limit would be exceeded. ® Computation  ® hdl s writes the string s# to the file or channel managed by hdl.This operation may fail with: 3 if the device is full; or 64 if another system resource limit would be exceeded. ¯ The same as  ®, but adds a newline character. ° °  hdl buf count writes count 8-bit bytes from the buffer buf to the handle hdl. It returns (). °/ ignores any text encoding that applies to the 1?, writing the bytes directly to the underlying file or device. ° ignores the prevailing  TextEncoding and & on the 1, and writes bytes directly.This operation may fail with:Üø if the handle is a pipe or socket, and the reading end is closed. (If this is a POSIX system, and the program has not asked to ignore SIGPIPE, then a SIGPIPE may be delivered instead, whose default action is to terminate the program). ² ²  hdl buf count reads data from the handle hdl into the buffer buf! until either EOF is reached or count’ 8-bit bytes have been read. It returns the number of bytes actually read. This may be zero if EOF was reached before any data was read (or if count is zero). ²I never raises an EOF exception, instead it returns a value smaller than count.CIf the handle is a pipe or socket, and the writing end is closed,  ²# will behave as if EOF was reached. ² ignores the prevailing  TextEncoding and & on the 1, and reads bytes directly. ³ ³  hdl buf count reads data from the handle hdl into the buffer buf1. If there is any data available to read, then  ³H returns it immediately; it only blocks if there is no data to be read.tIt returns the number of bytes actually read. This may be zero if EOF was reached before any data was read (or if count is zero). ³I never raises an EOF exception, instead it returns a value smaller than count.CIf the handle is a pipe or socket, and the writing end is closed,  ³# will behave as if EOF was reached. ³ ignores the prevailing  TextEncoding and & on the 1, and reads bytes directly. ´ ´  hdl buf count reads data from the handle hdl into the buffer buf" until either EOF is reached, or countU 8-bit bytes have been read, or there is no more data available to read immediately. ´ is identical to  ²ª, except that it will never block waiting for data to become available, instead it returns only whatever data is available. To wait for data to arrive before calling  ´, use  ©.CIf the handle is a pipe or socket, and the writing end is closed,  ´# will behave as if EOF was reached. ´ ignores the prevailing  TextEncoding and & on the 1, and reads bytes directly.TNOTE: on Windows, this function does not work correctly; it behaves identically to  ².< © ª « ¬ ­ ® ¯= ° ± ² ³ ´W((c) The University of Glasgow, 1994-2008see libraries/base/LICENSElibraries@haskell.orginternal non-portable Trustworthy 6JA handle managing output to the Haskell program's standard output channel. µJA handle managing input from the Haskell program's standard input channel. ¶IA handle managing output to the Haskell program's standard error channel. · Computation  ·  file mode> allocates and returns a new, open handle to manage the file file. It manages input if mode is 1 , output if mode is 2 or 3(, and both input and output if mode is 4.aIf the file does not exist and it is opened for output, it should be created as a new file. If mode is 2· and the file already exists, then it should be truncated to zero length. Some operating systems delete empty files, so there is no guarantee that the file will exist following an  · with mode 2h unless it is subsequently written to successfully. The handle is positioned at the end of the file if mode is 3ƒ, and otherwise at the beginning (in which case its internal position is 0). The initial buffer mode is implementation-dependent.This operation may fail with:isAlreadyInUseError4 if the file is already open and cannot be reopened;isDoesNotExistError if the file does not exist; orisPermissionError7 if the user does not have permission to open the file.YNote: if you will be working with files containing binary data, you'll want to be using  ¹. ¸Like  ·ð, but opens the file in ordinary blocking mode. This can be useful for opening a FIFO for writing: if we open in non-blocking mode then the open will fail if there are no readers, whereas a blocking open will block until a reader appear. ¹Like  ·ÿº, but open the file in binary mode. On Windows, reading a file in text mode (which is the default) will translate CRLF to LF, and writing will translate LF to CRLF. This is usually what you want with text files. With binary files this is undesirable; also, as usual under Microsoft operating systems, text mode treats control-Z as EOF. Binary mode turns off all special treatment of end-of-line and end-of-file characters. (See also hSetBinaryMode.) »&Old API kept to avoid breaking clients ¼mTurn an existing file descriptor into a Handle. This is used by various external libraries to make Handles.˜Makes a binary Handle. This is for historical reasons; it should probably be a text Handle with the default encoding and newline translation instead. ½„Turn an existing Handle into a file descriptor. This function throws an IOError if the Handle does not reference a file descriptor. 6 µ ¶ · ¸ ¹ º » ¼ ½ µ6 ¶ · ¹ ¸ º ¼ » ½pNone ]^.Å ¾2Indicates a mode in which a file should be locked. ÁException thrown by  Ã. on non-Windows platforms that don't support flock. à If a 1ÿ references a file descriptor, attempt to lock contents of the underlying file in appropriate mode. If the file is already locked in incompatible mode, this function blocks until the lock is established. The lock is automatically released upon closing a 1.Things to be aware of:Ý1) This function may block inside a C call. If it does, in order to be able to interrupt it with asynchronous exceptions and/or for other threads to continue working, you MUST use threaded version of the runtime system.2) The implementation uses  LockFileEx on Windows and flock8 otherwise, hence all of their caveats also apply here./3) On non-Windows plaftorms that don't support flock& (e.g. Solaris) this function throws FileLockingNotImplementede. We deliberately choose to not provide fcntl based locking instead because of its broken semantics. Ä Non-blocking version of  Ã. ¾ ¿ À Á  à Ä Á  ¾ ¿ À à Ä ¾ ¿ À Á ÂV((c) The University of Glasgow, 1994-2009see libraries/base/LICENSElibraries@haskell.org provisional non-portable Trustworthy"#Zz7 The action 7 hdl1 causes any items buffered for output in handle hdl0 to be sent immediately to the operating system.This operation may fail with: isFullError if the device is full;isPermissionError¢ if a system resource limit would be exceeded. It is unspecified whether the characters in the buffer are discarded or retained under these circumstances. Ê Computation  Ê hdl makes handle hdl/ closed. Before the computation finishes, if hdl+ is writable its buffer is flushed as for 7. Performing  ÊŒ on a handle that has already been closed has no effect; doing so is not an error. All other operations on a closed handle will fail. If  Ê; fails for any reason, any further operations (apart from  Ê&) on the handle will still fail as if hdl had been successfully closed. Ë For a handle hdl% which attached to a physical file,  Ë hdl. returns the size of that file in 8-bit bytes. Ì Ì hdl size) truncates the physical file with handle hdl to size bytes. ÍFor a readable handle hdl,  Í hdl returns Ê' if no further input can be taken from hdlr or for a physical file, if the current I/O position is equal to the length of the file. Otherwise, it returns Å.NOTE:  Ív may block, because it has to attempt to read from the stream to determine whether there is any more data to be read. ÎThe computation  Î is identical to  Í , except that it works only on  µ. Ï Computation  Ï returns the next character from the handle without removing it from the input buffer, blocking until a character is available.This operation may fail with: isEOFError% if the end of file has been reached. Ð Computation  Ð hdl mode( sets the mode of buffering for handle hdl on subsequent reads and writes.#If the buffer mode is changed from 0 or / to ., thenif hdl+ is writable, the buffer is flushed as for 7;if hdl: is not writable, the contents of the buffer is discarded.This operation may fail with:isPermissionError‹ if the handle has already been used for reading or writing and the implementation does not allow the buffering mode to be changed. Ñ The action  Ñ hdl encoding+ changes the text encoding for the handle hdl to encoding. The default encoding when a 1 is created is localeEncoding6, namely the default encoding for the current locale. To create a 1 with no encoding at all, use  ¹8. To stop further encoding or decoding on an existing 1, use  á. ÑB may need to flush buffered data in order to change the encoding. ÒReturn the current Ú for the specified 1, or È if the 1 is in binary mode.Note that the ÚJ remembers nothing about the state of the encoder/decoder in use on this 1>. For example, if the encoding in use is UTF-16, then using  Ò and  Ñd to save and restore the encoding may result in an extra byte-order-mark being written to the file. Ó The action  Ó hdl flushes all buffered data in hdl±, including any buffered read data. Buffered read data is flushed by seeking the file position back to the point before the bufferred data was read, and hence only works if hdl is seekable (see  Ý).This operation may fail with: isFullError if the device is full;isPermissionError¢ if a system resource limit would be exceeded. It is unspecified whether the characters in the buffer are discarded or retained under these circumstances;isIllegalOperation if hdl1 has buffered read data, and is not seekable. Ô Computation  Ô hdl& returns the current I/O position of hdl! as a value of the abstract type  È. Õ If a call to  Ô hdl returns a position p, then computation  Õ p sets the position of hdl5 to the position it held at the time of the call to  Ô.This operation may fail with:isPermissionError. if a system resource limit would be exceeded. Ö Computation  Ö  hdl mode i sets the position of handle hdl depending on mode. The offset i" is given in terms of 8-bit bytes.If hdlÿ is block- or line-buffered, then seeking to a position which is not in the current buffer will first cause any items in the output buffer to be written to the device, and then cause the input buffer to be discarded. Some handles may not be seekable (see  ÝÿH), or only support a subset of the possible positioning operations (for instance, it may only be possible to seek to the end of a tape, or to a positive offset from the beginning or current position). It is not possible to set a negative I/O position, or for a physical file, an I/O position beyond the current end-of-file.This operation may fail with:isIllegalOperationErrorQ if the Handle is not seekable, or does not support the requested seek mode.isPermissionError. if a system resource limit would be exceeded. × Computation  × hdl- returns the current position of the handle hdlm, as the number of bytes from the beginning of the file. The value returned may be subsequently passed to  Ö2 to reposition the handle to the current position.This operation may fail with:isIllegalOperationError if the Handle is not seekable. Ü Computation  Ü hdl) returns the current buffering mode for hdl. Þ;Set the echoing status of a handle connected to a terminal. ß;Get the echoing status of a handle connected to a terminal. à&Is the handle connected to a terminal? áSelect binary mode (Ê) or text mode (Å) on a open handle. (See also  ¹.)$This has the same effect as calling  Ñ with  h, together with  â with 5. âSet the & on the specified 1'. All buffered data is flushed first. ãçReturns a duplicate of the original handle, with its own buffer. The two Handles will share a file pointer, however. The original handle's buffer is flushed, including discarding any input data, before the handle is duplicated. äwMakes the second handle a duplicate of the first handle. The second handle will be closed first, if it is not already.?This can be used to retarget the standard Handles, for example: >do h <- openFile "mystdout" WriteMode hDuplicateTo h stdout å å is in the †I monad, and gives more comprehensive output than the (pure) instance of ` for 1. æ çF÷øùú&'()*+,-./0123457 } ~  © ª « ¬ ­ ® ° ± ² ´ ¾ ¿ À Ã Ä Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä åF1-./0 } ~ Ë Ì Í Î Ï Ð á Ñ Ò7 Ó ã ä Ê  ¾ ¿ À Ã Ä Ç È É Ô Õ÷øùú Ö × Ø Ù Ú Û Ü Ý Þ ß à â*+,&'()2534 å © ª « ¬ ­ ® ² ´ ° ± È É"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthy ÔThe ‡ function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class `; 2 converts values to strings for output using the ¤ operation and adds a newline.aFor example, a program to print the first 20 integers and their powers of 2 could be written as: (main = print ([(n, 2^n) | n <- [0..19]]) è:Write a character to the standard output device (same as  ­ 6). é7Write a string to the standard output device (same as  ® 6). ê The same as  é, but adds a newline character. ë:Read a character from the standard input device (same as  ª  µ). ì5Read a line from the standard input device (same as  «  µ). íThe  íf operation returns all user input as a single string, which is read lazily as it is needed (same as  ¬  µ). îThe  î# function takes a function of type String->String³ as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device. ïThe  ïw function reads a file and returns the contents of the file as a string. The file is read lazily, on demand, as with  í. ðThe computation  ð file str function writes the string str, to the file file. ñThe computation  ñ file str function appends the string str, to the file file. Note that  ð and  ñU write a literal string to a file. To write a value of any printable type, as with  , use the ¤1 function to convert the value to a string first. >main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]]) òThe  ò function combines  ì and  ó. óThe  ó function is similar to . except that it signals parse failure to the †* monad instead of terminating the program. ô*The Unicode encoding of the current localeMThis is the initial locale encoding: if it has been subsequently changed by  d) this value will not reflect that change. õ Computation  õ hdlI indicates whether at least one item is available for input from handle hdl.This operation may fail with:K*% if the end of file has been reached. ö Computation  ö hdl t% writes the string representation of t given by the §, function to the file or channel managed by hdl and appends a newline.This operation may fail with:K+ if the device is full; orK,4 if another system resource limit would be exceeded. ÷ ÷ name mode act opens a file using  ·5 and passes the resulting handle to the computation act+. The handle will be closed on exit from  ÷, whether by normal termination or by raising an exception. If closing the handle raises an exception, then this exception will be raised by  ÷& rather than any exception raised by act. ø ø name mode act opens a file using  ¹5 and passes the resulting handle to the computation act+. The handle will be closed on exit from  ø<, whether by normal termination or by raising an exception. úŠThe function creates a temporary file in ReadWrite mode. The created file isn't deleted automatically, so you need to delete it manually.XThe file is created with permissions such that only the current user can read/write it.ÿ<With some exceptions (see below), the file will be created securely in the sense that an attacker should not be able to cause openTempFile to overwrite another file on the filesystem using your credentials, by putting symbolic links (on Unix) in the place where the temporary file is to be created. On Unix the O_CREAT and O_EXCL7 flags are used to prevent this attack, but note that O_EXCL{ is sometimes not supported on NFS filesystems, so if you rely on this behaviour it is best to use local filesystems only. ûLike  ú), but opens the file in binary mode. See  ¹ for more comments. üLike  ú', but uses the default file permissions ýLike  û', but uses the default file permissions ú%Directory in which to create the fileÀFile name template. If the template is "foo.ext" then the created file will be "fooXXX.ext" where XXX is some random number. Note that this should not contain any path separator characters.j†01234ŠÚ÷øùú&'()*+,-./01234567 [ \ ] ^ _ ` a b c h i © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¹ È Ê Ë Ì Í Î Ï Ð Ñ Ò Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â å è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ýj† ùŠ1 µ6 ¶ ÷ ·01234 Ê ï ð ñ Ë Ì Í Î-./0 Ð Ü7 Ô Õ È Ö÷øùú × Ø Ù Ú Û Ý à Þ ß å © õ ª « Ï ¬ ­ ® ¯ ö î è é ê ë ì í ó ò ø ¹ á ° ² ³ ± ´ ú û ü ý Ñ ÒÚ [ \ ] ^ _ ` a b c ô h i â*+,2&'()534>?@AB TrustworthyÙ… dComputes the hash of a given file. This function loops over the handle, running in constant memory.úÒþÿ þ ÿ úÒ þ ÿþÿ a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable TrustworthySTé¨0+The fixed point of a monadic computation. 0 f executes the action fD only once, with the eventual output fed back as the input. Hence f! should not be strict, for then 0 f would diverge.cHMonads having fixed points with a 'knot-tying' semantics. Instances of c# should satisfy the following laws: purity0 (return . h) = return (Û h)left shrinking (or  tightening)0+ (\x -> a >>= \y -> f x y) = a >>= \y -> 0 (\x -> f x y)sliding0 ( - h . f) =  - h (0 (f . h)), for strict h.nesting0 (\x -> 0 (\y -> f x y)) = 0 (\x -> f x x)7This class is used in the translation of the recursive do% notation supported by GHC and Hugs.                c0Ûc0Ûc0q`(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology 2001 BSD-style (see the file LICENSE)ross@soi.city.ac.uk experimentalportable Trustworthy13456Kò@ 0Identity functor and monad. (a non-strict monad)      CThis instance would be equivalent to the derived instances of the   newtype if the   field were removed CThis instance would be equivalent to the derived instances of the   newtype if the   field were removed         (c) Ross Paterson 20024BSD-style (see the LICENSE file in the distribution)libraries@haskell.org provisionalportable Trustworthy1ö'2Lift a function to an arrow.3oSend the first component of the input through the argument arrow, and copy the rest unchanged to the output.5RFanin: Split the input between the two argument arrows and merge their outputs.UThe default definition may be overridden with a more efficient version if desired. -The 6Ž operator expresses computations in which an output value is fed back as input, although the computation occurs only once. It underlies the rec/ value recursion construct in arrow notation. 6# should satisfy the following laws:  extension6 (2 f) = 2 (\ b ->  (Û (\ (c,d) -> f (b,d))))left tightening6 (3 h >>> f) = h >>> 6 fright tightening6 (f >>> 3 h) = 6 f >>> hsliding6 (f >>> 2 (å *** k)) = 6 (2 (å *** k) >>> f) vanishing6 (6 f) = 6 (2 unassoc >>> f >>> 2 assoc) superposing = (6 f) = 6 (2 assoc >>>  = f >>> 2 unassoc)where 9assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c) .The  0 class is equivalent to W: any monad gives rise to a  9 arrow, and any instance of  0 defines a monad. 0lSome arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws: 3 (2 (\x -> 2 (\y -> (x,y)))) >>> 4 = å 3 (2 (g >>>)) >>> 4 =  = g >>> 4 3 (2 (>>> h)) >>> 4 = 4 >>> h*Such arrows are equivalent to monads (see  .). 1?Choice, for arrows that support it. This class underlies the if and case constructs in arrow notation.,Instances should satisfy the following laws:  2 (2 f) = 2 ( 2 f)  2 (f >>> g) =  2 f >>>  2 g f >>> 2 Ì = 2 Ì >>>  2 f  2 f >>> 2 (å +++ g) = 2 (å +++ g) >>>  2 f  2 ( 2 f) >>> 2 assocsum = 2 assocsum >>>  2 fwhere qassocsum (Left (Left x)) = Left x assocsum (Left (Right y)) = Right (Left y) assocsum (Right z) = Right (Right z)aThe other combinators have sensible default definitions, which may be overridden for efficiency. 2cFeed marked inputs through the argument arrow, passing the rest through unchanged to the output. 3A mirror image of  2.UThe default definition may be overridden with a more efficient version if desired. 4‡Split the input between the two argument arrows, retagging and merging their outputs. Note that this is in general not a functor.UThe default definition may be overridden with a more efficient version if desired. 5A monoid on arrows. 6'An associative operation with identity  8. 9Kleisli arrows of a monad. <The basic arrow class.,Instances should satisfy the following laws: 2 id = å 2 (f >>> g) = 2 f >>> 2 g 3 (2 f) = 2 (3 f) 3 (f >>> g) = 3 f >>> 3 g 3 f >>> 2  = 2  >>> f 3 f >>> 2 (å *** g) = 2 (å *** g) >>> 3 f 3 (3 f) >>> 2 assoc = 2 assoc >>> 3 fwhere assoc ((a,b),c) = (a,(b,c))aThe other combinators have sensible default definitions, which may be overridden for efficiency. =A mirror image of 3.UThe default definition may be overridden with a more efficient version if desired. >ySplit the input between the two argument arrows and combine their output. Note that this is in general not a functor.UThe default definition may be overridden with a more efficient version if desired. ?KFanout: send the input to both argument arrows and combine their output.UThe default definition may be overridden with a more efficient version if desired. @,The identity arrow, which plays the role of / in arrow notation. A$Precomposition with a pure function. B%Postcomposition with a pure function. C<Precomposition with a pure function (right-to-left variant). D=Postcomposition with a pure function (right-to-left variant). EAny instance of  0$ can be made into an instance of  1 by defining  2 =  E. F G H I J K L M N O P Q R S T1Beware that for many monads (those for which the ,* operation is strict) this instance will not3 satisfy the right-tightening law required by the  - class. U çè -6 . / 04 15 4 2 3 5 6 7 8 9 : ; <23 > ? = @ A B C D E <23 = > ? 9 : ; @ A Bèç C D 7 8 5 6 1 2 3 45 04 . / E -6 -6 . / 04 1 2 3 45 5 6 7 8 9 : ; <23 = > ? 52 42 65 >3 ?3 A1 B1 C1 D1$Conor McBride and Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimentalportable Trustworthy6K>› VLists, but with an f functor based on zipping. _ One or none. ` a b c d e f 3f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN V (zipWithN f xs1 ... xsN)where zipWithN refers to the zipWith% function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example: Î(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}:fONP9835746;<=Ø V W X Y Z [ \ ] ^ _fON8P934567 \ ] ^ Y Z [ V W XØ:;<= _ V W X Y Z [ \ ] ^#$Conor McBride and Ross Paterson 20054BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimentalportable Trustworthy 0345;=STV}ÎhPFunctors representing data structures that can be traversed from left to right.A definition of  t! must satisfy the following laws:  naturalityt .  t f =  t (t . f)) for every applicative transformation tidentity t Identity = Identity composition t (Compose . . g . f) = Compose . . ( t g) .  t fA definition of  u! must satisfy the following laws:  naturalityt .  u =  u . . t) for every applicative transformation tidentity u . . Identity = Identity composition u . . Compose = Compose . .  u .  u where an applicative transformation is a function 1t :: (Applicative f, Applicative g) => f a -> g apreserving the f operations, i.e. t (O x) = O x t (x N y) = t x N t yand the identity functor Identity and composition of functors Compose are defined as ÿ* newtype Identity a = Identity a instance Functor Identity where fmap f (Identity x) = Identity (f x) instance Applicative Identity where pure x = Identity x Identity f <*> Identity x = Identity (f x) newtype Compose f g a = Compose (f (g a)) instance (Functor f, Functor g) => Functor (Compose f g) where fmap f (Compose x) = Compose (fmap (fmap f) x) instance (Applicative f, Applicative g) => Applicative (Compose f g) where pure x = Compose (pure (pure x)) Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)1(The naturality law is implied by parametricity.)Instances are similar to Y, e.g. given a data type 7data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)a suitable instance would be ²instance Traversable Tree where traverse f Empty = pure Empty traverse f (Leaf x) = Leaf <$> f x traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r:This is suitable even for abstract types, as the laws for N imply a form of associativity.6The superclass instances should satisfy the following:In the Y instance, .N should be equivalent to traversal with the identity applicative functor ( |).In the g instance, ".P should be equivalent to traversal with a constant applicative functor ( }). tŸMap each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see "/. u„Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see "0. v¦Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see "1. wˆEvaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see "2. x x is  tI with its arguments flipped. For a version that ignores the results see "3. y y is  vI with its arguments flipped. For a version that ignores the results see "4. zThe  z( function behaves like a combination of . and foldlÀ; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure. {The  {( function behaves like a combination of . and foldrÀ; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure. |)This function may be used as a value for . in a Y instance, provided that  t is defined. (Using  | with a h instance defined only by  u$ will result in infinite recursion.)  | f "a   .  t (  . f) })This function may be used as a value for ". in a g instance.  } f "a  .  t ( . f) ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ h v w t u x y z { | } h t u v w x y z { | }h t u v wr"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthy†0 ›The  ›& function takes two lists and returns Êy if all the elements of the first list occur, in order, in the second. The elements do not have to occur consecutively. › x y is equivalent to ê x (R y).Examples5isSubsequenceOf "GHC" "The Glorious Haskell Compiler"True)isSubsequenceOf ['a','d'..'z'] ['a'..'z']True!isSubsequenceOf [1..10] [10,9..0]Falsetêìëîíåáæäãéètuvwx~‚ƒ…†‰Š‹ŒŽ‘’“”›žŸ ¡¢ !#$%&'()*+,-./0123478;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ùúûüýþÿ z { ›ttwvxuèé”123RSãäæ~áåùúûüýþíîë샂…† z {‰Š‹ŒW‘Ž’“NPQ%&' ›ê›4 !#$žABCDŸ EFGH¡¢IJKLXZY[(*,-/TV7)+M.0OU8ÿ;<=>?@s"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableUnsafeD œThe  œs function outputs the trace message from the IO monad. This sequences the output with respect to other IO actions. žThe  žt function outputs the trace message given as its first argument, before returning the second argument as its result.'For example, this returns the value of f x but first outputs the message. -trace ("calling f with x = " ++ show x) (f x)The  ž function should onlyÍ be used for debugging, or for monitoring execution. The function is not referentially transparent: its type indicates that it is a pure function but it has the side effect of outputting the trace message. ŸLike  ž2 but returns the message instead of a third value.  Like  ž , but uses ¤$ on the argument to convert it to a /.¡This makes it convenient for printing the values of interesting variables or expressions inside a function. For example here we print the value of the variables x and z: Af x y = traceShow (x, z) $ result where z = ... ... ¡Like   6 but returns the shown value instead of a third value. ¢Like  ž$ but returning unit in an arbitrary f3 context. Allows for convenient use in do-notation.Note that the application of  ¢ is not an action in the f context, as  œ is in the †H type. While the fresh bindings in the following example will force the  ¢* expressions to be reduced every time the do-block is executed, traceM "not crashed"^ would only be reduced once, and the message would only be printed once. If your monad is in MonadIO, liftIO . traceIO may be a better option. T... = do x <- ... traceM $ "x: " ++ show x y <- ... traceM $ "y: " ++ show y £Like  ¢ , but uses ¤$ on the argument to convert it to a /. D... = do x <- ... traceShowM $ x y <- ... traceShowM $ x + y ¤like  ž<, but additionally prints a call stack if one is available.fIn the current GHC implementation, the call stack is only available if the program was compiled with -prof ; otherwise  ¤ behaves exactly like  ž,. Entries in the call stack correspond to SCC+ annotations, so it is a good idea to use  -fprof-auto or -fprof-auto-calls& to add SCC annotations automatically. ¥The  ¥ function behaves like  ž~ with the difference that the message is emitted to the eventlog, if eventlog profiling is available and enabled at runtime.:It is suitable for use in pure code. In an IO context use  ¦ instead.¡Note that when using GHC's SMP runtime, it is possible (but rare) to get duplicate events emitted if two CPUs simultaneously evaluate the same thunk that uses  ¥. ¦The  ¦f function emits a message to the eventlog, if eventlog profiling is available and enabled at runtime. Compared to  ¥,  ¦7 sequences the event with respect to other IO actions. §The  §j function emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime. The Stringx is the name of the marker. The name is just used in the profiling tools to help you keep clear which marker is which.FThis function is suitable for use in pure code. In an IO context use  ¨ instead.¡Note that when using GHC's SMP runtime, it is possible (but rare) to get duplicate events emitted if two CPUs simultaneously evaluate the same thunk that uses  §. ¨The  ¨e function emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime. Compared to  §,  ¨7 sequences the event with respect to other IO actions. œ ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ ž Ÿ   ¡ ¤ œ ¢ £ ¥ ¦ § ¨"(c) The University of Glasgow 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthy0;=FKTǵenClass for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC). © (a ~ Char) context was introduced in 4.9.0.0 « e7/XYZ[/e7XZY[e7t"(c) The University of Glasgow 2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental6non-portable (local universal quantification in ReadP)Safe6ëj ¬A  ¬- represents the version of a software entity.An instance of SS is provided, which implements exact equality modulo reordering of the tags in the  ¯ field.An instance of [= is also provided, which gives lexicographic ordering on the  ®ÿ fields (i.e. 2.1 > 2.0, 1.2.3 > 1.2.2, etc.). This is expected to be sufficient for many uses, but note that you may need to use a more specific ordering for your versioning scheme. For example, some versioning schemes may include pre-releases which have tags "pre1", "pre2"·, and so on, and these would need to be taken into account when determining ordering. In some cases, date ordering may be more appropriate, so the application would have to look for date tags in the  ¯G field and compare those. The bottom line is, don't always assume that  and other [* operations are the right thing for every  ¬.sSimilarly, concrete representations of versions may differ. One possible concrete representation is provided (see  ° and  ±`), but depending on the application a different concrete representation may be more appropriate. ®ÿ†The numeric branch for this version. This reflects the fact that most software versions are tree-structured; there is a main trunk which is tagged with versions at various points (1,2,3...), and the first branch off the trunk after version 3 is 3.1, the second branch off the trunk after version 3 is 3.2, and so on. The tree can be branched arbitrarily, just by adding more digits.%We represent the branch as a list of x\, so version 3.2.1 becomes [3,2,1]. Lexicographic ordering (i.e. the default instance of [ for [Int]*) gives the natural ordering of branches. ¯¥A version can be tagged with an arbitrary list of strings. The interpretation of the list of tags is entirely dependent on the entity that this version applies to. °2Provides one possible concrete representation for  ¬. For a version with  ®  = [1,2,3] and  ¯ = ["tag1","tag2"], the output will be 1.2.3-tag1-tag2. ±0A parser for versions in the format produced by  °. ²Construct tag-less  ¬ ³ ´ ¬ ­ ® ¯ ° ± ² ¬ ­ ® ¯ ° ± ² ¬ ­ ® ¯ "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable Trustworthyô<< b is O () if b is Ê, and 4 if b is Å. ¸ This generalizes the list-based filter function. ¹,Left-to-right Kleisli composition of monads. º-Right-to-left Kleisli composition of monads. ( ¹), with the arguments flipped.6Note how this operator resembles function composition (I): q(.) :: (b -> c) -> (a -> b) -> a -> c (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c » » act repeats the action infinitely. ¼The  ¼¶ function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state-transforming monad. ½The  ½ function generalizes Ÿ# to arbitrary applicative functors. ¾ ¾ is the extension of  ½ which ignores the final result. ¿The  ¿ function is analogous to foldl?, except that its result is encapsulated in a monad. Note that  ¿P works from left-to-right over the list arguments. This could be an issue where (-)/ and the `folded function' are not commutative. " foldM f a1 [x1, x2, ..., xm]== P do a2 <- f a1 x1 a3 <- f a2 x2 ... f am xmKIf right-to-left evaluation is required, the input list should be reversed.Note:  ¿ is the same as ð ÀLike  ¿, but discards the result. Á Á n act performs the action n times, gathering the results. ÂLike  Á, but discards the result. ÃThe reverse of ?. ÄStrict version of Ø. ÅDirect 0 equivalent of filter filter = $(mfilter:: (a -> Bool) -> [a] -> [a] applicable to any 0, for example mfilter odd (Just 1) == Just 1 mfilter odd (Just 2) == Nothing*<MW,-/+Y. w v012>?@ABCDEÚóôöø y ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å*Y.W,-/+012 vó yô wö> ¹ º »ÚMø Å ¸ ¼ ½ ¾ ¿ À Á Â<? Ã@ABCDE Ä ¹1 º1 Ä4"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthy ¦ý89Q»¼R·¸¹º$%&'S(T !"#$%&'(UÂÃ#VÄÅÆÇÈÉ:W,-/+Y.:ZV"W*XY![)\ÊË];^     _½¾¿ÀÁ`£¥¤fONP9géèêàáãåæëìîíh t u v wrFGHtÅÊuvwx}ÈÉ€ÎÏЂ†‡ŽÌÍ,-./>GHIJKLMZhiktvwx‚…†‰Š‹ŒŽ‘’“”›žŸ ¡¢¦§¨©ªÎÏÐÑÒÓØkÎÑXYZ[óöùúûüýþƒ…ŠT è é ê ë ì í î ï ð ñ ò óÿÿtÅÊÈÉkŽÌÍ€ÎÏÐu/hiS([)R·¸¹º$%&'Q»¼x}wv‚‡ZV"W*XY!];VÄÅÆÇÈÉ:UÂÃ#T !"#$%&'(_½¾¿ÀÁ^     ZÎÏÒÓÐÑ89rFGHY.:ØfONP9W,-/+óö>gàáãåæèéêëìíîh t u v wGHIJLM,-.Ktwvxèé”ûüýþùú‚…†‰Š‹Œ‘Ž’“›žŸ ¡¢XZY[¦`£¤¥§¨©ªk\ÊËÎц è é ê ë ì í îŠ ï ð ñ ó òƒT…-(c) The University of Glasgow, CWI 2001--2015/BSD-style (see the file libraries/base/LICENSE)SafeDBC¿ÔÖ     ×@ABENR¿CRENÖ     ×ÔBBA@u"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe( Æv+(c) Lennart Augustsson and Bart Massey 20135BSD-style (see the file LICENSE in this distribution)Bart Massey <bart@cs.pdx.edu> provisionalportableSafe&'œ); ÇOType of a function that will parse modifier characters from the format string. ÈAThis is the type of a field formatter reified over its argument. É‘The "format parser" walks over argument-type-specific modifier characters to find the primary format character. This is the type of its result. ËAny modifiers found. ÌPrimary format character. ÍRest of the format string. Î$Description of field formatting for  á . See UNIX  å5(3) for a description of how field formatting works. ÐTotal width of the field. Ñ Secondary field width specifier. Ò)Kind of filling or padding to be done. Ó8Whether to insist on a plus sign for positive numbers. Ô`Indicates an "alternate format". See printf(3) for the details, which vary by argument spec. Õ6Characters that appeared immediately to the left of  Ö1 in the format and were accepted by the type's  â. Normally the empty string. ÖThe format character  å was invoked with.  á… should fail unless this character matches the type. It is normal to handle many different format characters for a single type. ×PHow to handle the sign of a numeric field. These are mutually exclusive, with  Ø taking precedence. ÚPWhether to left-adjust or zero-pad a field. These are mutually exclusive, with  Û taking precedence. ÝSThis class, with only the one instance, is used as a workaround for the fact that /A, as a concrete type, is not allowable as a typeclass instance.  Ý) is exported for backward-compatibility. Þ ß à Typeclass of  å-formattable values. The  ám method takes a value and a field format descriptor and either fails due to a bad descriptor or produces a ¦ as the result. The default  âC expects no modifiers: this is the normal case. Minimal instance:  á. á â ãThe  ã1 class provides the variable argument magic for  æE. Its implementation is intentionally not visible from this module. äThe  ä1 class provides the variable argument magic for  åž. Its implementation is intentionally not visible from this module. If you attempt to pass an argument of a type which is not an instance of this class to  å or  æ=, then the compiler will report it as a missing instance of  à. åfFormat a variable number of arguments with the C-style formatting string. The return value is either / or († a) (which should be († '()')., but Haskell's type system makes this hard).7The format string consists of ordinary characters and conversion specifications7, which specify how to format one of the arguments to  åD in the output string. A format specification is introduced by the %N character; this character can be self-escaped into the format string using %%ÿ1. A format specification ends with a /format character/ that provides the primary information about how to format the value. The rest of the conversion specification is optional. In order, one may have flag characters, a width specifier, a precision specifier, and type-specific modifier characters. Unlike C  printf(3), the formatting of this  åW is driven by the argument type; formatting is type specific. The types formatted by  å "out of the box" are:V types, including u/^ types å6 is also extensible to support other types: see below.6A conversion specification begins with the character %2, followed by zero or more of the following flags: ÿ - left adjust (default is right adjust) + always use a sign (+ or -) for signed conversions space leading space for positive numbers in signed conversions 0 pad with zeros rather than spaces # use an \"alternate form\": see belowWhen both flags are given, - overrides 0 and +3 overrides space. A negative width specifier in a *E conversion is treated as positive but implies the left adjust flag.@The "alternate form" for unsigned radix conversions is as in C  printf(3): ÿ %o prefix with a leading 0 if needed %x prefix with a leading 0x if nonzero %X prefix with a leading 0X if nonzero %b prefix with a leading 0b if nonzero %[eEfFgG] ensure that the number contains a decimal point3Any flags are followed optionally by a field width: D num field width * as num, but taken from argument listhThe field width is a minimum, not a maximum: it will be expanded as needed to avoid mutilating a value.6Any field width is followed optionally by a precision: W .num precision . same as .0 .* as num, but taken from argument list_Negative precision is taken as 0. The meaning of the precision depends on the conversion type. “ Integral minimum number of digits to show RealFloat number of digits after the decimal point String maximum number of charactersœThe precision for Integral types is accomplished by zero-padding. If both precision and zero-pad are given for an Integral field, the zero-pad is ignored.ÍAny precision is followed optionally for Integral types by a width modifier; the only use of this modifier being to set the implicit size of the operand for conversion of a negative operand to unsigned: N hh Int8 h Int16 l Int32 ll Int64 L Int64/The specification ends with a format character: ÿˆ c character Integral d decimal Integral o octal Integral x hexadecimal Integral X hexadecimal Integral b binary Integral u unsigned decimal Integral f floating point RealFloat F floating point RealFloat g general format float RealFloat G general format float RealFloat e exponent format float RealFloat E exponent format float RealFloat s string String v default format any typeóThe "%v" specifier is provided for all built-in types, and should be provided for user-defined type formatters as well. It picks a "best" representation for the given type. For the built-in types the "%v" specifier is converted as follows: u c Char u other unsigned Integral d other signed Integral g RealFloat s String¶Mismatch between the argument types and the format string, as well as any other syntactic or semantic errors in the format string, will cause an exception to be thrown at runtime.Note that the formatting for ^4 types is currently a bit different from that of C  printf(3), conforming instead to Þ, ß and à (and their alternate versions á and âÖ). This is hard to fix: the fixed versions would format in a backward-incompatible way. In any case the Haskell behavior is generally more sensible than the C behavior. A brief summary of some key differences:Haskell  å@ never uses the default "6-digit" precision used by C printf.Haskell  å` treats the "precision" specifier as indicating the number of digits after the decimal point.Haskell  å~ prints the exponent of e-format numbers without a gratuitous plus sign, and with the minimum possible number of digits.Haskell  å: will place a zero after a decimal point when possible.Examples q > printf "%d\n" (23::Int) 23 > printf "%s %s\n" "Hello" "World" Hello World > printf "%.2f\n" pi 3.14 æ Similar to  å+, except that output is via the specified 1$. The return type is restricted to († a). çRSubstitute a 'v' format character with the given default format character in the  ÎH. A convenience for user-implemented types, which should support "%v". èFormatter for u values. éFormatter for / values. êFormatter for x values. ëFormatter for } values. ìFormatter for ^ values. í Raises an ,6 with a printf-specific prefix on the message string. îCalls  í8 to indicate an unknown format letter for a given type. ïCalls  í1 to indicate that the format string ended early. ðCalls  íD to indicate that there is a missing argument in the argument list. ñCalls  íJ to indicate that there is a type error or similar in the given argument. ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ        + Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý ß Þ à â á ã ä å æ ç è é ê ë ì í î ï ð ñ+ å æ à á â È Î Ï Ð Ñ Ò Ó Ô Õ Ö Ú Û Ü × Ø Ù ç Ç É Ê Ë Ì Í é è ê ë ì î ï ð ñ í ä ã Ý Þ ß É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ãB äC>"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental non-portable Trustworthy«Æ A specialised version of g3, where the key and the value are the same object: 2mkWeakPtr key finalizer = mkWeak key key finalizer A specialised version of   , where the f© object returned is simply thrown away (however the finalizer will be remembered by the garbage collector, and will still be run when the key becomes unreachable).Note: adding a finalizer to a P  using  + won't work; use the specialised version P5$ instead. For discussion see the f type. . A specialised version of gD where the value is actually a pair of the key and value passed to  : =mkWeakPair key val finalizer = mkWeak key (key,val) finalizer:The advantage of this is that the key can be retrieved by h in addition to the value.fghi  fghi  w"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental non-portable Trustworthy0DÄ­ CAn abstract name for an object, that supports equality and hashing.)Stable names have the following property:If sn1 :: StableName and sn2 :: StableName and  sn1 == sn2 then sn1 and sn2 were created by calls to makeStableName on the same object.”The reverse is not necessarily true: if two stable names are not equal, then the objects they name may still be equal. Note in particular that   may return a different   after an object is evaluated.-Stable Names are similar to Stable Pointers (Foreign.StablePtr&), but differ in the following ways: There is no freeStableName operation, unlike Foreign.StablePtr[s. Stable names are reclaimed by the runtime system when they are no longer needed. There is no deRefStableNameÿ operation. You can't get back from a stable name to the original Haskell object. The reason for this is that the existence of a stable name for an object does not guarantee the existence of the object itself; it can still be garbage collected. Makes a  X for an arbitrary object. The object passed as the first argument is not evaluated by  .  Convert a   to an x. The x. returned is not necessarily unique; several  s may map to the same xI (in practice however, the chances of this are small, so the result of   makes a good hash key).  Equality on  > that does not require that the types of the arguments match.    Dl"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable TrustworthyÉ¡ /Triggers an immediate minor garbage collection. /Triggers an immediate major garbage collection. /Triggers an immediate major garbage collection. Ä Å Æ Ç       Ä Å Æ Çx"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafeÐ{ The version of  > with which the program was compiled or is being interpreted. 5The operating system on which the program is running. 9The machine architecture on which the program is running. XThe Haskell implementation with which the program was compiled or is being interpreted.        X"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable Trustworthyçt  Computation   code throws 9 code3. Normally this terminates the program, returning code to the program's caller.%On program termination, the standard 1s 6 and  ¶/ are flushed automatically; any other buffered 1Os need to be flushed manually, otherwise the buffered data will be discarded.FA program that fails in any other way is treated as if it had called  :. A program that terminates successfully without calling  , explicitly is treated as if it had called   :.As an 9 is not an ƒ,  % bypasses the error handling in the †% monad and cannot be intercepted by Ž from the Prelude. However it is a  SomeException,, and can be caught using the functions of Control.Exception4. This means that cleanup computations added with Lí (from Control.Exception ) are also executed properly on  .Note: in GHC,  q should be called from the main program thread in order to exit the process. When called from another thread,   will throw an  ExitExceptionI as normal, but the exception will not cause the process itself to exit. The computation   is equivalent to   (; exitfail) , where exitfail is implementation-dependent. The computation   is equivalent to   :*, It terminates the program successfully. Write given error message to  ¶ and terminate with  .9:;    9:;    6"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafeíÁE Reads the FilePath1 pointed to by the symbolic link and returns it.See readlink(2) 8Returns the absolute pathname of the current executable.aNote that for scripts and interactive sessions, this is the path to the interpreter (e.g. ghci.) y"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe  Computation  Z returns a list of the program's command line arguments (not including the program name).  Computation  3 returns the name of the program as it was invoked.ÿ!However, this is hard-to-impossible to implement on some non-Unix OSes, so instead, for maximum portability, we just return the leafname of the program as invoked. Even then there are some differences between platforms: on Windows, for example, a program invoked as foo is probably really FOO.EXE, and that is what   will return.  Computation   var0 returns the value of the environment variable var(. For the inverse, POSIX users can use 78.This computation may fail with:K90 if the environment variable does not exist. -Return the value of the environment variable var, or Nothing if there is no such value.'For POSIX users, this is equivalent to 7:. setEnv name value, sets the specified environment variable to value.2On Windows setting an environment variable to the  empty string€ removes that environment variable from the environment. For the sake of compatibility we adopt that behavior. In particular setEnv name "" has the same effect as  ! name iIf you don't care about Windows support and want to set an environment variable to the empty string use System.Posix.Env.setEnv from the unix package instead.Throws L; if name1 is the empty string or contains an equals sign. ! unsetEnv nameY removes the specified environment variable from the environment of the current process.Throws L; if name1 is the empty string or contains an equals sign. " " args act - while executing action act, have   return args. # # name act - while executing action act, have   return name. $ $0 retrieves the entire environment as a list of  (key,value) pairs.,If an environment entry does not contain an '=' character, the key is the whole entry and the value is the empty string.      ! " # $      ! " # $z(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafe#é %sDescribes whether an option takes an argument or not, and if so how the argument is injected into a value of type a. &no argument expected 'option requires argument (optional argument )Each  ) describes a single option.The arguments to  * are:list of short option characters*list of long option strings (without "--")argument descriptorexplanation of option for user +-What to do with options following non-options ,+no option processing after first non-option -*freely intersperse options and non-options .wrap non-options into options /Return a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument. 0pProcess 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  )):The actual command line arguments (presumably got from y<). 0j returns a triple consisting of the option arguments, a list of non-options, and a list of error messages. 1This is almost the same as  0’, 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. 2 3 4 % & ' ( ) * + , - . / 0 1 0 1 / + , - . ) * % & ' (FGHIJK % & ' ( ) * + , - .=Safe$ÍLMN>Safe%OP?Safe !'¡Q&Perform the given action to fill in a struct timespec;, returning the result of the action and the value of the timespec in picoseconds.RS{"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable Trustworthy .½ 5The  5” constant is the smallest measurable difference in CPU time that the implementation can record, and is given as an integral number of picoseconds. 6 Computation  6… returns the number of picoseconds CPU time used by the current program. The precision of this result is implementation-dependent. 5 6 6 5((c) Adam Gundry 2015-2016see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)Safe,>?AF4Çs0Constraint representing the fact that the field x belongs to the record type r and has field type aT. This will be solved automatically, but manual instances may be provided as well. 77Selector function to extract the field from the record.s 7s 7s 7'(c) Adam Gundry 2015-2016see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)None -;=>?FVh7p 8p 8p 8|"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental non-portable TrustworthyD@½ 9,An abstract unique object. Objects of type  9< may be compared for equality and ordering and hashed into x. :Creates a new object of type  9I. The value returned will not compare equal to any other value of type  9 returned by previous calls to  :-. There is no limit on the number of times  : may be called. ; Hashes a  9 into an x. Two  9Ks may hash to the same value, although in practice this is unlikely. The x! returned makes a good hash key. 9 : ; 9 : ; 9T;"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental$non-portable (uses Control.Monad.ST) TrustworthyL >Mutate the contents of an ².Be warned that  >I does not apply the function strictly. This means if the program calls  >ø many times, but seldomly uses the value, thunks will pile up in memory resulting in a space leak. This is a common mistake made when using an STRef as a counter. For example, the following will leak memory and likely produce a stack overflow: iprint $ runST $ do ref <- newSTRef 0 replicateM_ 1000000 $ modifySTRef ref (+1) readSTRef refTo avoid this problem, use  ? instead. ?Strict version of  >²³´µ > ?²³´µ > ?@"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional+non-portable (uses Control.Monad.ST.Strict)SafeNû²³´µ > ?-"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportableSafeV· @ @), applied to two real fractional numbers x and epsilon/, returns the simplest rational number within epsilon of x. A rational number y is said to be simpler than another y' ifX (Ë y) <= X (Ë y'), andÌ y <= Ì y'.QAny real interval contains a unique simplest rational; in particular, note that 0/1! is the simplest rational of all.‚ÊËÌ @‚ÊËÌ @ANone !W7UVBNone !WWX34BSD-style (see the LICENSE file in the distribution)libraries@haskell.org experimental not portable TrustworthyTY}‘’“‘’“ "(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgstableportable Trustworthy[ÆaÔÕÖ×aÔÕÖ×C"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental:non-portable (requires universal quantification for runST)Unsafe^ã ƒ­®¯°±‹Œ:"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental:non-portable (requires universal quantification for runST)Unsafeaþ®¯Œ®¯Œ."(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental:non-portable (requires universal quantification for runST) Trustworthye'ƒ­°±‹­±°ƒ‹·"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental:non-portable (requires universal quantification for runST) TrustworthyhXƒ­°±‹­±°ƒ‹D"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST)Safekiƒ­°±‹E"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST)UnsafeDQV…‚ A9The lazy state-transformer monad. A computation of type  A s a* transforms an internal state indexed by s, and returns a value of type a. The s parameter is either5an unstantiated type variable (inside invocations of  B), orƒ (inside invocations of  F).CIt serves to keep the internal states of different invocations of  B2 separate from each other and from invocations of  F.The , and -6 operations are not strict in the state. For example,  B5 (writeSTRef _|_ v >>= readSTRef _|_ >> return 2) = 2Y~This is a terrible hack to prevent a thunk from being entered twice. Simon Peyton Jones would very much like to be rid of it. BCReturn the value computed by a state transformer computation. The forall- ensures that the internal state used by the  A9 computation is inaccessible to the rest of the program. CoAllow the result of a state transformer computation to be used (lazily) inside the computation. Note that if f is strict,  C f = _|_. DConvert a strict  AA computation into a lazy one. The strict state thread passed to  DS is not performed until the result of the lazy state thread it returns is demanded. EConvert a lazy  A computation into a strict one. F=A monad transformer embedding lazy state transformers in the † monad. The ƒ: parameter indicates that the internal state used by the  A. computation is a special one supplied by the †= monad, and thus distinct from those used by invocations of  B.Z[ \]^ ƒ A B C D E F G H_` Aab~"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST)Unsafeˆ¯ G H G H}"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST) Trustworthy‹Äƒ A B C D E F A B C D Eƒ FF"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional:non-portable (requires universal quantification for runST) Trustworthyƒ A B C D E F A B C D Eƒ F"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental)non-portable (uses Control.Monad.ST.Lazy)Safe‘â² I J K L² I J K LG"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportableSafe”+W,-/+Y.:Y.:W,-/+€a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)R.Paterson@city.ac.uk experimentalportableSafeœÕ MMonads in which †e computations may be embedded. Any monad built by applying a sequence of monad transformers to the †) monad will be an instance of this class.>Instances should satisfy the following laws, which state that  N is a transformer of monads:  N . / = /  N (m >>= f) =  N m >>= ( N . f) NLift a computation from the † monad. O  M N M N M N Trustworthy"#ÓE8 PEStatistics about memory usage and the garbage collector. Apart from  X and  Y6 all are cumulative values since the program started. RTotal number of bytes allocated SJNumber of garbage collections performed (any generation, major and minor) T(Maximum number of live bytes seen so far UWNumber of byte usage samples taken, or equivalently the number of major GCs performed. V1Sum of all byte usage samples, can be used with  Uc to calculate averages with arbitrary weighting (if you are sampling this record multiple times). W Number of bytes copied during GC X4Number of live bytes at the end of the last major GC Y$Current number of bytes lost to slop Z;Maximum number of bytes lost to slop at any one time so far [%Maximum number of megabytes allocated \Number of allocated megablocks ^VWall clock time spent running mutator threads. This does not include initialization. _CPU time spent running GC ` Wall clock time spent running GC a*Total CPU time elapsed since program start b)Total wall clock time elapsed since start crNumber of bytes copied during GC, minus space held by mutable lists held by the capabilities. Can be used with  d7 to determine how well parallel GC utilized all cores. d[Sum of number of bytes copied each GC by the most active GC thread each GC. The ratio of  c divided by  di approaches 1 for a maximally sequential run and approaches the number of threads (set by the RTS flag -N) for a maximally parallel run. eBTime values from the RTS, using a fixed resolution of nanoseconds. f9Statistics about a single GC. This is a mirror of the C struct GCDetails in RtsAPI.h, with the field prefixed with gc_ to avoid collisions with  u. h The generation number of this GC i!Number of threads used in this GC j/Number of bytes allocated since the previous GC kFTotal amount of live data in the heap (incliudes large + compact data) l*Total amount of live data in large objects m,Total amount of live data in compact regions n$Total amount of slop (wasted memory) o(Total amount of memory in use by the RTS p*Total amount of data copied during this GC q?In parallel GC, the max amount of data copied by any one thread r1The time elapsed during synchronisation before GC s"The CPU time used during GC itself t!The time elapsed during GC itself u ^Statistics about runtime activity since the start of the program. This is a mirror of the C struct RTSStats in RtsAPI.h wTotal number of GCs x-Total number of major (oldest generation) GCs yTotal bytes allocated z=Maximum live data (including large objects + compact regions) {"Maximum live data in large objects |$Maximum live data in compact regions } Maximum slop ~ Maximum memory in use by the RTS |Sum of live bytes across all major GCs. Divided by major_gcs gives the average live data over the lifetime of the program. €"Sum of copied_bytes across all GCs +Sum of copied_bytes across all parallel GCs ‚3Sum of par_max_copied_bytes across all parallel GCs ƒ"Total CPU time used by the mutator „&Total elapsed time used by the mutator …Total CPU time used by the GC †!Total elapsed time used by the GC ‡#Total CPU time (at the previous GC) ˆ'Total elapsed time (at the previous GC) ‰ Details about the most recent GC Š 1Returns whether GC stats have been enabled (with +RTS -T, for example). ŒžRetrieves garbage collection and memory statistics as of the last garbage collection. If you would like your statistics as recent as possible, first run a lH.> 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 { | } ~  € ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ > u v w x y z { | } ~  € ‚ ƒ „ … † ‡ ˆ ‰ f g h i j k l m n o p q r s t e ‹ Š P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d Œ  P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d f g h i j k l m n o p q r s t u v w x y z { | } ~  € ‚ ƒ „ … † ‡ ˆ ‰‚None"#ï2 ” Parameters of the runtime system Ÿ$Parameters pertaining to parallelism «-Parameters pertaining to ticky-ticky profiler ¯&Parameters pertaining to event tracing ²show timestamp in stderr output ³trace scheduler events ´trace GC events µ&trace spark events by a sampled method ¶"trace spark events 100% accurately ·-trace user events (emitted from Haskell code) ¸Is event tracing enabled? ¹ no tracing º$send tracing events to the event log »send tracing events to stderr ¼&Parameters of the cost-center profiler ¿time between samples Àticks between samples (derived) Ì,What sort of heap profile are we collecting? Õ2Parameters pertaining to the cost-center profiler. Ú-Should the RTS produce a cost-center summary? àJFlags to control debugging output & extra checking in various subsystems. âs ãi äw åG æg çb èS ét êp ël the object linker ìa ím îz# stack squeezing & lazy blackholing ïc coverage ðr ñMiscellaneous parameters ö:address to ask the OS for memory for the linker, 0 ==> off ÷'Parameters concerning context switching û$Parameters of the garbage collector.True  = "compact all the time"Duse "mostly mark-sweep" instead of copying for the oldest generation address to ask the OS for memory^Should we produce a summary of the garbage collector statistics after the program has exited?Time is defined as a  StgWord64 in  stg/Types.hcGRead a NUL terminated string. Return Nothing in case of a NULL pointer.)*+,• ” • – — ˜ ™ š › œ ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á ï ì ä æ â ã å ç è é ê ë í î ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ      !"#$%&'(• ” • – — ˜ ™ š › œ ž û ü ý þ ÿ      ÷ ø ù ú ñ ò ó ô õ ö à á â ã ä å æ ç è é ê ë ì í î ï ð Ú Û Ü Ý Þ ß Õ Ö × Ø Ù Ì Í Î Ï Ð Ñ Ò Ó Ô ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë ¸ ¹ º » ¯ ° ± ² ³ ´ µ ¶ · « ¬ ­ ® Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª "#$%&'(! ” • – — ˜ ™ š › œ ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ     ƒ'(c) The University of Glasgow 2013-2015see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)None^ðd&A LibdwSession from the runtime systeme An address; The state of the execution stackfA chunk of backtrace frames<7Location information about an address from a backtrace.A*A location in the original program source.F#How many stack frames in the given ;gUReturn a list of the chunks of a backtrace, from the outer-most to inner-most chunk.hUnpack the given < in the Haskell representationiThe size in bytes of a iG!List the frames of a stack trace.HGet an execution stack.IFree the cached debug data.JRender a stacktrace as a stringj Render a < as a string;<=>?@ABCDEFGHIJ<=>?@ABCDE;GFHJI;kflmno<=>?@ABCDE„'(c) The University of Glasgow 2013-2015see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)NoneØK1Get a trace of the current execution stack state.Returns Nothing8 if stack trace support isn't available on host machine.LAGet a string representation of the current execution stack state. <=>?@ABCDEKL <=>?@ABCDEKLs(c) Nils Schweinsberg 2011, (c) George Giorgidze 2011 (c) University Tuebingen 2011/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafeSTMM! type class. Minimal definition: = or N"Instances should satisfy the laws: Naturality : =liftM (f *** g) (mzip ma mb) = mzip (liftM f ma) (liftM g mb)Information Preservation: LliftM (const ()) ma = liftM (const ()) mb ==> munzip (mzip ma mb) = (ma, mb)P Q R S T U VWXYZ[\]^MON=M=NO^]\[ZYXWVUTSRQPM=NO…(c) Ross Paterson 2013 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafeŒä\_ Lifting of the `# class to binary type constructors.` £? function for an application of the type constructor based on £ and ¥" functions for the argument types.a ¥? function for an application of the type constructor based on £ and ¥u functions for the argument types. The default implementation using standard list syntax is correct for most types.bLifting of the \# class to binary type constructors.Both c and e/ exist to match the interface provided in the \1 type class, but it is recommended to implement b instances using e as opposed to cC, since the former is more efficient than the latter. For example:  instance b T where e = ... f = ƒ 9For more information, refer to the documentation for the \ class. @since 4.9.0.0c Ê? function for an application of the type constructor based on Ê and Ë" functions for the argument types.d Ë? function for an application of the type constructor based on Ê and Ëu functions for the argument types. The default implementation using standard list syntax is correct for most types.e Ì? function for an application of the type constructor based on Ì and Í" functions for the argument types.f Í? function for an application of the type constructor based on Ì and Í" functions for the argument types.The default definition uses d. Instances that define e should also define f as ƒ.g Lifting of the [# class to binary type constructors.h Lift ( functions through the type constructor.ÌThe function will usually be applied to comparison functions, but the more general type ensures that the implementation uses them to compare elements of the first container with elements of the second.i Lifting of the S# class to binary type constructors.j 1Lift equality tests through the type constructor.ÊThe function will usually be applied to equality functions, but the more general type ensures that the implementation uses them to compare elements of the first container with elements of the second.k Lifting of the `" class to unary type constructors.l £? function for an application of the type constructor based on £ and ¥! functions for the argument type.m ¥? function for an application of the type constructor based on £ and ¥t functions for the argument type. The default implementation using standard list syntax is correct for most types.n Lifting of the \" class to unary type constructors.Both o and q/ exist to match the interface provided in the \1 type class, but it is recommended to implement n instances using q as opposed to oC, since the former is more efficient than the latter. For example:  instance n T where q = ... r = | 9For more information, refer to the documentation for the \ class.o Ê? function for an application of the type constructor based on Ê and Ë! functions for the argument type.p Ë? function for an application of the type constructor based on Ê and Ët functions for the argument type. The default implementation using standard list syntax is correct for most types.q Ì? function for an application of the type constructor based on Ì and Í! functions for the argument type.r Í? function for an application of the type constructor based on Ì and Í! functions for the argument type.The default definition uses p. Instances that define q should also define r as |.s Lifting of the [" class to unary type constructors.t Lift a ' function through the type constructor.ËThe function will usually be applied to a comparison function, but the more general type ensures that the implementation uses it to compare elements of the first container with elements of the second.u Lifting of the S" class to unary type constructors.v 3Lift an equality test through the type constructor.ÊThe function will usually be applied to an equality function, but the more general type ensures that the implementation uses it to compare elements of the first container with elements of the second.w Lift the standard (()' function through the type constructor.x Lift the standard ' function through the type constructor.y Lift the standard Ê and Ë) functions through the type constructor.z Lift the standard Ì and Í) functions through the type constructor.{ *A possible replacement definition for the p" method. This is only needed for n instances where r isn't defined as |.| *A possible replacement definition for the r method, defined using q.} Lift the standard £ and ¥) functions through the type constructor.~ Lift the standard (()' function through the type constructor. Lift the standard ' function through the type constructor.€ Lift the standard Ê' function through the type constructor. Lift the standard Ì' function through the type constructor.‚ *A possible replacement definition for the d" method. This is only needed for b instances where f isn't defined as ƒ.ƒ *A possible replacement definition for the f method, defined using e.„ Lift the standard £' function through the type constructor.… … p d€ is a parser for datatypes where each alternative begins with a data constructor. It parses the constructor and passes it to p=. Parsers for various constructors can be constructed with , Ž and , and combined with mappend from the Monoid class.† † p€ is a parser for datatypes where each alternative begins with a data constructor. It parses the constructor and passes it to p=. Parsers for various constructors can be constructed with ˆ and Š, and combined with '( | )' from the 3 class.‡ ‡ rp n c n'R matches the name of a unary data constructor and then parses its argument using rp.ˆ ˆ rp n c'R matches the name of a unary data constructor and then parses its argument using rp.‰ ‰ rp1 rp2 n c n'T matches the name of a binary data constructor and then parses its arguments using rp1 and rp2 respectively.Š Š rp1 rp2 n c'T matches the name of a binary data constructor and then parses its arguments using rp1 and rp2 respectively.‹ ‹ sp n d xK produces the string representation of a unary data constructor with name n and argument x, in precedence context d.Œ Œ sp1 sp2 n d x yL produces the string representation of a binary data constructor with name n and arguments x and y, in precedence context d.  n c n'R matches the name of a unary data constructor and then parses its argument using Ê.Ž Ž n c n'R matches the name of a unary data constructor and then parses its argument using y.  n c n'T matches the name of a binary data constructor and then parses its arguments using y.  n d xK produces the string representation of a unary data constructor with name n and argument x, in precedence context d.‘ ‘ n d xK produces the string representation of a unary data constructor with name n and argument x, in precedence context d.’ ’ n d x yL produces the string representation of a binary data constructor with name n and arguments x and y, in precedence context d.“ ” • – — ˜ ™ š › œ  ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º 4_`abcedfghijklmnoqprstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’4uvwstxnopqryz{|klm}ij~ghbcdef€‚ƒ_`a„…†‡ˆ‰Š‹ŒŽ‘’_`abcdefghijklmnopqrstuv†(C) 2008-2014 Edward Kmett, BSD-style (see the file LICENSE)libraries@haskell.org provisionalportableSafe »Formally, the class » represents a bifunctor from Hask -> Hask.WIntuitively it is a bifunctor where both the first and second arguments are covariant.You can define a » by either defining ¼ or by defining both ½ and ¾.If you supply ¼, you should ensure that: ¼ G G "a GIf you supply ½ and ¾ , ensure: ½ G "a G ¾ G "a G +If you supply both, you should also ensure: ¼ f g "a ½ f I ¾ gThese ensure by parametricity: ¼ (f I g) (h I i) "a ¼ f h I ¼ g i ½ (f I g) "a ½ f I ½ g ¾ (f I g) "a ¾ f I ¾ g ¼)Map over both arguments at the same time. ¼ f g "a ½ f I ¾ g½(Map covariantly over the first argument. ½ f "a ¼ f G¾)Map covariantly over the second argument. ¾ "a ¼ G¿ ÀÁÂÃÄÅÆÇ»½¾¼»¼½¾»¼½¾‡(C) 2011-2016 Edward Kmett BSD-style (see the file LICENSE)libraries@haskell.org provisionalportableSafeVíÅ.È ÈY identifies foldable structures with two different varieties of elements (as opposed to g:, which has one variety of element). Common examples are Ž and '(,)': ¤instance Bifoldable Either where bifoldMap f _ (Left a) = f a bifoldMap _ g (Right b) = g b instance Bifoldable (,) where bifoldr f g z (a, b) = f a (g b z) A minimal È definition consists of either Ê or Ëb. When defining more than this minimal set, one should ensure that the following identities hold: É "a Ê G G Ê f g "a Ë (G . f) (G . g) F Ë f g z t "a … (Ê (Endo . f) (Endo . g) t) z If the type is also a  Bifunctor instance, it should satisfy: ('bifoldMap' f g "a 'bifold' . 'bimap' f gwhich implies that ;'bifoldMap' f g . 'bimap' h i "a 'bifoldMap' (f . h) (g . i)É 4Combines the elements of a structure using a monoid. É "a Ê G GÊ UCombines the elements of a structure, given ways of mapping them to a common monoid. Ê f g "a Ë (G . f) (G . g) FË cCombines the elements of a structure in a right associative manner. Given a hypothetical function %toEitherList :: p a b -> [Either a b]U yielding a list of all elements of a structure in order, the following would hold: Ë f g z "a á ( f g) z . toEitherListÌ aCombines the elments of a structure in a left associative manner. Given a hypothetical function %toEitherList :: p a b -> [Either a b]T yielding a list of all elements of a structure in order, the following would hold: Ì f g z "a ã (acc -> " (f acc) (g acc)) z . toEitherListHNote that if you want an efficient left-fold, you probably want to use Ð instead of Ì’. The reason is that the latter does not force the "inner" results, resulting in a thunk chain which then must be evaluated from the outside-in.Í As ËD, but strict in the result of the reduction functions at each step.Î  A variant of ËN that has no base case, and thus may only be applied to non-empty structures.Ï 2Right associative monadic bifold over a structure.Ð As ÌD, but strict in the result of the reduction functions at each step.ÿ This ensures that each step of the bifold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single, monolithic result (e.g., Ý).Ñ  A variant of ÌN that has no base case, and thus may only be applied to non-empty structures.Ò 1Left associative monadic bifold over a structure.Ó ²Map each element of a structure using one of two actions, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see ˆI.Ô As Óf, but with the structure as the primary argument. For a version that doesn't ignore the results, see ˆJ.,> bifor_ ('a', "bc") print (print . reverse)'a'"cb"Õ  Alias for Ó.Ö  Alias for Ô.×  Alias for Ø.Ø ‡Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results, see ˆK.Ù 1The sum of a collection of actions, generalizing ß.Ú  Alias for Ù.Û ACollects the list of elements of a structure, from left to right.Ü $Test whether the structure is empty.Ý 4Returns the size/length of a finite structure as an x.Þ (Does the element occur in the structure?ß AReduces a structure of lists to the concatenation of those lists.à -The largest element of a non-empty structure.á +The least element of a non-empty structure.â The â9 function computes the sum of the numbers of a structure.ã The ã> function computes the product of the numbers of a structure.ä vGiven a means of mapping the elements of a structure to lists, computes the concatenation of all such lists in order.å åI returns the conjunction of a container of Bools. For the result to be Ê , the container must be finite; Å, however, results from a Å& value finitely far from the left end.æ æI returns the disjunction of a container of Bools. For the result to be Å , the container must be finite; Ê, however, results from a Ê& value finitely far from the left end.ç ^Determines whether any element of the structure satisfies its appropriate predicate argument.è _Determines whether all elements of the structure satisfy their appropriate predicate argument.é \The largest element of a non-empty structure with respect to the given comparison function.ê ZThe least element of a non-empty structure with respect to the given comparison function.ë ë is the negation of Þ.ì The ì{ function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or È if there is no such element.í î ï ð ñ ò ó ô õ %ÈËÊÉÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëì%ÈÉÊËÌÍÎÏÐÑÒÓÔÕÖÚ×ØÙÛÜÝÞàáâãßäåæçèéêëìÈÉÊË̈(C) 2011-2016 Edward Kmett BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable TrustworthyV"þö ö_ identifies bifunctorial data structures whose elements can be traversed in order, performing f or WQ actions at each element, and collecting a result structure with the same shape.As opposed to hZ data structures, which have one variety of element on which an action can be performed, ö6 data structures have two such varieties of elements.A definition of ÷! must satisfy the following laws:  naturality÷ (t . f) (t . g) "a t . ÷ f g) for every applicative transformation tidentity÷     "a   compositionCompose . . (÷ g1 g2) . ÷ f1 f2 "a  t (Compose . . g1 . f1) (Compose . . g2 . f2) where an applicative transformation is a function t :: (f f, f g) => f a -> g apreserving the f operations: t (O x) = O x t (f N x) = t f N t x and the identity functor   and composition functors Compose are defined as ÿnewtype Identity a = Identity { runIdentity :: a } instance Functor Identity where fmap f (Identity x) = Identity (f x) instance Applicative Identity where pure = Identity Identity f <*> Identity x = Identity (f x) newtype Compose f g a = Compose (f (g a)) instance (Functor f, Functor g) => Functor (Compose f g) where fmap f (Compose x) = Compose (fmap (fmap f) x) instance (Applicative f, Applicative g) => Applicative (Compose f g) where pure = Compose . pure . pure Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)Some simple examples are Ž and '(,)': Çinstance Bitraversable Either where bitraverse f _ (Left x) = Left <$> f x bitraverse _ g (Right y) = Right <$> g y instance Bitraversable (,) where bitraverse f g (x, y) = (,) <$> f x <*> g yö3 relates to its superclasses in the following ways: ¼ f g "a   . ÷ (  . f) (  . g) Ê f g =  . ÷ ( . f) ( . g) These are available as ÿ and  respectively.÷ ÀEvaluates the relevant functions at each element in the structure, running the action, and builds a new structure with the same shape, using the results produced from sequencing the actions. ÷ f g "a ø . ¼ f g,For a version that ignores the results, see Ó.ø  Alias for ú.ù  Alias for ÷.ú §Sequences all the actions in a structure, building a new structure with the same shape using the results of the actions. For a version that ignores the results, see Ø. ú "a ÷ G Gû û is ÷X with the structure as the first argument. For a version that ignores the results, see Ô.ü  Alias for û.ý The ý( function behaves like a combination of ¼ and ÌJ; it traverses a structure from left to right, threading a state of type aH and using the given actions to compute new elements for the structure.þ The þ( function behaves like a combination of ¼ and ÌJ; it traverses a structure from right to left, threading a state of type aH and using the given actions to compute new elements for the structure.ÿ A default definition of ¼ in terms of the ö operations. ÿ f g "a   . ÷ (  . f) (  . g) A default definition of Ê in terms of the ö operations.  f g "a  . ÷ ( . f) ( . g)          ö÷øùúûüýþÿ ö÷øúùûüýþÿö÷i Trustworthy#³ ¡ ¢ £ ¤ ¥ ¦ ‘ ’ “ ” • – — ˜ ™ š › œ ž Ÿ • ž ™ Ÿ ¤ ¥ ¦ – — ˜ ¡ ¢ £ š œ › ‘ ’ ” “j((c) The University of Glasgow, 1994-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions)Unsafe& M ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë î ï ð ñ Š ‹ Œ   ¡ ¢ £ ¤ ¥ ¦ § ¨M Á Â È É Ê Ë Ì Í Î Ï Ð Ñ Ô Ò Ó Ø × Ù Õ Ö Ü µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Ú Û Ý ´ § ¨ ¢ £ ¤ ¥ ¦ Ä Å Æ Ç ² ³ ß à á â ã ä å ° ± æ ç é è ê Þ ë ‹ Š Œ   ¡ ð ñ ï î ÃL((c) The University of Glasgow, 2001-2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions) Trustworthy D=Ôpp is wrapped around MN‰ (or whatever main is called in the program). It catches otherwise uncaught exceptions, and also flushes stdout/stderr before exiting.qq is wrapped around every foreign export and foreign import "wrapper"B to mop up any uncaught exceptions. Thus, the result of running XO_ in a foreign-exported function is the same as in the main thread: it terminates the program.rLike qÿ(, but in the event of an exception that causes an exit, we don't shut down the system cleanly, we just exit. This is useful in some cases, because the safe exit version will give other threads a chance to clean up first, which might shut down the system in a different way. For example, tryEmain = forkIO (runIO (exitWith (ExitFailure 1))) >> threadDelay 10000ØThis will sometimes exit with "interrupted" and code 0, because the main thread is given a chance to shut down when the child thread calls safeExit. There is a race to shut down between the main and child threads.s The same as q3, but for non-IO computations. Used for wrapping foreign export and foreign import "wrapper"D when these are used to export Haskell functions with non-IO types. p î ïqrstuv‰"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (concurrency)SafeG×  — is a quantity semaphore in which the resource is aqcuired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked   calls. The pattern . bracket_ (waitQSemN n) (signalQSemN n) (...),is safe; it never loses any of the resource.  Build a new  M with a supplied initial quantity. The initial quantity must be at least 0. 3Wait for the specified quantity to become available 7Signal that a given quantity is now available from the  .         wŠ"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (concurrency)SafeQ>— is a quantity semaphore in which the resource is aqcuired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked  calls. The pattern $ bracket_ waitQSem signalQSem (...)/is safe; it never loses a unit of the resource. Build a new M with a supplied initial quantity. The initial quantity must be at least 0.#Wait for a unit to become availableSignal that a unit of the  is availablex‹"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (concurrency) Trustworthy0dÒ < is an abstract type representing an unbounded FIFO channel.$Build and returns a new instance of .Write a value to a .Read the next value from the K. Blocks when the channel is empty. Since the read end of a channel is an [2, this operation inherits fairness guarantees of [Gs (e.g. threads blocked in this operation are woken up in FIFO order).Throws BlockedIndefinitelyOnMVarQ when the channel is empty and no other thread holds a reference to the channel. Duplicate a Ý: the duplicate channel begins empty, but data written to either channel from then on will be available from both. Hence this creates a kind of broadcast channel, where data written by anyone is seen by everyone else.C(Note that a duplicated channel is not equal to its original. So: fmap (c /=) $ dupChan c returns True for all c.)IPut a data item back onto a channel, where it will be the next item read.Returns Ê if the supplied  is empty.>Return a lazy list representing the contents of the supplied  , much like ¢.#Write an entire list of items to a .  yz{k"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (concurrency) TrustworthyDQV  Ê% if bound threads are supported. If rtsSupportsBoundThreads is Å,   will always return Å and both  and ! will fail.¹Fork a thread and call the supplied function when the thread is about to terminate, with an exception or a returned value. The function is called with asynchronous exceptions masked. aforkFinally action and_then = mask $ \restore -> forkIO $ try (restore action) >>= and_thenWThis function is useful for informing the parent when a child terminates, for example.Like  È*, this sparks off a new thread to run the †; computation passed as the first argument, and returns the  Á of the newly created thread. However,  creates a bound‰ thread, which is necessary if you need to call foreign (non-Haskell) libraries that make use of thread-local state, such as OpenGL (see Control.Concurrent#boundthreads).Using  instead of  ÈŠ makes no difference at all to the scheduling behaviour of the Haskell runtime system. It is a common misconception that you need to use  instead of  ÈÔ to avoid blocking all the Haskell threads when making a foreign call; this isn't the case. To allow foreign calls to be made without blocking all the Haskell threads (with GHC), it is only necessary to use the  -threadedU option when linking your program, and to make sure the foreign import is not marked unsafe.Like  É3, but the child thread is a bound thread, as with . Returns Ê if the calling thread is boundl, that is, if it is safe to use foreign libraries that rely on thread-local state from the calling thread.!Run the †H computation passed as the first argument. If the calling thread is not bound), a bound thread is created temporarily. runInBoundThread doesn't finish until the † computation finishes.UYou can wrap a series of foreign function calls that rely on thread-local state with runInBoundThreadH so that you can use them without knowing whether the current thread is bound."Run the †D computation passed as the first argument. If the calling thread is bound1, an unbound thread is created temporarily using  È. runInBoundThread doesn't finish until the † computation finishes.Use this function only¨ in the rare case that you have actually observed a performance loss due to the use of bound threads. A program that doesn't need its main thread to be bound and makes heavy@ use of concurrency (e.g. a web server), might want to wrap its main action in runInUnboundThread.ÅNote that exceptions which are thrown to the current thread are thrown in turn to the thread that is executing the given computation. This ensures there's always a way of killing the forked thread.#bBlock the current thread until data is available to read on the given file descriptor (GHC only).This will throw an ƒ if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with #, use  ¦.$\Block the current thread until data can be written to the given file descriptor (GHC only).This will throw an ƒ if the file descriptor was closed while this thread was blocked. To safely close a file descriptor that has been used with $, use  ¦.%ÄReturns an STM action that can be used to wait for data to read from a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.&ËReturns an STM action that can be used to wait until data can be written to a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.=[\]^_`abcd Á È É Ê Ë Í Î Ò Ó Ô Õ Û Ü ‚ ƒ „ … † ‡ ˆ ‰ §     !"#$%& Á Ô È É Ò Ó Ê Ë Í Î Û Õ §#$%& !" ÜŒ"(c) The University of Glasgow 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental non-portableSafe0¿!'Wrap an †$ computation to time out and return Nothing( in case no result is available within n microseconds (1/10^6F seconds). In case a result is available before the timeout expires, Just a is returned. A negative timeout interval means "wait indefinitely". When specifying long timeouts, be careful not to exceed maxBound :: Int.?The design of this combinator was guided by the objective that  timeout n f$ should behave exactly the same as f as long as f$ doesn't time out. This means that f has the same  Ô< it would have without the timeout wrapper. Any exceptions fP might throw cancel the timeout and propagate further up. It also possible for f7 to receive exceptions thrown to it by another thread.BA tricky implementation detail is the question of how to abort an IOÿ„ computation. This combinator relies on asynchronous exceptions internally. The technique works very well for computations executing inside of the Haskell runtime system, but it doesn't work at all for non-Haskell code. Foreign function calls, for example, cannot be timed out with this combinator simply because an arbitrary C function cannot receive asynchronous exceptions. When timeoutÿ is used to wrap an FFI call that blocks, no timeout event can be delivered until the FFI call returns, which pretty much negates the purpose of the combinator. In practice, however, this limitation is less severe than it may sound. Standard I/O functions like P, Q, Network.Socket.accept, or Rj appear to be blocking, but they really don't because the runtime system uses scheduling mechanisms like  select(2)u to perform asynchronous I/O, so it is possible to interrupt standard socket I/O or file I/O using this combinator.()''|}-(c) The University of Glasgow, CWI 2001--2004/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimental-non-portable (local universal quantification) Trustworthy&',-01;<=FQSTV?HrXThe X+ class comprehends a fundamental primitive <  for folding over constructor applications, say terms. This primitive can be instantiated in several ways to map over the immediate subterms of a term; see the gmap™ combinators later in this class. Indeed, a generic programmer does not necessarily need to use the ingenious gfoldl primitive but rather the intuitive gmap combinators. The <ÿ primitive is completed by means to query top-level constructors, to turn constructor representations into proper terms, and to list all possible datatype constructors. This completion allows us to serve generic programming scenarios like read, show, equality, term generation.The combinators B, E, G<, etc are all provided with default definitions in terms of <_, leaving open the opportunity to provide datatype-specific definitions. (The inclusion of the gmap! combinators as members of class Xk allows the programmer or the compiler to derive specialised, and maybe more efficient code per datatype. Note: < is more higher-order than the gmap` combinators. This is subject to ongoing benchmarking experiments. It might turn out that the gmap, combinators will be moved out of the class X.)$Conceptually, the definition of the gmap' combinators in terms of the primitive <$ requires the identification of the <Q function arguments. Technically, we also need to identify the type constructor cC for the construction of the result type from the folded term type.In the definition of gmapQx7 combinators, we use phantom type constructors for the c in the type of <w because the result type of a query does not involve the (polymorphic) type of the term argument. In the definition of C; we simply use the plain constant type constructor because <ÿJ is left-associative anyway and so it is readily suited to fold a left-associative binary operation over the immediate subterms. In the definition of gmapQr, extra effort is needed. We use a higher-order accumulation trick to mediate between left-associative constructor application vs. right-associative binary operation (e.g., (:)7). When the query is meant to compute a value of type r2, then the result type withing generic folding is r -> rQ. So the result of folding is a function to which we finally pass the right unit. With the -XDeriveDataTypeable+ option, GHC can generate instances of the X9 class automatically. For example, given the declaration 2data T a b = C1 a b | C2 deriving (Typeable, Data)3GHC will generate an instance that is equivalent to ÿÅinstance (Data a, Data b) => Data (T a b) where gfoldl k z (C1 a b) = z C1 `k` a `k` b gfoldl k z C2 = z C2 gunfold k z c = case constrIndex c of 1 -> k (k (z C1)) 2 -> z C2 toConstr (C1 _ _) = con_C1 toConstr C2 = con_C2 dataTypeOf _ = ty_T con_C1 = mkConstr ty_T "C1" [] Prefix con_C2 = mkConstr ty_T "C2" [] Prefix ty_T = mkDataType "Module.T" [con_C1, con_C2]?This is suitable for datatypes that are exported transparently.+Fixity of constructors.iUnique index for datatype constructors, counting from 1 in the order they are given in the program text./%Public representation of constructors4"Public representation of datatypes:ƒRepresentation of constructors. Note that equality on constructors with different types may not work -- i.e. the constructors for Å and È may compare equal.;eRepresentation of datatypes. A package of constructor representations with names of type and module.~1The type constructor used in definition of gmapMp1The type constructor used in definition of gmapQr€/Type constructor for adding counters to queries<=Left-associative fold operation for constructor applications. The type of <P is a headache, but operationally it is a simple generalisation of a list fold.The default definition for < is H GB, which is suitable for abstract datatypes with no substructures.="Unfolding constructor applications>ÒObtaining the constructor from a given datum. For proper terms, this is meant to be the top-level constructor. Primitive datatypes are here viewed as potentially infinite sets of values (i.e., constructors).?&The outer type constructor of the type@/Mediate types and unary type constructors. In X instances of the form T a, @ should be defined as a.The default definition is H È8, which is appropriate for non-unary type constructors.A0Mediate types and binary type constructors. In X instances of the form T a b, A should be defined as b.The default definition is H È9, which is appropriate for non-binary type constructors.B>A generic transformation that maps over the immediate subterms9The default definition instantiates the type constructor c in the type of <^ to an identity datatype constructor, using the isomorphism pair as injection and projection.C7A generic query with a left-associative binary operatorD8A generic query with a right-associative binary operatorEÀA generic query that processes the immediate subterms and returns a list of results. The list is given in the same order as originally specified in the declaration of the data constructors.F>A generic query that processes one child by index (zero-based)GFA generic monadic transformation that maps over the immediate subterms9The default definition instantiates the type constructor c in the type of <M to the monad datatype constructor, defining injection and projection using / and ,.H>Transformation of at least one immediate subterm does not failI4Transformation of one immediate subterm with successJBuild a term skeletonK4Build a term and use a generic function for subtermsLMonadic variation on KM.Gets the type constructor including the moduleN*Gets the public presentation of a datatypeO"Gets the datatype of a constructorP,Gets the public presentation of constructorsQ+Look up a constructor by its representationR Constructs an algebraic datatypeSConstructs a constructorT.Gets the constructors of an algebraic datatypeU—Gets the field labels of a constructor. The list of labels is returned in the same order as they were given in the original constructor declaration.V Gets the fixity of a constructorW!Gets the string for a constructorX!Lookup a constructor via a stringYTest for an algebraic typeZ<Gets the constructor for an index (algebraic datatypes only)[:Gets the index of a constructor (algebraic datatypes only)\;Gets the maximum constructor index of an algebraic datatype]Constructs the x type^Constructs the w type_Constructs the u type Helper for ], ^bMakes a constructor for u.c<Constructs a non-representation for a non-representable typed!Test for a non-representable typeeAGets the unqualified type constructor: drop *.*.*... before namefAGets the module of a type constructor: take *.*.*... before namegEquality of constructorshijklmnopqrstuvwxyz{|„ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’“”•–—˜™š› œ ž Ÿ ¡¢£¤¥¦§¨©ª«<¾defines how nonempty constructor applications are folded. It takes the folded tail of the constructor application and its head, i.e., an immediate subterm, and combines them in some way.mdefines how the empty constructor application is folded, like the neutral / start element for list folding.structure to be folded.(result, with a type defined in terms of a=, but variability is achieved by means of type constructor c0 for the construction of the actual result type.hX<=>?@ABECDFGHIbÔ¸¹º»ïð=>?@DSTUVWXYZ[\]^_`abcdefghijklmnop+,-./0123467589:;JKLMNOPQRSTUVWXYZ[\]^_`abcdef=X<=>?@ABCDEFGHI;R]^_cM456789NQYTZ\d:.+,-S`abO/0123PUV[WXefJKL X<=>?@ABCDEFGHI+,-/0123456789:‚ƒ„…†‡;ˆ‰Š~‹ŒŽ€"(c) The University of Glasgow 2002see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)Unsafe 1;=>?DFTXS The Å function uses the user supplied function which projects an element out of every list element in order to first sort the input list and then to form groups by equality on these projected elements>The >d class and its methods are intended to be used in conjunction with the OverloadedLists extension.?The ?# function constructs the structure l from the given list of Item l@The @\ function takes the input list's length as a hint. Its behaviour should be equivalent to ?5. The hint can be used to construct the structure l more efficiently compared to ?U. If the given hint does not equal to the input list's length the behaviour of @ is not specified.AThe A function extracts a list of Item l from the structure l.. It should satisfy fromList . toList = id.¬The ¬= type function returns the type of items of the structure l.±±^ ensures that all the elements of the list are identical and then returns that unique element²The ²m function sorts a list of elements using the user supplied function to project something out of each element´ 9Be aware that 'fromList . toList = id' only for unfrozen ¾ s, since A removes frozenness information.µ¶ÿÉfjmps >¬?@Ate7wxyzuÃ{vÄ|wÆ}xÇ~€‚ƒƒ„……†‡ˆ‰ŠŒ‡ËŽ‘Œçæ’“‘”íîïðñòóôõö÷ø•ùúûüýþ–ÿ»–¼š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëNOPQRS÷øÿ­®¯°±²³WxLJËwÆvÄuÃŒçæ°NOPQR÷øe7 »…”íîïðñòóôõö÷ø•ùúûüýþ–ÿÿ²±³­®¯S‘¼>¬?@A>¬?@A­®¯(C) 2014 I/O Tweagsee libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)NoneCDVzÏ ½A reference to a value of type a.¹:Miscelaneous information available for debugging purposes.º>Package key of the package where the static pointer is defined»6Name of the module where the static pointer is defined¼>Source location of the definition of the static pointer as a (Line, Column) pair.½2A class for things buildable from static pointers.¾ A key for  StaticPtrs' that can be serialized and used with Á.¿Dereferences a static pointer.ÀThe ¾' that can be used to look up the given ½.Á Looks up a ½ by its ¾.If the ½ is not found returns Nothing._This function is unsafe because the program behavior is undefined if the type of the returned ½! does not match the expected one.¹ of the given ½.ÃA list of all known keys.Ä ½¹Ñº»¼½K¾¿ÀÁÂý¿¾ÀÁ¹Ñº»¼ÂýK½¹Ñº»¼½KS(C) 2016 I/O Tweagsee libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC Extensions)None}3‘T#(c) The University of Glasgow, 2007see libraries/base/LICENSEcvs-ghc@haskell.orginternalnon-portable (GHC extensions) TrustworthyCQV}’“”•”•(C) 2008-2014 Edward Kmett/BSD-style (see the file libraries/base/LICENSE)Edward Kmett <ekmett@gmail.com> provisionalportableSafe016cˆT ÆUninhabited data typeÇSince Æb values logically don't exist, this witnesses the logical reasoning tool of "ex falso quodlibet".ÈIf Æ is uninhabited then any Y! that holds only values of type Æ is holding no values.ÉÊËÌ Reading a Æ- value is always a parse error, considering Æ7 as a data type with no constructors. | @since 4.8.0.0ÍÎÆÇÈÆÇÈŽe(C) 2011-2015 Edward Kmett, (C) 2010 Tony Morris, Oliver Taylor, Eelis van der Weegen BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable Trustworthy16FTãëFÑ %Non-empty (and non-strict) list type.ÓNumber of elements in Ñ list.Ô.Compute n-ary logic exclusive OR operation on Ñ list.ÕÕv produces a new stream by repeatedly applying the unfolding function to the seed value to produce an element of type b= and a new seed value. When the unfolding function returns È/ instead of a new seed value, the stream ends.ÖÖ( efficiently turns a normal list into a Ñ stream, producing È if the input is empty.××[ produces the first element of the stream, and a stream of the remaining elements, if any.ØThe Ø function is analogous to  Data.List's rU operation.Ù(Extract the first element of the stream.Ú.Extract the possibly-empty tail of the stream.Û'Extract the last element of the stream.Ü9Extract everything except the last element of the stream.Ý!Prepend an element to the stream.Þ Synonym for Ý.ßSort a stream.àConverts a normal list to a Ñ stream.'Raises an error if given an empty list.á.Convert a stream to a normal list efficiently.–"Lift list operations to work on a Ñ stream.BewareL: If the provided function returns an empty list, this will raise an error.âMap a function over a Ñ stream.ãThe ã function takes a stream xs) and returns all the finite prefixes of xs.äThe ä function takes a stream xs" and returns all the suffixes of xs.åå x xs inserts x into the last position in xs where it is still less than or equal to the next element. In particular, if the list is sorted beforehand, the result will also be sorted.ææ x sequences x one or more times.çç is similar to ãC, but returns a stream of successive reduced values from the left: Bscanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...] Note that $last (scanl f z xs) == foldl f z xs.èè is the right-to-left dual of ç . Note that $head (scanr f z xs) == foldr f z xs.éé is a variant of ç% that has no starting value argument: Dscanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...]êê is a variant of è% that has no starting value argument.ëB'intersperse x xs' alternates elements of the list with copies of x. ,intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]ìì f x= produces the infinite sequence of repeated applications of f to x. %iterate f x = x :| [f x, f (f x), ..]íí xs$ returns the infinite repetition of xs: )cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]îî a finite NonEmpty stream.ïï x= returns a constant stream, where all elements are equal to x.ðð n xs returns the first n elements of xs.ññ n xs drops the first n) elements off the front of the sequence xs.òò n xs, returns a pair consisting of the prefix of xs of length n< and the remaining stream immediately following this prefix. ['splitAt' n xs == ('take' n xs, 'drop' n xs) xs == ys ++ zs where (ys, zs) = 'splitAt' n xsóó p xs+ returns the longest prefix of the stream xs for which the predicate p holds.ôô p xs% returns the suffix remaining after ó p xs.õõ p xs returns the longest prefix of xs that satisfies p,, together with the remainder of the stream. _'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs) xs == ys ++ zs where (ys, zs) = 'span' p xsöThe ö p function is equivalent to õ (not . p).÷÷ p xs removes any elements from xs that do not satisfy p.øThe ø function takes a predicate p and a stream xsN, and returns a pair of lists. The first list corresponds to the elements of xs for which p3 holds; the second corresponds to the elements of xs for which p does not hold. 9'partition' p xs = ('filter' p xs, 'filter' (not . p) xs)ùThe ùæ function takes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements. For example, in list notation: f'group' $ 'cycle' "Mississippi" = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...úú operates like ù7, but uses the provided equality predicate instead of (.ûû operates like ù?, but uses the provided projection when comparing for equalityüü operates like û`, but sorts the list first so that each equivalence class has, at most, one list in the outputýý operates like ù], but uses the knowledge that its input is non-empty to produce guaranteed non-empty output.þþ is to ý as ú is to ù.ÿÿ is to ý as û is to ù is to ÿ as ü is to ûThe isPrefix function returns True2 if the first argument is a prefix of the second.xs !! n# returns the element of the stream xs at index n/. Note that the head of the stream has index 0.Beware8: a negative or out-of-bounds index will cause an error.The I function takes two streams and returns a stream of corresponding pairs.The  function generalizes p. Rather than tupling the elements, the elements are combined using the function passed as the first argument.The  function is the inverse of the  function.The  function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name , means 'essence'.) It is a special case of C, which allows the programmer to supply their own inequality test.The  function behaves just like O, except it uses a user-supplied equality predicate instead of the overloaded ( function. for Ñ, behaves the same as rV\ The rows/columns need not be the same length, in which case > transpose . transpose /= id   for Ñ, behaves the same as r¿   for Ñ, behaves the same as: sortBy . comparing               :ÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ  :ÑÒâëçèéê  ÓÙÚÛÜÝÞ×ØßîãäìïíÕåæðñòóôõö÷øùúûüýþÿàáÖÔÑÒÒ5Ý5(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)libraries@haskell.org provisionalportable Trustworthy ,167<FKSTVxdEAn associative operation. (a E b) E c = a E (b E c) If a is also a r we further require (E) = G q EThe class of semigroups (types with an associative binary operation). is effectively  with a better instance of r, built off of an underlying q instead of an underlying r.EIdeally, this type would not exist at all and we would just fix the r instance of !,Provide a Semigroup for an arbitrary Monoid.$Use  ($ a) to get the behavior of W from  Data.Monoid'Use  (' a) to get the behavior of X from  Data.Monoid.,, isn't itself a q0 in its own right, but it can be placed inside 1 and ." to compute an arg min or arg max.4Reduce a non-empty list with <>XThe default definition should be sufficient, but this can be overridden for efficiency.5Repeat a value n times.Given that this works on a qf it is allowed to fail if you request 0 or fewer repetitions, and the default definition will do so.hBy making this a member of the class, idempotent semigroups and monoids can upgrade this to execute in O(1) by picking stimes = stimesIdempotent or stimes = stimesIdempotentMonoid respectively.6A generalization of rY to an arbitrary q<. May fail to terminate for some values in some semigroups.7This is a valid definition of 5 for a r.!Unlike the default definition of 5D, it is defined for 0 and so it should be preferred where possible.8This is a valid definition of 5 for an idempotent r.When mappend x x = x<, this definition should be preferred, because it works in O(1) rather than O(log n)9This is a valid definition of 5 for an idempotent q.When  x <> x = x<, this definition should be preferred, because it works in O(1) rather than O(log n).:Repeat a value n times. ?mtimesDefault n a = a <> a <> ... <> a -- using <> (n-1) timesImplemented using 5 and F.%This is a suitable definition for an mtimes member of r.;Fold an  case-wise, just like k.<)This lets you use a difference list of a q as a r.= > ? @ 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 { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   7qE45rFGHwxyz{|}~€‚ƒ„…†‡ˆ !"#$%&'()*+,-./01236789:;<8qEE45798:123./0'()$%&!"#rFGH†‡ˆƒ„…€‚}~z{|wxy ;<6,-+*qEE45 !"#$%&'(),-./0123E6(c) Ross Paterson 2014 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe,16F ÅLifted sum of functors.È É Ê Ë Ì Í Î Ï Ð Ñ Ò ÅÆÇÅÆÇÅÆÇ(c) Ross Paterson 2010 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe,16F¦ÖLifted product of functors.Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è Ö×Ö×Öב(c) Ross Paterson 2010 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportable Trustworthy,16FV&7ìœRight-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.ï ð ñ ò ó ô õ ö ÷ ø ù ú û ìíîìíîìíîì9 í9 ’#(c) Ashley Yakeley 2005, 2006, 2009/BSD-style (see the file libraries/base/LICENSE)$Ashley Yakeley <ashley@semantic.org> experimentalportable TrustworthyV2ïÿ$resolution of 10^-12 = .000000000001 resolution of 10^-9 = .000000001resolution of 10^-6 = .000001resolution of 10^-3 = .001>resolution of 10^-2 = .01, useful for many monetary currencies resolution of 10^-1 = .1 /resolution of 1, this works the same as Integer,The type parameter should be an instance of  .generalisation of Æ to any instance of Realgeneralisation of É to any instance of Realgeneralisation of Ç to any instance of Real/First arg is whether to chop off trailing zeros !"#ÿ          ÿ “"(c) The University of Glasgow 2001/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalportable Trustworthy013456Fa&&Complex numbers are an algebraic type.For a complex number z, X z# is a number with the magnitude of z8, but oriented in the positive real direction, whereas Y z has the phase of z, but unit magnitude.The g and h( instances traverse the real part first.'Kforms a complex number from its real and imaginary rectangular components.(+Extracts the real part of a complex number.)0Extracts the imaginary part of a complex number.*"The conjugate of a complex number.+CForm a complex number from polar components of magnitude and phase.,, t# is a complex value with magnitude 1 and phase t (modulo 2*).- The function -Œ takes a complex number and returns a (magnitude, phase) pair in canonical form: the magnitude is nonnegative, and the phase in the range (-, ]2; if the magnitude is zero, then so is the phase...The nonnegative magnitude of a complex number./,The phase of a complex number, in the range (-, ]2. If the magnitude is zero, then so is the phase.0 1 2345 &'()*+,-./ &'()+,-./*&''6—Z—[—\—]—^_`abcdefghiªjªkªlÕmnop—q—r`st`su`sv—w—x`sy—z{—|`a}Ÿ~Ÿ½€¼¼‚¼ƒ¼„`…†`…‡Ÿˆ—‰—Š—‹—Œ—Ž‰‘’“”½•½–½—½˜ ™š›œžçŸç ¡¢—£—¤—¥”¦”§¨©—ª—«—¬—­¼®¼¯`…°Á±½²½³—´µ—¶Ÿ·`…¸Æ´½¹Áº½»³Ǿ¼ç½¾¿À—Á"Â#Ã$Ä$Å$Æ$Ç$È%É&Ê'ËÌ—Í(Î`ÏÐ`Ï`ÏÑ`ÏÒ`ÏÓÛËÛÌÛÍÛÎÔÕÖ×—™`ÏؽÙ½Ú`aÛÕÓ`ÏÜ`Ïš`ÏÝÙÏÙÐÙÑÙÒÉÖÉÞ2›`Ïß`aà`Ïá`Ïâ`Ïã`Ïä`Ïå`Ïæ$ç$è$é$ê$ë$ì$í$î$ï$ð$ñ$ò$ó$ô$õ$ö$÷$ø$ù$ú$û$ü$ý$þ$ÿ$`Ï`Ï%%â%%%&%&`Ï `Ï  ” ç çç&`Ï`Ï`Ï`Ï`Ï——`Ï`Ï22`Ï`Ï`Ï4” `Ï!`Ï"`Ï#`Ï$&%&&&'&($)$*$+$,$-$.$/$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—{—|—}—~——€——‚—ƒ—„—…—†—‡—ˆ—‰—Š—‹—-—Œ——Ž———‘—’—“—”—•—–———˜—™—š—›—œ—6ž7Ÿ7 ŸŸâŸ¡Ÿ¢Ÿ£ ÷ ¤ ¥ ¦ § ¨ © ª « ¬¡¡­¡®¯°±,²,³,´,µ,¶,·,¸,¹,ºª»ª¼ª½ª¾ª¿ªÀªÁªªêĪŪƪǪȪɪʪ˪̪ͪΪϪЪѪÒªYªÓªÔªÕªÖªתتÙªÚªÛªܪݪÞªߪàªáªâªãª䪘ªåªæªç³È³è³é³ê³ë³ì³í³î³ï³ð¶ñ¶ò¶ó¶ô¶õ¹ö¹÷¹ø¹ù5ú¼û¼ü¼»¼œ¼ý¼þ½ÿ½½½½½½½½½½ ½ ½ ½ ½ ½½½½½½½½¾¾¾¾   < <f<g<!="=#=$=%=&='=(=)=*=+=,=-=.=/=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ÁnopqÃrÃsÃtÃuÃvÃwÃxÃyÃzÃ{Ã|Ã}Ã~ÃÀÃÂÃÄÅÆÇÈÉÊËÃêÃŒÃÃŽÃÃÑÒÓÔÕÖ×ØÙÚÃßÛÜÃÞßàáâţŤťŦ?§?¨?©?ª?«?¬?­?®?¯?°?±?²?³?´?µ?¶?·?¸?¹?º?ƒ?»?¼?½?¾?¿?À?Á?Â?Ã?Ä?Å?Æ?Ç?È?É?Ê?Ë?Ì?Í?Î?Ï?Ð?Ñ?Ò?Ó?Ô@Õ@Ö@×@Ø@Ù@Ú@Û@©@ª@¬@­@«@µ@Ü@Ý@Þ@ß@à@á@â@ã@ä@åAæAçAA{AèAéAAæAêAëAìAíAîAïAðAñAòAóAôAõAöA÷AøAùAúAûƵÆüÆýÆþÆÿÆÆÆïÆÆÆÆÆ     ÉÞÉÖÉ×ÉÉÉÉÉÉÉÉÕÕÕ Õ!Ù"Ù#Ù$Ù%Ù&44'4(4)B*B+Û,Û-CÊC C.C/C0C1C2C3C4C5C6C7C8C9C:C;C<C=C>C?C@CACBCCCDCECFCGCHIJKLMNOPQRSTUVWXYÝZÝ[Ý\Ý]Ý^1_1_1`1`1Ô1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|D}D}D~D~DDD€D€DD‚DƒD„D„D…D…D†D†D‡D‡DˆDˆD‰D‰DŠDŠD‹D‹DŒDŒDDDŽDŽDDDDD‘D‘D’D’D“D“D”D”D•D•D–D–D—D—D˜D˜D™D™DšD›DœDDžDŸD D¡D¢D£D¤D¥D¦D§D¨D©DªD«D¬D­D®D¯D°D±D²D³D´DµD¶D·D¸D¹DºD»D¼D½D¾D¿DÀDÁDÂDÃDÄDÅDÆDÇDÈDÉDÊDËDÌDÍDÎDÏDÐDÑDÒDÓDÔDÕDÖD×DØDÙDÚDÛDÜDÝDÞDßDàDáDâDãDäDåDæDçDèDéDêDëDìDíDîDïDðDñDòDóDôDõDöD÷DøDùDúDûDüDýDþDÿDDDDDDDDDD 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@DADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQDRDSDTDUDVDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfDgDhDiDjDkDlDmDnDoDpDqDrDsDtDuDvDwDxDyDzD{D|D}D~DD€DD‚DƒD„D…D†D‡DˆD‰DŠD‹DŒDDŽDDD‘D’D“D”D•D–D—D˜D™DšD›DœDDžDŸD D¡D¢D£D¤D¥D¦D§D¨D©DªD«D¬D­D®D¯D°D±D²D³D´DµD¶D·D¸D¹DºD»D¼D½D¾D¿DÀDÁ/†/Â/Ã/Ä/Å/Æ/Ç/È/É/Ê/Ë/Ì/Í/Î/Ï/Ð/Ñ/Ò/Ó/Ô/Õ/Ö/×/Ø/Ù/Ú/Û/Ü/ÝEÞEßEàEàEáEâEÈEÉEãEäEåEæEçEèEéEêEëEìFíF’F”FîFïFðFñFòFóGôGôGõGõGöG÷GøGùGúGûGüGýGþGÿGGGG        2 2 2 2 22222222222))Ä))) à!à"à#à$à%à&à'à(à)à*à+à,à-à.à/à0à1à2à3à4à5àVà6à7à8à9à:à¬à­à«à¯à°à±à²à®à;à<à=à>à?à@àAàBàCàDàEàFàGàHàIàJàKàLàMàNà¿àOàUàPàQàRàSTHU%h%V%V%W%X%Y%Z%[%\%]%^&_&`&`&W&a&X&b&Y&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$XYYZWW[XX\]]^__`  abbcddeffg¢hijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼"½"."^"¾"Â"Ã"Ë"Ä"ž"À"Á"ß"Î"Ï"Æ"Ç"¿"À"/"3"1"4"0"2"Á"Â"j"â"Û"Ü"Ý"Þ"¬"­"à"%"Ã"Ä"Å"Æ"Ç"È"É"Ê"Ë"Ì"Í"Î"Ï"Ð"Ñ"Ò"Ó"Ô"Õ"Ö"×"Ø"Ù"Ú"Û"ÜIÝIÝIÞIßIàIáIâIãIäIåIæIçIèIéIêIëIìIíIîIïIðIñIòIóIôIõçöç÷çøçùçúç~çûçüçýçþçÿçççççççççç ç ç ç ç çççJJJJJJJJ J J JJJJJJJJJ J!JJJJ"J#J$J%J&J'J(è)è*è+è,è-è.è/è0è1èëè2è3è4èwè0è5è6è78;9é:é;é<é=é>é¸é?é@éééAéBéCééDéEéFðGðHðIðJñKñLñ ñMñNñ5ñOñPñQñRñSñTñUôVôóôWôXôYQZQ[Q\Q]Q^Q^Q_Q`QaQbQcQdQeQfQgQhQiQjQkQlQmQnQoQpQqQrQsQtQuQvQwQxQyQzQ{Q|Q}Q~QQ€QR‚RƒR„R…R†R†R‡RˆR‰RŠR‹RŒRRŽRRRR‘R’R“R”R•R–R—M˜M™MšM›MœMSžSŸS T¡T¢T£T¤T¥T¦T§T¨T©TªT«T’T¬T­T®T¯T°T±T²T³T´TµT¶T·T¸TT¹TºT»T¼T½T¾T¿TÀTÁTÂUÃU}UÄUÅUÆUÇUÈUÉUÊUËUÌÍÍÎÏÐÑÒÓÔÕÖû×ØÙÚWÛVÜÝÞßàáâãäåæçèèééêêëëììííîîïðñYòYóYôYõYöY÷YøYùYúYûZüZýZþZÿ[ [ [ [ [ [ [ [ [ [ [ [ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ] ] ] ] ] !] "^ #^ $^ %^ &^ '^_ _ò_ (_ )_ *__ +_ ,_ -_ ._ ` `` /` 0` 1` 2` 3` 4` 5` 6` 7aõaöa 8a 9a :a ;a <a =a >a ?a @a Aa Ba Ca Da Ea Fa Ga Ha Ia Ja Kb Lb Mb Nb Ob Pb Qb Rb Sc Tc Uc Vc Wc Lc Mc Nc Oc Pc Qc Sc Xc Yc Zc [c \c ]c ^c _c `c ac bc cc dc ec fc gc hc id jeVe5f kf kf lf mf nf of pf qf rf sf tf uf vf wf xf yf zf {f |f }f ~f f €f f ‚f ƒf „f …f †f ‡f ˆf ‰f Šf ‹f Œf f Žf f f ‘f ’f “f ”f •f –f —f ˜f ™f šf ›f œf f žf Ÿf  f ¡f ¢f £f ¤f ¥f ¦f §f ¨f ©f ªf «f ¬f ­f ®f ¯f °f ±f ²f ³f ´f µf ¶f ·f ¸f ¹f ºf »f ¼f ½f ¾f ¿f Àf Áf Âf Ãf Äf Åf Æf Çf Èf Éf Êf Ëf Ìf Íf Îf Ïf Ðf Ñf Ò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 ùh úh ûh üh ýh þh ÿh h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h !h "h #h $h %h &h 'h (h )h *h +h ,h -h .h /h 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 Kh Lh Mh Nh Oh Ph Qh Rh Sh Th Uh Vh Wh Xh Yh Zh [h \h ]h ^h _h `h ah bh ch dh eh fh gh hh ih jh kh lh mh nh oh ph qh rh sh th uh vh wh xh yh zh {h |h }h ~h h €h h ‚h ƒh „h …h †h ‡h ˆh ‰h Šh ‹h Œh h Žh h h ‘h ’h “h ”h •h –h —h ˜h ™h šh ›h œh h žh Ÿh  h ¡h ¢h £h ¤h ¥h ¦h §h ¨h ©h ªh «h ¬h ­h ®h ¯h °h ±h ²h ³h ´h µh ¶h ·h ¸h ¹h ºh »h ¼h ½h ¾h ¿h Àh Áh Âh Ãh Äh Åh Æh Çh Èh Éh Êh Ëh Ìh Íh Îh Ïh Ðh Ñh Òh Óh Ôh Õh Öh ×h Øh Ùh Úh Ûh Üh Ýh Þh ßh àh áh âh ãh äh åh æh çh èh éh êh ëh ìh íh îh ïh ðh ñh òh óh ôh õh öh ÷h øh ùh úh ûh üh ýh þh ÿh h h h h h h h h h h h h h h h h h h h h               ! "m #m #m $m $m %m &m 'm (m )m *m +m ,m -m .m /m 0m 1m 2m 2m 3mm 4mm 5mïmîm 6m 7m 8m 9m :m ;m <m =mmì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 j k k l l m m n n o o p p q q r s t u v wí x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ ŒK K ŽK K9K K+K*K ‘K,K ’K “K ”K •K –K —K ˜K ™K šK ›K œK K žK ŸK  K ¡K ¢K £K ¤K ¥K ¦K §K ¨K ©K ªK «K ¬K ­K ®K ¯L °L °L ±L ²L ³9 ´S SüSþS S S S S S S µS ¶S ·S ¸S ¹S ºS S 6 »6 ¼6 ½6 ¾6 ¿6 À6 Á6 Â6 Ã6 Ä6 Å6 Æ6 Ç È É• Ê!ü! Ë! Ìn Í8 Î8 U8 Ï8 V8 Ð8 Ñ8 Ò8 Ó8 Ôo Õo Öo ×o Øo Ù$ Ú$ Û$ Ü$ Ý$ Þ$ ß% à% á% â% ã% % ä% å% æ% ç& è& é' ê' ë' ì' í' î' ï' ð' ñ' ò)R) ó) ô)¢) õ) ö) ÷)Q) ø)P) ù) úW ûW üWÞW ýW þWýW ÿW W p p p p p p p p p V V V V V V V V VV V V V V V V V V V V V V V V V V !V "V #V $V %V &V 'V ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =B >B ?B @ A B C D E F G H I J K L M N O Pq Qq Qq Rq Sq Tq Uq Vq Wq Xq Yq Zq [q \q ]q ^q _q `q aq bq cq dq eq fq gq hq iq jq k l m m n o p q¬ r s t u v v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ ’ “ ” • – — ˜ ™º š › œ  ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­#á#å#ã#æ#â#ä#7#8# ®# ¯# °# ±# ²# ³# ´# µ# ¶# ·# ¸# ¹# º# »# ¼# ½# ¾# ¿# À# Á# Â# Ã# Ä# Å# Æ# Ç# È# É# Ê# Ë# Ìr Ís Îs Ïs Ðs Ñs Òs Ós Ôs Õs Ös ×s Øs Ùs Ú Û Ü Ýt Þt Þt ßt àt át ât ãt ät åt æt çt è é ê ë ì í î ï ð ñ ò ó ô õ öu ÷v øv ùv úv úv ûv üv ýv þv þv ÿv v v v v v v v v v v v v v v v v v v v v v v v v v v v v v v v v v !v "v #v $v %v &v 'v (v )v *v +v ,v -v .v /v 0v 1v 2v 3v 4v 5v 6> 7> 8> 9w :w ;w <w =w >l ?l @lHx Ax Bx Cx DXOX EX FX G6 Hy<y Iy:y Jy Ky Ly My Ny Oz Pz Qz Rz Sz Tz Uz Vz Wz Xz Yz Zz [z \z ]z ^z _{ `{ a( b' c| d| e| f| g| h; i; j- kEñEõEôE lE mE¸EòE?÷øù i€ n€ o€ p q 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ƒLƒMƒNƒOƒ ƒ ƒPƒQƒRƒSƒTƒUƒVƒW„X„YZ[\]^_`abcdefghijk…l…m…n…o…p…q…r…s…t…u…v…w…x…y…z…{…|…}…~……€……‚…ƒ…„………†…‡…ˆ…‰…Š…‹…Œ……Ž………‘…’…“…”…•…–…—…˜…™…š…›…œ……ž…Ÿ… …¡…¢…£…¤…¥…¦…§…¨…©…ª…«…¬…­…®…¯…°…±…²…³…´…µ…¶…·…¸…¹…º…»…¼…½…¾…¿…À…Á…Â…Ã…Ä…Å…Æ…džȆɆ† y†ʆˆ̆͆ΆφІцÒ‡Ó‡Ô‡Õ‡Ö‡ׇ؇Ù‡Ú‡Û‡܇݇Þ‡߇à‡á‡â‡ã‡ä‡å‡æ‡ç‡è‡é‡ê‡ë‡ì‡í‡î‡ï‡ð‡ñ‡ò‡ó‡ô‡õ‡ö‡÷‡ø‡ù‡ú‡û‡ü‡ý‡þ‡ÿ‡ˆˆIˆˆˆKˆJˆˆˆˆˆˆ ˆ ˆ ˆ ˆ ˆˆˆˆ‰‰‰‰ŠŠŠŠ‹‹‹‹‹‹‹ ‹!‹"‹#k$k%kk&k'k(k)k ìk ík îk ïŒ*Œ+Œ,Œ-wxy./012345?D6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|üý}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­® ׯ°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊŽËŽÌŽÁŽ)ŽÍŽÎŽ¼ŽUŽ»Ž½Ž¾Ž¿ŽÏŽÐŽNŽœŽžŽzŽJŽKŽ9ŽÑŽÈŽÌŽÉŽÍŽ4ŽÐŽYŽÚŽÑŽÕŽÖŽ׎ÓŽÔŽØŽÙŽkŽ6ŽHŽIŽ{ŽÒŽÓŽÔŽÕŽÖŽ(ŽãŽlŽ˜ŽæŽ+Ž,ŽVŽ¿Ž®Ž׎ØŽÙŽÚŽÛŽÜŽÝŽÞŽߎàŽáŽâŽãŽäŽåŽæŽçŽèŽé U UêëìíWW[XX\îïððññòóóôõö÷øùúû¹üýþÿ      !"#$%&'()*+,-./0123 G¦¥ ³Å¤45 F¯® ²Ä­6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZžŸ¡ ¢£[§¨ª©«¬\]^_`abcdefghij_kl µÇq‘Žmnop’“”]qg Hrsst ´Æu™˜—–tuvw‘›œ‘x‘x‘y‘z‘{‘|‘}‘~‘‘€‘‘‚‘ƒ‘„‘…‘†‘‡‘ˆ‘‰’Š’‹’Œ’’Ž’’’‘’’’“’”’•’–’—’˜’™’š’›’œ’’ž’Ÿ’ ’¡’¢’£’¤’¥’¦’§’¨’©’ª’«’¬’­’®’¯’°“±“²“³“´“µ“¶“·“¸“¹“º“»“¼“½“¾“¿“À“Á““ÓēœƓǓȓɔʔ˔̖͗Ηæ—ã—Ï—Зїҗӗԗ՗֗חؗٗڗۗܗݗޗߗà—á—â—ã—ä—å—æ—ç—è—é—ê—ë—ì—í—î`aï`ðñ`ðò`ðó`aô`…õ`…ö`a÷—ø—ù`aú—û`sü`aý`aþ`…ÿ`…`a`a`a`a`a`a`a`a`a `a `a `a `a `a`a`a`a`a`a`a`Ïš`a`a`a`a`a`a`a`a——`a`Ï `Ï `Ï!`a"`a#`a$`a%`a&`a'`a(`a)`a*`a+`a,`a-`a.`a/`a0`a1`a2`a3`a4`a5`a6`a7`a8`a9`a:`a;`a<`a=`a>`a?`a@`aA`Ï!`Ï"`ÏB`ÏC`ÏD`aE`aF`aG`aH`aI`aJ`aK`aL`aM`aN`aO`aP`aQ`aR`aS`aT`aU`aV`aW`aX`aY`aZ`a[`a\`a]`a^`a_`a``aa`ab`ac`ad`ae`af`ag`ah`ai`aj`ak`al`am`an`ao`ap`aq`ar`as`at`au`av`aw`ax`ay`az`a{`a|`a}`a~`a`a€`a`a‚`aƒ`a„`a…`a†`a‡`aˆ`a‰`aŠ`a‹`aŒ`a`aŽ`a`a`a‘`a’`a“`a”`a•`a–`a—`a˜`a™`aš`a›`aœ`a`až`aŸ`a `a¡`a¢`a£`a¤`a¥`a¦`a§`a¨`a©`aª`a«`a¬`a­`a®`a¯`a°`a±`a²`a³`a´`aµ`a¶`a·`a¸`a¹`aº`a»`a¼`a½`a¾`a¿`aÀ`aÁ`aÂ`aÃ`aÄ`aÅ`aÆ`aÇ`aÈ`aÉ`aÊ`aË`aÌ`aÍ`aÎ`aÏ`aÐ`aÑ`aÒ`aÓ`aÔ`aÕ`aÖ`a×`aØ`aÙ`aÚ`aÛ`aÜ`aÝ`aÞ`aß`aà`aá`aâ`aã`aä`aå`aæ`aç`aè`aé`aê`aë`aì`aí`aî`aï`að`añ`aò`aó`aô`aõ`aö`a÷`aø`aù`aú`aû`aü`aý`aþ`aÿ`a`a`a`a`a`a`a`a`a`a `a `a `a `a `a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a `a!`a"`a#`a$`a%`a&`a'`a(`a)`a*`a+`a,`a-`a.`a/`a0`a1`a2`a3`a4`a5`a6`a7`a8`a9`a:`a;`a<`a=`a>`a?`a@`aA`aB`aC`aD`aE`aF`aG`aH`aI`aJ`aK`aL`aM`aN`aO`aP`aQ`aR`aS`aT`aU`aV`aW`aX`aY`aZ`a[`a\`a]`a^`a_`a``aa`ab`ac`ad`ae`af`ag`ah`ai`aj`ak`al`am`an`ao`ap`aq`ar`as`at`au`av`aw`ax`ay`az`a{`a|`a}`a~`a`a€`a`a‚`aƒ`a„`a…`a†`a‡`aˆ`a‰`aŠ`a‹`aŒ`a`aŽ`a`a`a‘`a’`a“`a”`a•`a–`a—`a˜`a™`aš`a›`aœ`a`až`aŸ`a `a¡`a¢`a£`a¤`a¥`a¦`a§`a¨`a©`aª`a«`a¬`a­`a®`a¯`a°`a±`a²`a³`a´`aµ`a¶`a·`a¸`a¹`aº`a»`a¼`a½`a¾`a¿`aÀ`aÁ`aÂ`aÃ`aÄ`aÅ`aÆ`aÇ`aÈ`aÉ`aÊ`aË`aÌ`aÍ`aÎ`aÏ`aÐ`aÑ`aÒ`aÓ`aÔ`aÕ`aÖ`a×`aØ`aÙ`aÚ`aÛ`aÜ`aÝ`aÞ`aß`aà`aá`aâ`aã`aä`aå`aæ`aç`aè`aé`aê`aë`aì`aí`aî`aï`að`añ`aò`aó`aô`aõ`aö`a÷`aø`aù`aú`aû`aü`aý`aþ`aÿ`a`a`a`a`a`a`a`a`a`a `a `a `a `a `a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a `a!`a"`a#`a$`a%`a&`a'`a(`a)`a*`a+`a,`a-`a.`a/`a0`a1`a2`a3`a4`a5`a6`a7`a8`a9`a:`a;`a<`a=`a>`a?`a@`aA`aB`aC`aD`aE`aF`aG`aH`aI`aJ`aK`aL`aM`aN`aO`aP`aQ`aR`aS`aT`aU`aV`aW`aX`aY`aZ`a[`a\`a]`a^`a_`a``aa`ab`ac`ad`ae`af`ag`ah`ai`aj`ak`al`am`an`ao`ap`aq`ar`as`at`au`av`aw`ax`ay`az`a{`a|`a}`a~`a`a€`a`a‚`aƒ`a„`a…`a†`a‡`aˆ`a‰`aŠ`a‹`aŒ`a`aŽ`a`a`a‘`a’`a“`a”`a•`a–`a—`a˜`a™`aš`a›`aœ`a`až`aŸ`a `a¡`a¢`a£`a¤`a¥`a¦`a§`a¨`a©`aª`a«`a¬`a­`a®`a¯`a°`a±`a²`a³`a´`aµ`a¶`a·`a¸`a¹`aº`a»`a¼`a½`a¾`a¿`aÀ`aÁ`aÂ`aÃ`aÄ`aÅ`aÆ`aÇ`aÈ`aÉ`aÊ`aË`aÌ`aÍ`aÎ`aÏ`aÐ`aÑ`aÒ`aÓ`aÔ`aÕ`aÖ`a×`aØ`aÙ`aÚ`aÛ`aÜ`aÝ`aÞ`aß`aà`aá`aâ`aã`aä`aå`aæ`aç`aè`aé`aê`aë`aì`aí`aî`aï`að`añ`aò`aó`aô`aõ`aö`a÷`aø`aù`aú`aû`aü`aý`aþ`aÿ`a`a`a`a`a`a`a`a`a`a `a `a `a `a `a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a `a!`a"`a#`a$`a%`a&`a'`a(`a)`a*`a+`a,`a-`a.`a/`a0`a1`a2`a3`a4`a5`a6`a7`a8`a9`a:`a;`a<`a=`a>`a?`a@`aA`aB`aC`aD`aE`aF`aG`aH`aI`aJ`aK`aL`aM`aN`aO`aP`aQ`aR`aS`aT`aU`aV`aW`aX`aY`aZ`a[`a\`a]`a^`a_`a``aa`ab`ac`ad`ae`af`ag`ah`ai`aj`ak`al`am`an`ao`ap`aq`ar`as`at`au`av`aw`ax`ay`az`a{`a|`a}`a~`a`a€`a`a‚`aƒ`a„`a…`a†`a‡`aˆ`a‰`aŠ`a‹`aŒ`a`aŽ`a`a`a‘`a’`a“`a”`a•`a–`a—`a˜`a™`aš`a›`aœ`a`až`aŸ`a `a¡`a¢`a£`a¤`a¥`a¦`a§`a¨`a©`aª`a«`a¬`a­`a®`a¯`a°`a±`a²`a³`a´`aµ`a¶`a·`a¸`a¹`aº`a»`a¼`a½`a¾`a¿`aÀ`aÁ`aÂ`aÃ`aÄ`aÅ`aÆ`aÇ`aÈ`aÉ`aÊ`aË`aÌ`aÍ`aÎ`aÏ`aÐ`aÑ`aÒ`aÓ`aÔ`aÕ`aÖ`a×`aØ`aÙ`aÚ`aÛ`aÜ`aÝ`aÞ`aß`aà`aá`aâ`aã`aä`aå`aæ`aç`aè`aé`aê`aë`aì`aí`aî`aï`að`añ`aò`aó`aô`aõ`aö`a÷`aø`aù`aú`aû`aü`aý`aþ`aÿ`a`a`a`a`a`a`a`a`a`a `a `a `a `a `a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a `a!`a"`a#`a$`a%`a&`a'`a(`a)`a*`a+`a,`a-`a.`a/`a0`a1`a2`a3`a4`a5`a6`a7`a8`a9`a:`a;`a<`a=`a>`a?`a@`aA`aB`aC`aD`aE`aF`aG`aH`aI`aJ`aK`aL`aM`aN`aO`aP`aQ`aR`aS`aT`aU`aV`aW`aX`aY`aZ`a[`a\`a]`a^`a_`a``aa`ab`ac`ad`ae`af`ag`ah`ai`aj`ak`al`am`an`ao`ap`aq`…r`…s`…t`…u`…v`…w`…x`…y`…z`…{`…|`…}`…~`…`…€`…`…‚`…ƒ`ð„`ð…`φ—‡—ˆ—‰—Š—‹—Œ——Ž———‘—’ž“ž”ž”Ÿ•Ÿ–Ÿ—ÔÕ˜ÔÕ™ÔÕšÔÕ›ÔÕœÔÕÔÕžÔÕŸÔÕ ÔÕ¡ÔÕ¢ÔÕ£ÔÕ¤ÔÕ¥ÔÕ¦ÔÕ§ÔÕ¨ÔÕ©ÔÕªÔÕ«ÔÕ¬ÔÕ­ÔÕ®ÔÕ¯ÔÕ°ÔÕ±ÔÕ²ÔÕ³ÔÕ´ÔÕµÔÕ¶ÔÕ·ÔÕ¸ÔÕ¹ÔÕºÔÕ»ÔÕ¼ÔÕ½ÔÕ¾ÔÕ¿ÔÕÀÔÕÁÔÕ  Ó à÷¡Ä¡ŤƤǤȤɤʤˤ̤ͤǤΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥà¥á¥â¥ã¥ä¦å¦æ¦ç¦ç§è§è§ §é§§ºªê³ë³ì³í³î³ï³ð³ñ³ò³ó³ô³õ³ö³÷³ø³ù³ú³û³ü³ý³þ³ÿ³³³³³³³³³³ ³ ³ ¶ ¶ ¶¶¶¶¶¶ñ¶¹¹öºº dº dºººº eº¼¼¼¼¼¼¼¼ ¼!¼"¼#¼$¼%¼&¼'¼(¼)¼*¼+¼,¼-¼.¼/¼0¼1¼2¼3¼4¼5¼6¼7¼8¼9¼:¼;¼<¼=½>½?½@½A½B½C½D½E½F½G½H½I½J½K½L½M½N½O½P½Q½R½S½T½U½V½W½X½Y½Z½[½\½]½^½_¾`¾a¾b¾c¾d¾e¾f¾g¾h¾i¾j¾k¾l¾m¾n¾o¾p¾q¾r¾s¾t¾u¾v¾w¾x¾y¾z¾{¾|¾}¾~¾¾€¾¾‚¾ƒ¾„¾…¾`¾a¾†¾‡¾ˆ¾‰¾Š¾‹¾Œ¾¾Ž¾¾¾‘¾’¾“¾”¾•¾–¾—¾˜¾™¾š¾›¾œ¾¾ž¾Ÿ¾ ¾¡¾¢¾£¾¤¾¥¾¦À)ÀÀ§À¨À©ÀªÀ«À«À¬À­À­À®ÀóÀóÀôÀñÀñÀòÀ¯=°Á±Á²Á³Á´ÁµÁ¶Á·Á¸Á¹ÁºÁ»Á¼Á½Á¾Á¿ÁÀÁÁÁÂÁÃÁÄÁÅÁÆÁÇÁÈÁÉÁÊÁËÁÌÁÍÁÎÁÏÁÐÁÑÁÒÁÓÁÔÁÕÁ ÁÖÁ×ÁØÁÙÁÚÁÛÁÜÁÝÁÞÁßÁàÁáÁâÁãÁäÁåÁæÁçÁèÁéÁêÁëÁìÁíÁîÁïÁðÁñÁòÁóÁôÁõÁöÁ÷ÁøÁùÁúÁûÁüÁýÁþÁÿÁÁÁÁÁÁÁÁÁÁ Á Á Á Á ÁÁÁÁÁÁÂÂÂéÂÀÂáÂÂ9Â-•œžÂ Â!Â"Â#Â$Â%Â&€Â'Â'Â(Â)Â*Â+Â,Â-Â.Â/ÂÀÂ0¢Ã1Å£Å2?ð?3?4?5?6?7?8@3A™A9A:A;Æ<Æ=Æ>Æ?Æ@Æ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Ø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Ù{Ù|Ù}Ù~ÙÙ€ÙقكلمنهوىيًٌÙÙŽÙÙّْٕٖٜٓٔٗ٘ٙٚٛÙٟٞ٠١٢٣٤٥٦٧٨٩٪٫٬٭ٮٯڰ۱۲۳۴۵۶۷۸۹ۺۻۼ۽۾ۿÛÀÛÁÛÂÛÃÛÄÛÅÛÆÛÇÛÈÛÉÛÊÛËÛÌÛÍÛÎÛÏÛÐÛÑÛÒÛÓÛÔÛÕÛÖÛ×ÛØÛÙÛÚÛÛÛÜÛÝÛÞÛßÛàÛáÛâÛãÛäÛåÛæÛçÛèÛéÛêÛëÛìÛíÛîÛïÛðÛñÛòÛóÛôÛõÛöÛ÷ÛøÛùÛúÛûÛüÜýÜþÜÿÜÜÜÜÜÜÜÜÜÜ Ü Ü Ü Ü ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ !"ÔÕ#ÔÕ$%DD‚Dƒ/&à'à(à(%)%*%*%+%+&,&-&-&.&.$/$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çkç_èlèmènèoèpèqèrèsètèuèvèwèxèyézé{é|éíé xé}é~é oéé wð€ðGð›ññ‚ñƒñ„ñ…ñ†ñ‡ñˆñ‰ñŠñ‹ñŒññŽñ ññññ‘ñ’ø“øÚø-ø”øáø ø•ø–ø—ø–ø˜ø™øšø›ø›øœøø”ùžùŸù ùaù€ù ù¡ùÁù¢ù£ù¤ù¥ù¦ù§ù¨ù©ù4ù“ù&ùjùªù«ù«ùaú¬ú­ú®ú¯ú°ú±ú²ú¬ú³´µ¶·¸¹º»¼½¾¿ÀÁÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíî8ïðñòóôõêö÷øùúûüýþÿ     YZ¸`b Wbbbg ë !"#$%&'()*+,--./  0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š²³›œžŸ ¡¢£¤ ,¥¦0§§¨©©  ª«¬¬­®®¯°m± ² ³ ´SµS¶!·!¸!¹!º!»!¼!½!¾!¿!À!Á!Â!Ã!Ä!Å!Æ!Ç!È!É!Ê!Ë!Ì!Í!Î!Ç!Ï!Ð!Ñ!Ò!Ó!Ô!Õ!Ö!×!Ø!Ù!Ú!Û"Ü"0" " " "Ý"Ý"Þ"ß"à"á"á"â"ã#ê#ä#å#æ#ç#è#é#ê#ë#ì#í#î#ï#ð#ñ#ò#ó$ô$õ$ $ö$“$÷$ø$ù$ú$û$ü$Ù$ Ú$ý$þ$ÿ$$$$$$$%ú%ö%%“%Ù%%÷% % %ø% % %ù%û%ü% à%ý% %ÿ%%%%%%%%% â%% %%%& ñ& ò& ì& ð& í& î& ï&&&& ê& ë(Þ(2((((((2((( û(Û( ü(((( (!))"#$%&v'v(w :6)z*z+z,z-z.z/=0=1=2> a>3?4? a?3| dA aA3B aB3E5E KE6E EEEE7EñE8‚9ƒ:ƒ;ƒ<ƒ=ƒ>ƒ?ƒ@ƒKƒ<ƒAƒBƒCLDLELFLGLHLILJ‰Š‹K‹K‹ŒŒLMNO8PQRST9UVLWMXN SYTïTZT[T[ŽØ\baseControl.Exception.BaseGHC.Exts GHC.OldListPreludeForeign.StablePtr System.IO Data.Tuple Data.Bool Data.Function Data.CoerceData.EqData.Ord Control.Monad Data.FunctorControl.Monad.FixControl.Monad.Fail Control.Arrow Data.StringControl.Monad.ZipType.Reflection.Unsafe Data.DynamicData.Semigroup Data.Monoid GHC.Stack GHC.StaticPtr GHC.NaturalControl.ApplicativeNumeric Data.Data Text.Read Text.ShowData.IxType.Reflection Data.FoldableData.Traversable GHC.Generics GHC.TypeNats GHC.TypeLitsGHC.OverloadedLabels GHC.Records Data.CharData.IntNumeric.Natural Data.Maybe Data.RatioControl.Monad.ST.SafeData.Type.Equality Data.Word Foreign.Ptr Data.Either Data.KindGHC.Fingerprint.TypeGHC.Char GHC.Stack.CCS GHC.ProfilingControl.Concurrent.MVarSystem.IO.UnsafeControl.Monad.ST.Unsafe Data.STRefData.Type.Bool Data.BitsSystem.Mem.WeakText.ParserCombinators.ReadPText.ParserCombinators.ReadPrec Text.Read.LexGHC.FingerprintForeign.StorableForeign.C.TypesData.Type.CoercionControl.Category Data.Proxy Unsafe.CoerceData.Functor.Const Data.TypeableSystem.IO.ErrorControl.Exception Data.IORefForeign.ForeignPtr.SafeForeign.ForeignPtr.UnsafeForeign.ForeignPtr GHC.IO.BufferGHC.IO.Encoding.TypesGHC.IO.Encoding GHC.IO.DeviceGHC.IO.BufferedIO GHC.IO.HandleGHC.IO.Handle.FD System.ExitGHC.IO.Encoding.FailureGHC.IO.Encoding.UTF8GHC.IO.Encoding.UTF32GHC.IO.Encoding.UTF16GHC.IO.Encoding.Latin1Foreign.Marshal.ErrorForeign.Marshal.AllocForeign.Marshal.UtilsForeign.Marshal.Array GHC.ForeignForeign.C.StringForeign.Marshal.UnsafeForeign.ConcurrentForeign.C.ErrorForeign.Marshal.PoolSystem.Posix.Types GHC.EventGHC.ConcControl.Concurrent System.Mem GHC.Conc.SyncGHC.EnvironmentGHC.Conc.SignalGHC.IO.Handle.LockData.Functor.Identity Data.List Debug.Trace Data.VersionText.Show.Functions Text.PrintfSystem.Mem.StableName System.InfoSystem.EnvironmentSystem.Console.GetOptSystem.CPUTime Data.UniqueControl.Monad.ST.Lazy.SafeControl.Monad.ST.Lazy.UnsafeData.STRef.LazyControl.Monad.IO.Class GHC.Stats GHC.RTS.FlagsGHC.ExecutionStack.InternalGHC.ExecutionStackData.Functor.ClassesData.BifunctorData.BifoldableData.BitraversableControl.Concurrent.QSemNControl.Concurrent.QSemControl.Concurrent.ChanSystem.Timeout Data.VoidData.List.NonEmptyData.Functor.SumData.Functor.ProductData.Functor.Compose Data.Fixed Data.ComplexGHC.Stack.Types callStackGHC.ErrGHC.BasezipWithMaybeIOEitherfromEnumCharGHC.PArrGHC.NumGHC.MVar GHC.IO.Unsafe hGetContentsGHC.IO.Encoding.CodePageGHC.GHCiGHC.Float.RealFracMethodsGHC.Float.ConversionUtils GHC.Event.Arr GHC.ConstantsGHC.ConsoleHandlerGHC.List genericLength maximumBy minimumBygenericReplicate genericTake genericDropgenericSplitAt genericIndexGHC.ShowRead readsPrecGHC.STControl.Monad.STstToIO GHC.STRefGHC.Event.UniquetoEnumGHC.EnumGHC.RealGHC.ArrsortByData.Functor.Utils GHC.Float GHC.Event.PSQ GHC.UnicodeisLetterGHC.WeakGHC.ReadShow showsPrecGHC.PtrStorableInt8Int16Int32Int64Word8Word16Word32Word64 StablePtrfreeHaskellFunPtr GHC.StablePtrnullPtrGHC.PackGHC.WordGHC.Event.ClockGHC.Int GHC.Storable GHC.IO.IOModeopenFileisAlpha Data.OldListtraverseformapMforM sequenceAsequenceData.Typeable.Internal GHC.ExceptionGHC.IOControl ExceptionthrowTobracketforkIOWithUnmaskforkIO GHC.IORefGHC.ForeignPtrmallocwithForeignPtrForeign.ForeignPtr.Imp mallocArray mallocArray0MVarGHC.Event.IntTableGHC.Event.Array GHC.IOArrayHandle mkFileHandlemkHandleFromFDSystem.DirectorygetDirectoryContentsGHC.IO.Handle.TypeshFlush hLookAheadGHC.IO.Exception killThread GHC.CompactcompactsetAllocationCounterenableAllocationLimit ForeignPtrnewsizeOffree finalizerFreeallocawith Foreign.CForeign.Marshal.SafeForeign.Marshal Foreign.SafeForeignGHC.Event.InternalGHC.Event.KQueueSystem.Posix.InternalsGHC.Event.EPollforkOSmaskthrowIOunsafePerformIOtrycatchfixIOGHC.IO.Encoding.IconvGHC.IO.Handle.InternalsGHC.Event.PollGHC.Event.ControlGHC.Event.TimerManagerGHC.Event.ManagerGHC.Event.Thread GHC.Conc.IO GHC.IO.FDGHC.IO.Handle.Text isEOFError isFullErrorisPermissionErrorliftMfoldMap traverse_ sequenceA_mapM_ sequence_for_forM_addForeignPtrFinalizer!System.Environment.ExecutablePathSystem.Posix.EnvputEnvisDoesNotExistErrorgetEnv IOExceptiongetArgsSystem.CPUTime.UtilsSystem.CPUTime.Unsupported!System.CPUTime.Posix.ClockGetTimeData.STRef.StrictSystem.CPUTime.Posix.TimesSystem.CPUTime.Posix.RUsageControl.Monad.ST.ImpControl.Monad.ST.StrictControl.Monad.ST.Lazy.ImpControl.Monad.ST.LazyControl.Monad.Instances performGC bitraversebifor bisequenceGHC.TopHandlerMainmainexitWithhGetBufhPutBuf hWaitForInputGHC.StaticPtr.Internal GHC.Desugarunfoldr transposeLastFirstcycle absentErroraugment++buildfoldr recSelErrorghc-primGHC.PrimseqirrefutPatErrornoMethodBindingErrornonExhaustiveGuardsError runtimeErrorpatError recConError typeErrorconcatfilterzip newStablePtrprintfstsnd otherwiseassert GHC.MagiclazyoneShotrunRW# breakpointbreakpointCondinlinemap groupWith$coerce fromInteger- fromRationalenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negatefail>>=>>fmapreturnmfixarrfirstapp|||loop fromString fromIntegral realToFrac toInteger toRationalguardmzipIsListfromList fromListNtoListmkTrConmkTrApptoDyn<>memptymappendmconcatemptyCallStack pushCallStack fromStaticPtrnaturalFromIntegerjoin<*>pure*>BoundedEnumEqFloating FractionalIntegralMonadDataFunctorNumOrdReal RealFloatRealFracIxTypeableMonadFix MonadFailIsString ApplicativeFoldable TraversableGenericGeneric1Datatype ConstructorSelectorKnownNat KnownSymbolIsLabel SemigroupMonoidHasField GHC.TypesBoolDoubleFloatInt integer-gmpGHC.Integer.TypeIntegerNaturalOrderingRatioRational RealWorld~~WordFunPtrTypeTYPE Constraint*★ RuntimeRepVecCountVecElemV1U1Par1Rec1K1M1:+::*::.:RDCSRec0D1C1S1RepRep1URecUAddrUCharUDoubleUFloatUIntUWordNatSymbol+^<=? CmpSymbolCmpNat TypeError CoercibleAny StaticPtr CallStackTypeRep SomeTypeRep AppendSymbolC#D#FalseF#I#NothingJustTrueW#LeftRightLTEQGT StaticPtrInfo FingerprintSrcLocTyConModuleKindRep TypeLitSortText:<>::$$:ShowTypePrefixIInfixILeftAssociativeRightAssociativeNotAssociative SourceUnpackSourceNoUnpackNoSourceUnpackedness SourceLazy SourceStrictNoSourceStrictness DecidedLazy DecidedStrict DecidedUnpackMetaDataMetaConsMetaSelVecRepTupleRepSumRep LiftedRep UnliftedRepIntRepWordRepInt64Rep Word64RepAddrRepFloatRep DoubleRepVec2Vec4Vec8Vec16Vec32Vec64 Int8ElemRep Int16ElemRep Int32ElemRep Int64ElemRep Word8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep FloatElemRep DoubleElemRepKindRepTyConApp KindRepVar KindRepApp KindRepFun KindRepTYPEKindRepTypeLitSKindRepTypeLitD TypeLitSymbol TypeLitNatneChareqCharminmax><not||&&<=compare/=isTrue# srcLocPackage srcLocModule srcLocFilesrcLocStartLinesrcLocStartCol srcLocEndLine srcLocEndCol HasCallStack getCallStackfromCallSiteListfreezeCallStack SomeExceptionerrorerrorWithoutStackTrace undefinedString MonadPlusmzeromplus Alternativeempty<|>somemanyliftA2<*<$<**>liftAliftA3=<<whenliftM2liftM3liftM4liftM5apordidconst.flip$!untilasTypeOfshiftL#shiftRL#iShiftL# iShiftRA# iShiftRL#currentCallStackstartProfTimer stopProfTimerabssignumsubtract newEmptyMVarnewMVartakeMVarreadMVarputMVar tryTakeMVar tryPutMVar tryReadMVar isEmptyMVarunsafeDupablePerformIOunsafeInterleaveIOcurryuncurryswapmaybeisJust isNothingfromJust fromMaybe maybeToList listToMaybe catMaybesmapMaybeheadunconstaillastinitnulllengthfoldlfoldl'foldl1foldl1'sumproductscanlscanl1scanl'foldr1scanrscanr1maximumminimumiteraterepeat replicate takeWhile dropWhiletakedropsplitAtspanbreakreverseandoranyallelemnotElemlookup concatMap!!zip3zipWith3unzipunzip3showshowListShowSshowsshowChar showString showParen showLitChar intToDigitSTunsafeInterleaveSTunsafeDupableInterleaveSTfixSTrunSTSTRefnewSTRef readSTRef writeSTRefchrsuccpredminBoundmaxBoundproperFractiontruncateroundceilingfloor/recipquotremdivmodquotRemdivMod% numerator denominator showSignedevenodd^^gcdlcmrangeindexinRange rangeSize<$>$>voidfixon&boolNotIf FiniteBits finiteBitSizecountLeadingZeroscountTrailingZerosBits.&..|.xor complementshiftrotatezeroBitsbitsetBitclearBit complementBittestBit bitSizeMaybebitSizeisSignedshiftL unsafeShiftLshiftR unsafeShiftRrotateLrotateRpopCount bitDefaulttestBitDefaultpopCountDefaulttoIntegralSized $fBitsInteger $fBitsBool$fFiniteBitsWord $fBitsWord$fFiniteBitsInt $fBitsInt$fFiniteBitsBool floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2piexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanhlog1pexpm1log1pexplog1mexp showFloat floatToDigitsfromRat $fMonadFailIO $fMonadFail[]$fMonadFailMaybeGeneralCategoryUppercaseLetterLowercaseLetterTitlecaseLetterModifierLetter OtherLetterNonSpacingMarkSpacingCombiningMark EnclosingMark DecimalNumber LetterNumber OtherNumberConnectorPunctuationDashPunctuationOpenPunctuationClosePunctuation InitialQuote FinalQuoteOtherPunctuation MathSymbolCurrencySymbolModifierSymbol OtherSymbolSpace LineSeparatorParagraphSeparatorFormat Surrogate PrivateUse NotAssignedgeneralCategoryisAsciiisLatin1 isAsciiLower isAsciiUpperisSpaceisDigit isOctDigit isHexDigit isPunctuationisSymbol isAlphaNum isControlisPrintisUpperisLowertoLowertoUppertoTitleWeakmkWeak deRefWeakfinalizeReadPReadSgetlookpfail+++<++gathersatisfychareofstringmunchmunch1choice skipSpacescountbetweenoptionoptionalmany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTill readP_to_S readS_to_P$fAlternativeP $fMonadFailP$fMonadP $fMonadPlusP$fApplicativeP$fMonadPlusReadP$fAlternativeReadP$fMonadFailReadP $fMonadReadP$fApplicativeReadP$fFunctorReadP $fFunctorPPrecReadPrecminPrecliftstepresetprec readPrec_to_P readP_to_Prec readPrec_to_S readS_to_Prec$fAlternativeReadPrec$fMonadPlusReadPrec$fMonadFailReadPrec$fMonadReadPrec$fApplicativeReadPrec$fFunctorReadPrecNumberLexemePuncIdentEOFnumberToInteger numberToFixednumberToRangedRationalnumberToRationallexexpecthsLex isSymbolCharlexCharreadIntPreadOctPreadDecPreadHexP $fEqNumber $fShowNumber $fEqLexeme $fShowLexemereadListreadPrec readListPrec readParenreadListDefaultreadListPrecDefault lexLitChar readLitChar lexDigitslexPparensreadIntreadOctreadDecreadHex readFloat readSignedshowInt showEFloat showFFloat showGFloat showFFloatAlt showGFloatAlt showIntAtBaseshowHexshowOctcastPtrplusPtralignPtrminusPtr nullFunPtr castFunPtrcastFunPtrToPtrcastPtrToFunPtr freeStablePtrdeRefStablePtrcastStablePtrToPtrcastPtrToStablePtr byteSwap16 byteSwap32uncheckedShiftL64#uncheckedShiftRL64# byteSwap64$fShowFingerprint$fEqFingerprint$fOrdFingerprintfingerprintStringfingerprintFingerprintsuncheckedIShiftL64#uncheckedIShiftRA64# alignment peekElemOff pokeElemOff peekByteOff pokeByteOffpeekpoke$fStorableFingerprint$fStorableRatio$fStorableInt64$fStorableInt32$fStorableInt16$fStorableInt8$fStorableWord64$fStorableWord32$fStorableWord16$fStorableWord8$fStorableDouble$fStorableFloat$fStorableStablePtr$fStorableFunPtr $fStorablePtr$fStorableWord $fStorableInt$fStorableChar$fStorableBool $fStorable()NatS#NatJ#isValidNaturalminusNaturalMaybe wordToNaturalnaturalToWordMaybe powModNatural $fBitsNatural $fIxNatural$fIntegralNatural $fEnumNatural $fRealNatural $fNumNatural $fReadNatural $fShowNatural $fEqNatural $fOrdNaturalIOModeReadMode WriteMode AppendMode ReadWriteModeIntPtrWordPtr ptrToWordPtr wordPtrToPtr ptrToIntPtr intPtrToPtr $fEqWordPtr $fOrdWordPtr $fNumWordPtr $fEnumWordPtr$fStorableWordPtr $fRealWordPtr$fBoundedWordPtr$fIntegralWordPtr $fBitsWordPtr$fFiniteBitsWordPtr $fReadWordPtr $fShowWordPtr $fEqIntPtr $fOrdIntPtr $fNumIntPtr $fEnumIntPtr$fStorableIntPtr $fRealIntPtr$fBoundedIntPtr$fIntegralIntPtr $fBitsIntPtr$fFiniteBitsIntPtr $fReadIntPtr $fShowIntPtrCUIntMaxCIntMaxCUIntPtrCIntPtrCJmpBufCFposCFile CSUSeconds CUSecondsCTimeCClock CSigAtomicCWcharCSizeCPtrdiffCDoubleCFloatCBoolCULLongCLLongCULongCLongCUIntCIntCUShortCShortCUCharCSCharCChar $fEqCChar $fOrdCChar $fNumCChar $fEnumCChar$fStorableCChar $fRealCChar$fBoundedCChar$fIntegralCChar $fBitsCChar$fFiniteBitsCChar $fReadCChar $fShowCChar $fEqCSChar $fOrdCSChar $fNumCSChar $fEnumCSChar$fStorableCSChar $fRealCSChar$fBoundedCSChar$fIntegralCSChar $fBitsCSChar$fFiniteBitsCSChar $fReadCSChar $fShowCSChar $fEqCUChar $fOrdCUChar $fNumCUChar $fEnumCUChar$fStorableCUChar $fRealCUChar$fBoundedCUChar$fIntegralCUChar $fBitsCUChar$fFiniteBitsCUChar $fReadCUChar $fShowCUChar $fEqCShort $fOrdCShort $fNumCShort $fEnumCShort$fStorableCShort $fRealCShort$fBoundedCShort$fIntegralCShort $fBitsCShort$fFiniteBitsCShort $fReadCShort $fShowCShort $fEqCUShort $fOrdCUShort $fNumCUShort $fEnumCUShort$fStorableCUShort $fRealCUShort$fBoundedCUShort$fIntegralCUShort $fBitsCUShort$fFiniteBitsCUShort $fReadCUShort $fShowCUShort$fEqCInt $fOrdCInt $fNumCInt $fEnumCInt$fStorableCInt $fRealCInt $fBoundedCInt$fIntegralCInt $fBitsCInt$fFiniteBitsCInt $fReadCInt $fShowCInt $fEqCUInt $fOrdCUInt $fNumCUInt $fEnumCUInt$fStorableCUInt $fRealCUInt$fBoundedCUInt$fIntegralCUInt $fBitsCUInt$fFiniteBitsCUInt $fReadCUInt $fShowCUInt $fEqCLong $fOrdCLong $fNumCLong $fEnumCLong$fStorableCLong $fRealCLong$fBoundedCLong$fIntegralCLong $fBitsCLong$fFiniteBitsCLong $fReadCLong $fShowCLong $fEqCULong $fOrdCULong $fNumCULong $fEnumCULong$fStorableCULong $fRealCULong$fBoundedCULong$fIntegralCULong $fBitsCULong$fFiniteBitsCULong $fReadCULong $fShowCULong $fEqCLLong $fOrdCLLong $fNumCLLong $fEnumCLLong$fStorableCLLong $fRealCLLong$fBoundedCLLong$fIntegralCLLong $fBitsCLLong$fFiniteBitsCLLong $fReadCLLong $fShowCLLong $fEqCULLong $fOrdCULLong $fNumCULLong $fEnumCULLong$fStorableCULLong $fRealCULLong$fBoundedCULLong$fIntegralCULLong $fBitsCULLong$fFiniteBitsCULLong $fReadCULLong $fShowCULLong $fEqCBool $fOrdCBool $fNumCBool $fEnumCBool$fStorableCBool $fRealCBool$fBoundedCBool$fIntegralCBool $fBitsCBool$fFiniteBitsCBool $fReadCBool $fShowCBool $fEqCFloat $fOrdCFloat $fNumCFloat $fEnumCFloat$fStorableCFloat $fRealCFloat$fFractionalCFloat$fFloatingCFloat$fRealFracCFloat$fRealFloatCFloat $fReadCFloat $fShowCFloat $fEqCDouble $fOrdCDouble $fNumCDouble $fEnumCDouble$fStorableCDouble $fRealCDouble$fFractionalCDouble$fFloatingCDouble$fRealFracCDouble$fRealFloatCDouble $fReadCDouble $fShowCDouble $fEqCPtrdiff $fOrdCPtrdiff $fNumCPtrdiff$fEnumCPtrdiff$fStorableCPtrdiff$fRealCPtrdiff$fBoundedCPtrdiff$fIntegralCPtrdiff$fBitsCPtrdiff$fFiniteBitsCPtrdiff$fReadCPtrdiff$fShowCPtrdiff $fEqCSize $fOrdCSize $fNumCSize $fEnumCSize$fStorableCSize $fRealCSize$fBoundedCSize$fIntegralCSize $fBitsCSize$fFiniteBitsCSize $fReadCSize $fShowCSize $fEqCWchar $fOrdCWchar $fNumCWchar $fEnumCWchar$fStorableCWchar $fRealCWchar$fBoundedCWchar$fIntegralCWchar $fBitsCWchar$fFiniteBitsCWchar $fReadCWchar $fShowCWchar$fEqCSigAtomic$fOrdCSigAtomic$fNumCSigAtomic$fEnumCSigAtomic$fStorableCSigAtomic$fRealCSigAtomic$fBoundedCSigAtomic$fIntegralCSigAtomic$fBitsCSigAtomic$fFiniteBitsCSigAtomic$fReadCSigAtomic$fShowCSigAtomic $fEqCClock $fOrdCClock $fNumCClock $fEnumCClock$fStorableCClock $fRealCClock $fReadCClock $fShowCClock $fEqCTime $fOrdCTime $fNumCTime $fEnumCTime$fStorableCTime $fRealCTime $fReadCTime $fShowCTime $fEqCUSeconds$fOrdCUSeconds$fNumCUSeconds$fEnumCUSeconds$fStorableCUSeconds$fRealCUSeconds$fReadCUSeconds$fShowCUSeconds$fEqCSUSeconds$fOrdCSUSeconds$fNumCSUSeconds$fEnumCSUSeconds$fStorableCSUSeconds$fRealCSUSeconds$fReadCSUSeconds$fShowCSUSeconds $fEqCIntPtr $fOrdCIntPtr $fNumCIntPtr $fEnumCIntPtr$fStorableCIntPtr $fRealCIntPtr$fBoundedCIntPtr$fIntegralCIntPtr $fBitsCIntPtr$fFiniteBitsCIntPtr $fReadCIntPtr $fShowCIntPtr $fEqCUIntPtr $fOrdCUIntPtr $fNumCUIntPtr$fEnumCUIntPtr$fStorableCUIntPtr$fRealCUIntPtr$fBoundedCUIntPtr$fIntegralCUIntPtr$fBitsCUIntPtr$fFiniteBitsCUIntPtr$fReadCUIntPtr$fShowCUIntPtr $fEqCIntMax $fOrdCIntMax $fNumCIntMax $fEnumCIntMax$fStorableCIntMax $fRealCIntMax$fBoundedCIntMax$fIntegralCIntMax $fBitsCIntMax$fFiniteBitsCIntMax $fReadCIntMax $fShowCIntMax $fEqCUIntMax $fOrdCUIntMax $fNumCUIntMax$fEnumCUIntMax$fStorableCUIntMax$fRealCUIntMax$fBoundedCUIntMax$fIntegralCUIntMax$fBitsCUIntMax$fFiniteBitsCUIntMax$fReadCUIntMax$fShowCUIntMax TestEquality testEquality:~~:HRefl:~:ReflsymtranscastWith gcastWithapplyinnerouter$f~kab $fEnum:~: $fRead:~: $fEnum:~~: $fRead:~~:$fTestEqualityk:~~:$fTestEqualityk:~: $fBounded:~~: $fOrd:~~: $fShow:~~:$fEq:~~: $fBounded:~:$fOrd:~: $fShow:~:$fEq:~: TestCoercion testCoercionCoercion coerceWith gcoerceWithrepr$fEnumCoercion$fReadCoercion$fTestCoercionkCoercion$fTestCoercionk:~~:$fTestCoercionk:~:$fBoundedCoercion $fOrdCoercion$fShowCoercion $fEqCoercionCategory<<<>>>$fCategorykCoercion$fCategoryk:~~:$fCategoryk:~:$fCategoryTYPE(->)KProxyProxy asProxyTypeOf$fMonadPlusProxy $fMonadProxy$fAlternativeProxy$fApplicativeProxy$fFunctorProxy $fMonoidProxy $fIxProxy $fEnumProxy $fReadProxy $fShowProxy $fOrdProxy $fEqProxy$fBoundedProxyDown comparing $fOrdDown$fEqDown $fShowDown $fReadDowneitherleftsrightspartitionEithersisLeftisRightfromLeft fromRight $fMonadEither$fApplicativeEither$fFunctorEither $fEqEither $fOrdEither $fReadEither $fShowEitherreads readEither readMayberead digitToIntisMarkisNumber isSeparator dropWhileEnd stripPrefix elemIndex elemIndicesfind findIndex findIndices isPrefixOf isSuffixOf isInfixOfnubnubBydeletedeleteBy\\unionunionBy intersect intersectBy intersperse intercalate partition mapAccumL mapAccumRinsertinsertByzip4zip5zip6zip7zipWith4zipWith5zipWith6zipWith7unzip4unzip5unzip6unzip7deleteFirstsBygroupgroupByinitstails subsequences permutationssortsortOnlinesunlineswordsunwords showListWith unsafeCoerceSomeNatnatValnatVal' someNatValsameNat $fReadSomeNat $fShowSomeNat $fOrdSomeNat $fEqSomeNat ErrorMessage SomeSymbol symbolVal symbolVal' someSymbolVal sameSymbol$fReadSomeSymbol$fShowSomeSymbol$fOrdSomeSymbol$fEqSomeSymbolMetafrom1to1fromtoselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessDecidedStrictnessSourceStrictnessSourceUnpackedness AssociativityFixityIFixityPrefixInfixconName conFixity conIsRecord datatypeName moduleName packageName isNewtypeComp1unComp1L1R1unM1unK1unRec1unPar1$fAlternative:.:$fApplicative:.:$fMonadPlus:*: $fMonad:*:$fAlternative:*:$fApplicative:*: $fMonadRec1 $fMonadPar1$fApplicativePar1 $fMonadPlusU1 $fMonadU1$fAlternativeU1$fApplicativeU1 $fFunctorU1$fShowU1$fReadU1$fOrdU1$fEqU1%$fSingIDecidedStrictnessDecidedUnpack%$fSingIDecidedStrictnessDecidedStrict#$fSingIDecidedStrictnessDecidedLazy#$fSingISourceStrictnessSourceStrict!$fSingISourceStrictnessSourceLazy)$fSingISourceStrictnessNoSourceStrictness%$fSingISourceUnpackednessSourceUnpack'$fSingISourceUnpackednessSourceNoUnpack-$fSingISourceUnpackednessNoSourceUnpackedness"$fSingIAssociativityNotAssociative$$fSingIAssociativityRightAssociative#$fSingIAssociativityLeftAssociative$fSingIFixityIInfixI$fSingIFixityIPrefixI$fSingIMaybeJust$fSingIMaybeNothing$fSingIBoolFalse$fSingIBoolTrue$fSingISymbola$fSingKindDecidedStrictness$fSingKindSourceStrictness$fSingKindSourceUnpackedness$fSingKindAssociativity$fSingKindFixityI$fSingKindMaybe$fSingKindBool$fSingKindSymbol$fSelectorMetaMetaSel$fConstructorMetaMetaCons$fDatatypeMetaMetaData$fEqURec $fOrdURec $fShowURec $fFunctorURec $fGenericURec$fGeneric1URec $fEqURec0 $fOrdURec0 $fShowURec0$fFunctorURec0$fGenericURec0$fGeneric1URec0 $fEqURec1 $fOrdURec1 $fShowURec1$fFunctorURec1$fGenericURec1$fGeneric1URec1 $fEqURec2 $fOrdURec2 $fShowURec2$fFunctorURec2$fGenericURec2$fGeneric1URec2 $fEqURec3 $fOrdURec3 $fShowURec3$fFunctorURec3$fGenericURec3$fGeneric1URec3 $fEqURec4 $fOrdURec4$fFunctorURec4$fGenericURec4$fGeneric1URec4$fEqDecidedStrictness$fShowDecidedStrictness$fOrdDecidedStrictness$fReadDecidedStrictness$fEnumDecidedStrictness$fBoundedDecidedStrictness$fIxDecidedStrictness$fGenericDecidedStrictness$fEqSourceStrictness$fShowSourceStrictness$fOrdSourceStrictness$fReadSourceStrictness$fEnumSourceStrictness$fBoundedSourceStrictness$fIxSourceStrictness$fGenericSourceStrictness$fEqSourceUnpackedness$fShowSourceUnpackedness$fOrdSourceUnpackedness$fReadSourceUnpackedness$fEnumSourceUnpackedness$fBoundedSourceUnpackedness$fIxSourceUnpackedness$fGenericSourceUnpackedness$fEqAssociativity$fShowAssociativity$fOrdAssociativity$fReadAssociativity$fEnumAssociativity$fBoundedAssociativity$fIxAssociativity$fGenericAssociativity $fEqFixity $fShowFixity $fOrdFixity $fReadFixity$fGenericFixity$fEq:.:$fOrd:.: $fRead:.: $fShow:.: $fFunctor:.: $fGeneric:.: $fGeneric1:.:$fEq:*:$fOrd:*: $fRead:*: $fShow:*: $fFunctor:*: $fGeneric:*: $fGeneric1:*:$fEq:+:$fOrd:+: $fRead:+: $fShow:+: $fFunctor:+: $fGeneric:+: $fGeneric1:+:$fEqK1$fOrdK1$fReadK1$fShowK1 $fFunctorK1 $fGenericK1 $fGeneric1K1$fEqRec1 $fOrdRec1 $fReadRec1 $fShowRec1 $fFunctorRec1 $fGenericRec1$fGeneric1Rec1$fEqPar1 $fOrdPar1 $fReadPar1 $fShowPar1 $fFunctorPar1 $fGenericPar1$fGeneric1Par1 $fGenericU1 $fGeneric1U1 $fFunctorV1 $fGenericV1 $fGeneric1V1$fEqM1$fOrdM1$fReadM1$fShowM1 $fFunctorM1 $fGenericM1 $fGeneric1M1$fGeneric1(,,,,,,)$fGeneric1(,,,,,)$fGeneric1(,,,,)$fGeneric1(,,,)$fGeneric1(,,) $fGeneric1(,)$fGeneric1Proxy$fGeneric1Either$fGeneric1Maybe $fGeneric1[]$fGeneric(,,,,,,)$fGeneric(,,,,,)$fGeneric(,,,,)$fGeneric(,,,) $fGeneric(,,) $fGeneric(,) $fGeneric()$fGenericProxy$fGenericOrdering $fGenericBool$fGenericEither$fGenericMaybe $fGeneric[] $fMonadPlusM1 $fMonadM1$fAlternativeM1$fApplicativeM1$fMonadPlusRec1$fAlternativeRec1$fApplicativeRec1$fShowV1$fReadV1$fOrdV1$fEqV1AltgetAltgetLastgetFirstProduct getProductSumgetSumgetAnyAllgetAllEndoappEndoDualgetDual $fMonadDual$fApplicativeDual $fFunctorDual $fMonoidDual $fMonoidEndo $fMonoidAll $fMonoidAny $fMonadSum$fApplicativeSum $fFunctorSum $fMonoidSum$fMonadProduct$fApplicativeProduct$fFunctorProduct$fMonoidProduct $fMonoidFirst $fMonoidLast $fMonoidAlt$fEqDual $fOrdDual $fReadDual $fShowDual $fBoundedDual $fGenericDual$fGeneric1Dual $fGenericEndo$fEqAll$fOrdAll $fReadAll $fShowAll $fBoundedAll $fGenericAll$fEqAny$fOrdAny $fReadAny $fShowAny $fBoundedAny $fGenericAny$fEqSum$fOrdSum $fReadSum $fShowSum $fBoundedSum $fGenericSum $fGeneric1Sum$fNumSum $fEqProduct $fOrdProduct $fReadProduct $fShowProduct$fBoundedProduct$fGenericProduct$fGeneric1Product $fNumProduct $fEqFirst $fOrdFirst $fReadFirst $fShowFirst$fGenericFirst$fGeneric1First$fFunctorFirst$fApplicativeFirst $fMonadFirst$fEqLast $fOrdLast $fReadLast $fShowLast $fGenericLast$fGeneric1Last $fFunctorLast$fApplicativeLast $fMonadLast $fGenericAlt $fGeneric1Alt $fReadAlt $fShowAlt$fEqAlt$fOrdAlt$fNumAlt $fEnumAlt $fMonadAlt$fMonadPlusAlt$fApplicativeAlt$fAlternativeAlt $fFunctorAltfoldfoldr'foldrMfoldlMasummsum $fFoldableU1$fFoldableLast$fFoldableFirst$fFoldableProduct $fFoldableSum$fFoldableDual$fFoldableProxy$fFoldableArray $fFoldable(,)$fFoldableEither $fFoldable[]$fFoldableMaybe$fFoldableURec$fFoldableURec0$fFoldableURec1$fFoldableURec2$fFoldableURec3$fFoldableURec4 $fFoldable:.: $fFoldable:*: $fFoldable:+: $fFoldableM1 $fFoldableK1$fFoldableRec1$fFoldablePar1 $fFoldableV1ConstgetConst$fApplicativeConst$fFunctorConst$fFoldableConst $fShowConst $fReadConst $fBitsConst$fBoundedConst $fEnumConst $fEqConst$fFiniteBitsConst$fFloatingConst$fFractionalConst$fGenericConst$fGeneric1Const$fIntegralConst $fIxConst $fMonoidConst $fNumConst $fOrdConst $fRealConst$fRealFracConst$fRealFloatConst$fStorableConstCon'ConAppFun modulePackage tyConPackage tyConModule tyConNametyConFingerprint tyConKindArgs tyConKindRep rnfModulernfTyContypeRepFingerprint withTypeablesomeTypeRepTyCon typeRepTyCon eqTypeRep typeRepKindtypeReptypeOf someTypeRepsomeTypeRepFingerprint splitApps rnfTypeReprnfSomeTypeRepmkTyCon Typeable7 Typeable6 Typeable5 Typeable4 Typeable3 Typeable2 Typeable1 showsTypeRepcasteqTgcastgcast1gcast2 funResultTymkFunTy splitTyConApp typeRepArgstypeOf1typeOf2typeOf3typeOf4typeOf5typeOf6typeOf7ArithExceptionOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominator ErrorCallErrorCallWithLocation toException fromExceptiondisplayExceptionthrow prettySrcLocprettyCallStackIOError userError MaskingStateUnmaskedMaskedInterruptibleMaskedUninterruptibleFilePath unsafeIOToST unsafeSTToIO interruptiblegetMaskingStatemask_uninterruptibleMask_uninterruptibleMaskevaluateIORefnewIORef readIORef writeIORefFinalizerEnvPtr FinalizerPtrmallocForeignPtrmallocForeignPtrBytesaddForeignPtrFinalizerEnvnewForeignPtr_touchForeignPtrunsafeForeignPtrToPtrcastForeignPtrplusForeignPtrfinalizeForeignPtr newForeignPtrnewForeignPtrEnvmallocForeignPtrArraymallocForeignPtrArray0 BufferState ReadBuffer WriteBuffer CharBufferBufferbufRawbufStatebufSizebufLbufR RawCharBuffer CharBufElem RawBuffer readWord8Buf writeWord8Buf peekCharBuf readCharBuf writeCharBufreadCharBufPtrwriteCharBufPtrcharSize withBuffer withRawBuffer isEmptyBuffer isFullBufferisFullCharBuffer isWriteBuffer bufferElemsbufferAvailable bufferRemove bufferAdjustL bufferAdd emptyBuffer newByteBuffer newCharBuffer newBuffer slideContents summaryBuffer checkBuffer$fEqBufferStateCodingProgressInputUnderflowOutputUnderflowInvalidSequence TextEncodingtextEncodingName mkTextDecoder mkTextEncoder TextEncoder TextDecoder EncodeBuffer DecodeBuffer CodeBuffer BufferCodecencoderecoverclosegetStatesetState$fShowTextEncoding$fEqCodingProgress$fShowCodingProgress mkWeakIORef modifyIORef modifyIORef'atomicModifyIORefatomicModifyIORef'atomicWriteIORefgetLocaleEncodinggetFileSystemEncodinggetForeignEncodingSeekMode AbsoluteSeek RelativeSeek SeekFromEnd IODeviceType DirectoryStream RegularFile RawDeviceIODeviceready isTerminal isSeekableseektellgetSizesetSizesetEchogetEchosetRawdevTypedupdup2RawIOreadNonBlockingwritewriteNonBlocking$fEqIODeviceType $fEqSeekMode $fOrdSeekMode $fIxSeekMode$fEnumSeekMode$fReadSeekMode$fShowSeekMode BufferedIOfillReadBufferfillReadBuffer0emptyWriteBufferflushWriteBufferflushWriteBuffer0readBufreadBufNonBlockingwriteBufwriteBufNonBlocking NewlineModeinputNLoutputNLNewlineLFCRLF BufferMode NoBuffering LineBufferingBlockBuffering nativeNewlineuniversalNewlineModenativeNewlineModenoNewlineTranslationstdout IOErrorTypeExitCode ExitSuccess ExitFailureArrayExceptionIndexOutOfBoundsUndefinedElementAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptSomeAsyncExceptionAssertionFailedCompactionFailedAllocationLimitExceededDeadlockBlockedIndefinitelyOnSTMBlockedIndefinitelyOnMVarasyncExceptionToExceptionasyncExceptionFromExceptionioErrorCodingFailureModeErrorOnCodingFailureIgnoreCodingFailureTransliterateCodingFailureRoundtripFailurecodingFailureModeSuffix isSurrogate recoverDecode recoverEncode$fShowCodingFailureModeutf8mkUTF8utf8_bom mkUTF8_bomutf32mkUTF32 utf32_encode utf32_decodeutf32be mkUTF32beutf32le mkUTF32leutf32be_decodeutf32le_decodeutf32be_encodeutf32le_encodeutf16mkUTF16 utf16_encode utf16_decodeutf16be mkUTF16beutf16le mkUTF16leutf16be_decodeutf16le_decodeutf16be_encodeutf16le_encodelatin1mkLatin1latin1_checkedmkLatin1_checkedasciimkAscii latin1_decode ascii_decode latin1_encodelatin1_checked_encode ascii_encodethrowIfthrowIf_ throwIfNeg throwIfNeg_ throwIfNullcalloc mallocBytes callocBytes allocaBytesallocaBytesAlignedrealloc reallocBytesfromBooltoBoolmaybeNew maybeWith maybePeekwithMany copyBytes moveBytes fillBytes callocArray callocArray0 allocaArray allocaArray0 reallocArray reallocArray0 peekArray peekArray0 pokeArray pokeArray0newArray newArray0 withArray withArrayLen withArray0 withArrayLen0 copyArray moveArray lengthArray0 advancePtr peekCStringpeekCStringLen newCString newCStringLen withCStringwithCStringLenwithCStringsLencharIsRepresentable CWStringLenCWString CStringLenCStringcastCCharToCharcastCharToCCharcastCUCharToCharcastCharToCUCharcastCSCharToCharcastCharToCSChar peekCAStringpeekCAStringLen newCAStringnewCAStringLen withCAStringwithCAStringLen peekCWStringpeekCWStringLen newCWStringnewCWStringLen withCWStringwithCWStringLenunsafeLocalStateErrnoeOKe2BIGeACCES eADDRINUSE eADDRNOTAVAILeADV eAFNOSUPPORTeAGAINeALREADYeBADFeBADMSGeBADRPCeBUSYeCHILDeCOMM eCONNABORTED eCONNREFUSED eCONNRESETeDEADLK eDESTADDRREQeDIRTYeDOMeDQUOTeEXISTeFAULTeFBIGeFTYPE eHOSTDOWN eHOSTUNREACHeIDRMeILSEQ eINPROGRESSeINTReINVALeIOeISCONNeISDIReLOOPeMFILEeMLINKeMSGSIZE eMULTIHOP eNAMETOOLONGeNETDOWN eNETRESET eNETUNREACHeNFILEeNOBUFSeNODATAeNODEVeNOENTeNOEXECeNOLCKeNOLINKeNOMEMeNOMSGeNONET eNOPROTOOPTeNOSPCeNOSReNOSTReNOSYSeNOTBLKeNOTCONNeNOTDIR eNOTEMPTYeNOTSOCKeNOTSUPeNOTTYeNXIO eOPNOTSUPPePERM ePFNOSUPPORTePIPEePROCLIM ePROCUNAVAIL ePROGMISMATCH ePROGUNAVAILePROTOePROTONOSUPPORT ePROTOTYPEeRANGEeREMCHGeREMOTEeROFS eRPCMISMATCHeRREMOTE eSHUTDOWNeSOCKTNOSUPPORTeSPIPEeSRCHeSRMNTeSTALEeTIME eTIMEDOUT eTOOMANYREFSeTXTBSYeUSERS eWOULDBLOCKeXDEV isValidErrnogetErrno resetErrno throwErrno throwErrnoIf throwErrnoIf_throwErrnoIfRetrythrowErrnoIfRetryMayBlockthrowErrnoIfRetry_throwErrnoIfRetryMayBlock_throwErrnoIfMinus1throwErrnoIfMinus1_throwErrnoIfMinus1RetrythrowErrnoIfMinus1Retry_throwErrnoIfMinus1RetryMayBlock throwErrnoIfMinus1RetryMayBlock_throwErrnoIfNullthrowErrnoIfNullRetrythrowErrnoIfNullRetryMayBlockthrowErrnoPaththrowErrnoPathIfthrowErrnoPathIf_throwErrnoPathIfNullthrowErrnoPathIfMinus1throwErrnoPathIfMinus1_errnoToIOError $fEqErrnoPoolnewPoolfreePoolwithPool pooledMallocpooledMallocBytes pooledReallocpooledReallocBytespooledMallocArraypooledMallocArray0pooledReallocArraypooledReallocArray0 pooledNewpooledNewArraypooledNewArray0LimitProcessGroupID FileOffset ProcessIDFileModeFileIDDeviceID EpochTime ClockTick ByteCountGroupIDUserID LinkCountFdCTimerCKeyCId CFsFilCnt CFsBlkCntCClockIdCBlkCntCBlkSizeCRLimCTcflagCSpeedCCcCUidCNlinkCGidCSsizeCPidCOffCModeCInoCDev$fEqCDev $fOrdCDev $fNumCDev $fEnumCDev$fStorableCDev $fRealCDev $fBoundedCDev$fIntegralCDev $fBitsCDev$fFiniteBitsCDev $fReadCDev $fShowCDev$fEqCIno $fOrdCIno $fNumCIno $fEnumCIno$fStorableCIno $fRealCIno $fBoundedCIno$fIntegralCIno $fBitsCIno$fFiniteBitsCIno $fReadCIno $fShowCIno $fEqCMode $fOrdCMode $fNumCMode $fEnumCMode$fStorableCMode $fRealCMode$fBoundedCMode$fIntegralCMode $fBitsCMode$fFiniteBitsCMode $fReadCMode $fShowCMode$fEqCOff $fOrdCOff $fNumCOff $fEnumCOff$fStorableCOff $fRealCOff $fBoundedCOff$fIntegralCOff $fBitsCOff$fFiniteBitsCOff $fReadCOff $fShowCOff$fEqCPid $fOrdCPid $fNumCPid $fEnumCPid$fStorableCPid $fRealCPid $fBoundedCPid$fIntegralCPid $fBitsCPid$fFiniteBitsCPid $fReadCPid $fShowCPid $fEqCSsize $fOrdCSsize $fNumCSsize $fEnumCSsize$fStorableCSsize $fRealCSsize$fBoundedCSsize$fIntegralCSsize $fBitsCSsize$fFiniteBitsCSsize $fReadCSsize $fShowCSsize$fEqCGid $fOrdCGid $fNumCGid $fEnumCGid$fStorableCGid $fRealCGid $fBoundedCGid$fIntegralCGid $fBitsCGid$fFiniteBitsCGid $fReadCGid $fShowCGid $fEqCNlink $fOrdCNlink $fNumCNlink $fEnumCNlink$fStorableCNlink $fRealCNlink$fBoundedCNlink$fIntegralCNlink $fBitsCNlink$fFiniteBitsCNlink $fReadCNlink $fShowCNlink$fEqCUid $fOrdCUid $fNumCUid $fEnumCUid$fStorableCUid $fRealCUid $fBoundedCUid$fIntegralCUid $fBitsCUid$fFiniteBitsCUid $fReadCUid $fShowCUid$fEqCCc$fOrdCCc$fNumCCc $fEnumCCc $fStorableCCc $fRealCCc $fReadCCc $fShowCCc $fEqCSpeed $fOrdCSpeed $fNumCSpeed $fEnumCSpeed$fStorableCSpeed $fRealCSpeed $fReadCSpeed $fShowCSpeed $fEqCTcflag $fOrdCTcflag $fNumCTcflag $fEnumCTcflag$fStorableCTcflag $fRealCTcflag$fBoundedCTcflag$fIntegralCTcflag $fBitsCTcflag$fFiniteBitsCTcflag $fReadCTcflag $fShowCTcflag $fEqCRLim $fOrdCRLim $fNumCRLim $fEnumCRLim$fStorableCRLim $fRealCRLim$fBoundedCRLim$fIntegralCRLim $fBitsCRLim$fFiniteBitsCRLim $fReadCRLim $fShowCRLim $fEqCBlkSize $fOrdCBlkSize $fNumCBlkSize$fEnumCBlkSize$fStorableCBlkSize$fRealCBlkSize$fBoundedCBlkSize$fIntegralCBlkSize$fBitsCBlkSize$fFiniteBitsCBlkSize$fReadCBlkSize$fShowCBlkSize $fEqCBlkCnt $fOrdCBlkCnt $fNumCBlkCnt $fEnumCBlkCnt$fStorableCBlkCnt $fRealCBlkCnt$fBoundedCBlkCnt$fIntegralCBlkCnt $fBitsCBlkCnt$fFiniteBitsCBlkCnt $fReadCBlkCnt $fShowCBlkCnt $fEqCClockId $fOrdCClockId $fNumCClockId$fEnumCClockId$fStorableCClockId$fRealCClockId$fBoundedCClockId$fIntegralCClockId$fBitsCClockId$fFiniteBitsCClockId$fReadCClockId$fShowCClockId $fEqCFsBlkCnt$fOrdCFsBlkCnt$fNumCFsBlkCnt$fEnumCFsBlkCnt$fStorableCFsBlkCnt$fRealCFsBlkCnt$fBoundedCFsBlkCnt$fIntegralCFsBlkCnt$fBitsCFsBlkCnt$fFiniteBitsCFsBlkCnt$fReadCFsBlkCnt$fShowCFsBlkCnt $fEqCFsFilCnt$fOrdCFsFilCnt$fNumCFsFilCnt$fEnumCFsFilCnt$fStorableCFsFilCnt$fRealCFsFilCnt$fBoundedCFsFilCnt$fIntegralCFsFilCnt$fBitsCFsFilCnt$fFiniteBitsCFsFilCnt$fReadCFsFilCnt$fShowCFsFilCnt$fEqCId$fOrdCId$fNumCId $fEnumCId $fStorableCId $fRealCId $fBoundedCId $fIntegralCId $fBitsCId$fFiniteBitsCId $fReadCId $fShowCId$fEqCKey $fOrdCKey $fNumCKey $fEnumCKey$fStorableCKey $fRealCKey $fBoundedCKey$fIntegralCKey $fBitsCKey$fFiniteBitsCKey $fReadCKey $fShowCKey $fEqCTimer $fOrdCTimer$fStorableCTimer $fShowCTimer$fEqFd$fOrdFd$fNumFd$fEnumFd $fStorableFd$fRealFd $fBoundedFd $fIntegralFd$fBitsFd$fFiniteBitsFd$fReadFd$fShowFdLifetimeOneShot MultiShotEventevtReadevtWriteDynamicfromDyn fromDynamicdynApplydynApp dynTypeRep$fExceptionDynamic $fShowDynamicTVarSTMPrimMVar ThreadStatus ThreadRunningThreadFinished ThreadBlocked ThreadDied BlockReason BlockedOnMVarBlockedOnBlackHoleBlockedOnException BlockedOnSTMBlockedOnForeignCallBlockedOnOtherThreadIdreportHeapOverflowgetAllocationCounterdisableAllocationLimitforkOnforkOnWithUnmasknumCapabilitiesgetNumCapabilitiessetNumCapabilitiesgetNumProcessors numSparks childHandler myThreadIdyield labelThreadpseqpar runSparks threadStatusthreadCapabilitymkWeakThreadIdnewStablePtrPrimMVar unsafeIOToSTM atomicallyretryorElsethrowSTMcatchSTMalwaysSucceedsalwaysnewTVar newTVarIO readTVarIOreadTVar writeTVarwithMVar modifyMVar_ sharedCAFreportStackOverflow reportErrorsetUncaughtExceptionHandlergetUncaughtExceptionHandler $fOrdThreadId $fEqThreadId$fShowThreadId$fMonadPlusSTM$fAlternativeSTM $fMonadSTM$fApplicativeSTM $fFunctorSTM$fEqTVar$fEqBlockReason$fOrdBlockReason$fShowBlockReason$fEqThreadStatus$fOrdThreadStatus$fShowThreadStatusNestedAtomicallyNonTermination NoMethodError RecUpdError RecConError RecSelErrorPatternMatchFail catchJusthandle handleJust mapExceptiontryJust onExceptionfinallybracket_bracketOnErrornonTerminationnestedAtomically$fExceptionPatternMatchFail$fShowPatternMatchFail$fExceptionRecSelError$fShowRecSelError$fExceptionRecConError$fShowRecConError$fExceptionRecUpdError$fShowRecUpdError$fExceptionNoMethodError$fShowNoMethodError$fExceptionTypeError$fShowTypeError$fExceptionNonTermination$fShowNonTermination$fExceptionNestedAtomically$fShowNestedAtomically tryIOError mkIOErrorisAlreadyExistsErrorisAlreadyInUseErrorisIllegalOperation isUserErroralreadyExistsErrorTypedoesNotExistErrorTypealreadyInUseErrorType fullErrorType eofErrorTypeillegalOperationErrorTypepermissionErrorType userErrorTypeisAlreadyExistsErrorTypeisDoesNotExistErrorTypeisAlreadyInUseErrorTypeisFullErrorTypeisEOFErrorTypeisIllegalOperationErrorTypeisPermissionErrorTypeisUserErrorTypeioeGetErrorTypeioeGetErrorStringioeGetLocation ioeGetHandleioeGetFileNameioeSetErrorTypeioeSetErrorStringioeSetLocation ioeSetHandleioeSetFileName modifyIOErrorannotateIOError catchIOErrorHandlercatchesallowInterrupt$fFunctorHandler unsafeFixIOsetLocaleEncodingsetFileSystemEncodingsetForeignEncodinginitLocaleEncodingchar8mkTextEncoding CostCentreCostCentreStack getCurrentCCSgetCCSOfclearCCSccsCC ccsParentccLabelccModule ccSrcSpan ccsToStrings whoCreated renderStackerrorWithStackTrace popCallStackwithFrozenCallStackmkDuplexHandle hClose_help getFullArgsswapMVarwithMVarMasked modifyMVarmodifyMVarMasked_modifyMVarMaskedaddMVarFinalizer mkWeakMVar HandlerFunSignal setHandler runHandlersrunHandlersPtr TimerManagerTimeoutCallback TimeoutKeyregisterTimeoutunregisterTimeout updateTimeout EventManager IOCallbackFdKeykeyFd registerFd unregisterFd_ unregisterFdcloseFdgetSystemEventManagergetSystemTimerManagerensureIOManagerIsRunningioManagerCapabilitiesChangedthreadWaitReadthreadWaitWritethreadWaitReadSTMthreadWaitWriteSTM closeFdWith threadDelay registerDelayhGetCharhGetLinehPutCharhPutStr hPutStrLnhPutBufNonBlocking hGetBufSomehGetBufNonBlockingstdinstderropenFileBlockingopenBinaryFile fdToHandle' fdToHandle handleToFdLockMode SharedLock ExclusiveLockFileLockingNotSupportedhLockhTryLock"$fExceptionFileLockingNotSupported$fShowFileLockingNotSupportedHandlePosition HandlePosnhClose hFileSize hSetFileSizehIsEOFisEOF hSetBuffering hSetEncoding hGetEncoding hFlushAllhGetPosnhSetPosnhSeekhTellhIsOpen hIsClosed hIsReadable hIsWritable hGetBuffering hIsSeekablehSetEchohGetEchohIsTerminalDevicehSetBinaryModehSetNewlineMode hDuplicate hDuplicateTohShow$fShowHandlePosn$fEqHandlePosnputCharputStrputStrLngetChargetLine getContentsinteractreadFile writeFile appendFilereadLnreadIOlocaleEncodinghReadyhPrintwithFilewithBinaryFile openTempFileopenBinaryTempFile"openTempFileWithDefaultPermissions(openBinaryTempFileWithDefaultPermissions fingerprint0fingerprintData getFileHash $fMonadFix:*: $fMonadFixM1$fMonadFixRec1$fMonadFixPar1 $fMonadFixAlt$fMonadFixLast$fMonadFixFirst$fMonadFixProduct $fMonadFixSum$fMonadFixDual $fMonadFixST$fMonadFixEither$fMonadFix(->) $fMonadFixIO $fMonadFix[]$fMonadFixMaybeIdentity runIdentity$fMonadFixIdentity$fMonadIdentity$fApplicativeIdentity$fFunctorIdentity$fFoldableIdentity$fShowIdentity$fReadIdentity$fBitsIdentity$fBoundedIdentity$fEnumIdentity $fEqIdentity$fFiniteBitsIdentity$fFloatingIdentity$fFractionalIdentity$fGenericIdentity$fGeneric1Identity$fIntegralIdentity $fIxIdentity$fMonoidIdentity $fNumIdentity $fOrdIdentity$fRealIdentity$fRealFracIdentity$fRealFloatIdentity$fStorableIdentity ArrowLoop ArrowMonad ArrowApply ArrowChoiceleftright ArrowPlus<+> ArrowZero zeroArrowKleisli runKleisliArrowsecond***&&&returnA^>>>>^<<^^<<leftApp $fArrow(->)$fArrowKleisli$fCategoryTYPEKleisli$fArrowZeroKleisli$fArrowPlusKleisli$fArrowChoiceKleisli$fArrowChoice(->)$fArrowApplyKleisli$fArrowApply(->)$fMonadPlusArrowMonad$fAlternativeArrowMonad$fMonadArrowMonad$fApplicativeArrowMonad$fFunctorArrowMonad$fArrowLoopKleisli$fArrowLoop(->)ZipList getZipList WrappedArrow WrapArrow unwrapArrow WrappedMonad WrapMonad unwrapMonad$fAlternativeWrappedMonad$fApplicativeWrappedMonad$fFunctorWrappedMonad$fAlternativeWrappedArrow$fApplicativeWrappedArrow$fFunctorWrappedArrow$fApplicativeZipList$fGenericWrappedMonad$fGeneric1WrappedMonad$fMonadWrappedMonad$fGenericWrappedArrow$fGeneric1WrappedArrow $fShowZipList $fEqZipList $fOrdZipList $fReadZipList$fFunctorZipList$fFoldableZipList$fGenericZipList$fGeneric1ZipList fmapDefaultfoldMapDefault$fTraversableU1$fTraversableZipList$fTraversableLast$fTraversableFirst$fTraversableProduct$fTraversableSum$fTraversableDual$fTraversableConst$fTraversableProxy$fTraversableArray$fTraversable(,)$fTraversableEither$fTraversable[]$fTraversableMaybe$fTraversableURec$fTraversableURec0$fTraversableURec1$fTraversableURec2$fTraversableURec3$fTraversableURec4$fTraversable:.:$fTraversable:*:$fTraversable:+:$fTraversableM1$fTraversableK1$fTraversableRec1$fTraversablePar1$fTraversableV1$fTraversableIdentityisSubsequenceOftraceIO putTraceMsgtracetraceId traceShow traceShowIdtraceM traceShowM traceStack traceEvent traceEventIO traceMarker traceMarkerIO $fIsString[]$fIsStringIdentity$fIsStringConstVersion versionBranch versionTags showVersion parseVersion makeVersion $fOrdVersion $fEqVersion $fReadVersion $fShowVersion$fGenericVersionfilterM>=><=<forever mapAndUnzipMzipWithM zipWithM_foldMfoldM_ replicateM replicateM_unless<$!>mfilter $fShow(->)ModifierParserFieldFormatter FormatParse fpModifiersfpCharfpRest FieldFormatfmtWidth fmtPrecision fmtAdjustfmtSign fmtAlternate fmtModifiersfmtChar FormatSignSignPlus SignSpaceFormatAdjustment LeftAdjustZeroPadIsChartoCharfromChar PrintfArg formatArg parseFormat HPrintfType PrintfTypeprintfhPrintfvFmt formatChar formatString formatInt formatIntegerformatRealFloatperrorerrorBadFormaterrorShortFormaterrorMissingArgumenterrorBadArgument $fIsCharChar$fPrintfArgDouble$fPrintfArgFloat$fPrintfArgNatural$fPrintfArgInteger$fPrintfArgWord64$fPrintfArgWord32$fPrintfArgWord16$fPrintfArgWord8$fPrintfArgWord$fPrintfArgInt64$fPrintfArgInt32$fPrintfArgInt16$fPrintfArgInt8$fPrintfArgInt $fPrintfArg[]$fPrintfArgChar$fHPrintfType(->)$fHPrintfTypeIO$fPrintfType(->)$fPrintfTypeIO$fPrintfType[] mkWeakPtr addFinalizer mkWeakPair StableNamemakeStableNamehashStableName eqStableName$fEqStableNameperformMinorGCperformMajorGCcompilerVersionosarch compilerName exitFailure exitSuccessdiegetExecutablePath getProgName lookupEnvsetEnvunsetEnvwithArgs withProgNamegetEnvironmentArgDescrNoArgReqArgOptArgOptDescrOptionArgOrder RequireOrderPermute ReturnInOrder usageInfogetOptgetOpt'$fFunctorArgOrder$fFunctorArgDescr$fFunctorOptDescrcpuTimePrecision getCPUTimegetField fromLabelUnique newUnique hashUnique $fEqUnique $fOrdUnique modifySTRef modifySTRef'approxRationalstrictToLazySTlazyToStrictSTMonadIOliftIO $fMonadIOIOGCStatsbytesAllocatednumGcs maxBytesUsednumByteUsageSamplescumulativeBytesUsed bytesCopiedcurrentBytesUsedcurrentBytesSlop maxBytesSloppeakMegabytesAllocatedmblocksAllocatedmutatorCpuSecondsmutatorWallSeconds gcCpuSeconds gcWallSeconds cpuSeconds wallSecondsparTotBytesCopiedparMaxBytesCopiedRtsTime GCDetails gcdetails_gengcdetails_threadsgcdetails_allocated_bytesgcdetails_live_bytesgcdetails_large_objects_bytesgcdetails_compact_bytesgcdetails_slop_bytesgcdetails_mem_in_use_bytesgcdetails_copied_bytesgcdetails_par_max_copied_bytesgcdetails_sync_elapsed_nsgcdetails_cpu_nsgcdetails_elapsed_nsRTSStatsgcs major_gcsallocated_bytesmax_live_bytesmax_large_objects_bytesmax_compact_bytesmax_slop_bytesmax_mem_in_use_bytescumulative_live_bytes copied_bytespar_copied_bytescumulative_par_max_copied_bytesmutator_cpu_nsmutator_elapsed_ns gc_cpu_ns gc_elapsed_nscpu_ns elapsed_nsgcgetRTSStatsEnabled getRTSStats getGCStatsgetGCStatsEnabled$fReadGCDetails$fShowGCDetails$fReadRTSStats$fShowRTSStats $fShowGCStats $fReadGCStatsRTSFlagsgcFlagsconcurrentFlags miscFlags debugFlagscostCentreFlagsprofilingFlags traceFlags tickyFlagsparFlagsParFlags nCapabilitiesmigratemaxLocalSparks parGcEnabledparGcGenparGcLoadBalancingEnabledparGcLoadBalancingGenparGcNoSyncWithIdle parGcThreads setAffinity TickyFlagsshowTickyStats tickyFile TraceFlagstracing timestamptraceSchedulertraceGc sparksSampled sparksFulluserDoTrace TraceNone TraceEventLog TraceStderr ProfFlags doHeapProfileheapProfileIntervalheapProfileIntervalTicks includeTSOsshowCCSOnExceptionmaxRetainerSetSize ccsLength modSelector descrSelector typeSelector ccSelector ccsSelectorretainerSelector bioSelector DoHeapProfileNoHeapProfiling HeapByCCS HeapByMod HeapByDescr HeapByTypeHeapByRetainer HeapByLDVHeapByClosureTypeCCFlags doCostCentres profilerTicks msecsPerTick DoCostCentresCostCentresNoneCostCentresSummaryCostCentresVerboseCostCentresAllCostCentresJSON DebugFlags scheduler interpreterweakgccafs block_allocsanitystableproflinkerstmsqueezehpcsparks MiscFlags tickIntervalinstallSignalHandlersmachineReadable linkerMemBase ConcFlagsctxtSwitchTimectxtSwitchTicksGCFlags statsFile giveStats maxStkSizeinitialStkSize stkChunkSizestkChunkBufferSize maxHeapSizeminAllocAreaSize largeAllocLimnurseryChunkSize minOldGenSizeheapSizeSuggestionheapSizeSuggestionAuto oldGenFactor pcFreeHeap generationssqueezeUpdFramescompactThresholdsweepringBellidleGCDelayTimedoIdleGCheapBaseallocLimitGracenumanumaMask GiveGCStats NoGCStatsCollectGCStatsOneLineGCStatsSummaryGCStatsVerboseGCStats getRTSFlags getGCFlags getParFlags getConcFlags getMiscFlags getDebugFlags getCCFlags getProfFlags getTraceFlags getTickyFlags$fEnumGiveGCStats$fEnumDoCostCentres$fEnumDoHeapProfile $fEnumDoTrace$fShowGiveGCStats $fShowGCFlags$fShowConcFlags$fShowMiscFlags$fShowDebugFlags$fShowDoCostCentres $fShowCCFlags$fShowDoHeapProfile$fShowProfFlags $fShowDoTrace$fShowTraceFlags$fShowTickyFlags$fShowParFlags$fShowRTSFlags StackTraceLocation objectName functionNamesrcLoc sourceFile sourceLine sourceColumn stackDepth stackFramescollectStackTraceinvalidateDebugCacheshowStackFrames getStackTraceshowStackTraceMonadZipmzipWithmunzip $fMonadZip:*: $fMonadZipM1$fMonadZipRec1$fMonadZipPar1 $fMonadZipU1$fMonadZipProxy $fMonadZipAlt$fMonadZipLast$fMonadZipFirst$fMonadZipMaybe$fMonadZipProduct $fMonadZipSum$fMonadZipDual$fMonadZipIdentity $fMonadZip[]Show2liftShowsPrec2 liftShowList2Read2liftReadsPrec2 liftReadList2 liftReadPrec2liftReadListPrec2Ord2 liftCompare2Eq2liftEq2Show1 liftShowsPrec liftShowListRead1 liftReadsPrec liftReadList liftReadPrecliftReadListPrecOrd1 liftCompareEq1liftEqeq1compare1 readsPrec1 readPrec1liftReadListDefaultliftReadListPrecDefault showsPrec1eq2compare2 readsPrec2 readPrec2liftReadList2DefaultliftReadListPrec2Default showsPrec2 readsDatareadDatareadsUnaryWith readUnaryWithreadsBinaryWithreadBinaryWithshowsUnaryWithshowsBinaryWith readsUnary readsUnary1 readsBinary1 showsUnary showsUnary1 showsBinary1 $fEq1Proxy $fEq1Identity$fEq1[] $fEq1Maybe $fOrd1Proxy$fOrd1Identity$fOrd1[] $fOrd1Maybe $fRead1Proxy$fRead1Identity $fRead1[] $fRead1Maybe $fShow1Proxy$fShow1Identity $fShow1[] $fShow1Maybe $fEq1Const $fEq2Const $fEq1Either $fEq2Either$fEq1(,)$fEq2(,) $fOrd1Const $fOrd2Const $fOrd1Either $fOrd2Either $fOrd1(,) $fOrd2(,) $fRead1Const $fRead2Const $fRead1Either $fRead2Either $fRead1(,) $fRead2(,) $fShow1Const $fShow2Const $fShow1Either $fShow2Either $fShow1(,) $fShow2(,) Bifunctorbimap $fBifunctorK1$fBifunctorConst$fBifunctorEither$fBifunctor(,,,,,,)$fBifunctor(,,,,,)$fBifunctor(,,,,)$fBifunctor(,,,)$fBifunctor(,,)$fBifunctor(,) Bifoldablebifold bifoldMapbifoldrbifoldlbifoldr'bifoldr1bifoldrMbifoldl'bifoldl1bifoldlM bitraverse_bifor_bimapM_biforM_ bisequenceA_ bisequence_biasumbimsumbiListbinullbilengthbielembiconcat bimaximum biminimumbisum biproduct biconcatMapbiandbiorbianybiall bimaximumBy biminimumBy binotElembifind$fBifoldableEither$fBifoldable(,,,,,,)$fBifoldable(,,,,,)$fBifoldable(,,,,)$fBifoldable(,,,)$fBifoldable(,,)$fBifoldableK1$fBifoldableConst$fBifoldable(,) Bitraversable bisequenceAbimapMbiforM bimapAccumL bimapAccumR bimapDefaultbifoldMapDefault$fBitraversableK1$fBitraversableConst$fBitraversableEither$fBitraversable(,,,,,,)$fBitraversable(,,,,,)$fBitraversable(,,,,)$fBitraversable(,,,)$fBitraversable(,,)$fBitraversable(,)QSemNnewQSemN waitQSemN signalQSemNQSemnewQSemwaitQSem signalQSemChannewChan writeChanreadChandupChan unGetChan isEmptyChangetChanContentswriteList2Chan$fEqChanrtsSupportsBoundThreads forkFinallyforkOSWithUnmaskisCurrentThreadBoundrunInBoundThreadrunInUnboundThreadtimeout$fExceptionTimeout $fShowTimeout $fEqTimeoutConIndex ConstrRep AlgConstr IntConstr FloatConstr CharConstrDataRepAlgRepCharRepNoRepConstrDataTypegfoldlgunfoldtoConstr dataTypeOf dataCast1 dataCast2gmapTgmapQlgmapQrgmapQgmapQigmapMgmapMpgmapMo fromConstr fromConstrB fromConstrM dataTypeName dataTypeRep constrType constrRep repConstr mkDataTypemkConstrdataTypeConstrs constrFields constrFixity showConstr readConstr isAlgType indexConstr constrIndexmaxConstrIndex mkIntType mkFloatType mkCharTypemkIntegralConstr mkRealConstr mkCharConstr mkNoRepType isNorepType tyconUQname tyconModule $fEqConstr $fShowConstr $fDataArray$fDataForeignPtr $fDataPtr$fData[] $fDataRatio $fDataWord64 $fDataWord32 $fDataWord16 $fDataWord8 $fDataWord $fDataInt64 $fDataInt32 $fDataInt16 $fDataInt8 $fDataNatural $fDataInteger $fDataInt $fDataDouble $fDataFloat $fDataChar $fEqConstrRep$fShowConstrRep$fShowDataType $fEqDataRep $fShowDataRep$fDataDecidedStrictness$fDataSourceStrictness$fDataSourceUnpackedness$fDataAssociativity $fDataFixity $fData:*:$fDataV1 $fData:.: $fData:+:$fDataM1$fDataK1 $fDataRec1 $fDataPar1$fDataU1 $fDataAlt $fDataLast $fDataFirst $fDataProduct $fDataSum $fDataAny $fDataAll $fDataDual $fDataVersion $fDataConst$fDataIdentity$fDataCoercion $fData:~~: $fData:~: $fDataProxy$fData(,,,,,,) $fData(,,,,,) $fData(,,,,) $fData(,,,) $fData(,,) $fData(,)$fData() $fDataEither$fDataOrdering $fDataMaybe $fDataBoolItemSpecConstrAnnotation NoSpecConstrForceSpecConstr maxTupleSizethesortWith$fIsListCallStack$fIsListVersion $fIsList[]$fDataSpecConstrAnnotation$fEqSpecConstrAnnotation spInfoUnitIdspInfoModuleName spInfoSrcLocIsStatic StaticKeydeRefStaticPtr staticKeyunsafeLookupStaticPtr staticPtrInfo staticPtrKeys$fIsStaticStaticPtr$fShowStaticPtrInfoVoidabsurdvacuous$fExceptionVoid$fIxVoid $fShowVoid $fReadVoid $fOrdVoid$fEqVoid $fGenericVoid $fDataVoidNonEmpty:|unfoldnonEmpty<|conssome1 groupAllWithgroup1groupBy1 groupWith1 groupAllWith1$fFoldableNonEmpty$fTraversableNonEmpty$fMonadNonEmpty$fApplicativeNonEmpty$fFunctorNonEmpty$fMonadZipNonEmpty$fMonadFixNonEmpty$fIsListNonEmpty$fShow1NonEmpty$fRead1NonEmpty$fOrd1NonEmpty $fEq1NonEmpty $fEqNonEmpty $fOrdNonEmpty$fShowNonEmpty$fReadNonEmpty$fDataNonEmpty$fGenericNonEmpty$fGeneric1NonEmpty getOption WrappedMonoid WrapMonoid unwrapMonoidArgMaxArgMinArgMaxgetMaxMingetMinsconcatstimescycle1 stimesMonoidstimesIdempotentMonoidstimesIdempotent mtimesDefaultdiff$fSemigroupLifetime$fSemigroupEvent $fSemigroupIO$fSemigroupProxy$fSemigroupNonEmpty$fSemigroupVoid$fSemigroupAlt$fSemigroupLast$fSemigroupFirst$fSemigroupConst$fSemigroupIdentity$fSemigroupProduct$fSemigroupSum$fSemigroupAny$fSemigroupAll$fSemigroupEndo$fSemigroupDual$fSemigroupOrdering$fSemigroup(,,,,)$fSemigroup(,,,)$fSemigroup(,,)$fSemigroup(,)$fSemigroupEither$fSemigroupMaybe $fSemigroup[]$fSemigroup(->) $fSemigroup()$fNumMin $fMonadFixMin $fMonadMin$fApplicativeMin$fTraversableMin $fFoldableMin $fFunctorMin $fMonoidMin$fSemigroupMin $fEnumMin$fNumMax $fMonadFixMax $fMonadMax$fApplicativeMax$fTraversableMax $fFoldableMax $fFunctorMax $fMonoidMax$fSemigroupMax $fEnumMax$fBitraversableArg$fBifoldableArg$fBifunctorArg$fOrdArg$fEqArg$fTraversableArg $fFoldableArg $fFunctorArg$fSemigroupFirst0 $fEnumFirst$fSemigroupLast0 $fEnumLast$fEnumWrappedMonoid$fMonoidWrappedMonoid$fSemigroupWrappedMonoid$fMonoidOption$fSemigroupOption$fTraversableOption$fFoldableOption$fMonadFixOption$fMonadPlusOption$fAlternativeOption $fMonadOption$fApplicativeOption$fFunctorOption $fBoundedMin$fEqMin$fOrdMin $fShowMin $fReadMin $fDataMin $fGenericMin $fGeneric1Min $fBoundedMax$fEqMax$fOrdMax $fShowMax $fReadMax $fDataMax $fGenericMax $fGeneric1Max $fShowArg $fReadArg $fDataArg $fGenericArg $fGeneric1Arg$fBoundedFirst $fBoundedLast$fBoundedWrappedMonoid$fEqWrappedMonoid$fOrdWrappedMonoid$fShowWrappedMonoid$fReadWrappedMonoid$fDataWrappedMonoid$fGenericWrappedMonoid$fGeneric1WrappedMonoid $fEqOption $fOrdOption $fShowOption $fReadOption $fDataOption$fGenericOption$fGeneric1OptionInLInR $fShow1Sum $fRead1Sum $fOrd1Sum$fEq1SumPair$fMonadPlusProduct$fAlternativeProduct$fShow1Product$fRead1Product $fOrd1Product $fEq1ProductCompose getCompose$fAlternativeCompose$fApplicativeCompose$fTraversableCompose$fFoldableCompose$fFunctorCompose $fShowCompose $fReadCompose $fOrdCompose $fEqCompose$fShow1Compose$fRead1Compose $fOrd1Compose $fEq1Compose $fDataCompose$fGenericCompose$fGeneric1ComposePicoE12NanoE9MicroE6MilliE3CentiE2DeciE1UniE0 HasResolution resolutionFixedMkFixeddiv'divMod'mod' showFixed $fEnumFixed $fDataFixed $fReadFixed $fShowFixed$fRealFracFixed$fFractionalFixed $fRealFixed $fNumFixed$fHasResolutionE0$fHasResolutionE1$fHasResolutionE2$fHasResolutionE3$fHasResolutionE6$fHasResolutionE9$fHasResolutionE12 $fEqFixed $fOrdFixedComplex:+realPartimagPart conjugatemkPolarcispolar magnitudephase$fMonadComplex$fApplicativeComplex$fStorableComplex$fFloatingComplex$fFractionalComplex $fNumComplex $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1Complex$fFunctorComplex$fFoldableComplex$fTraversableComplexFreezeCallStackEmptyCallStack PushCallStack absentErreqStringgetTag $fMonoidMaybe$fMonoidOrdering$fMonoid(,,,,) $fMonoid(,,,) $fMonoid(,,) $fMonoid(,) $fMonoid() $fMonoid(->) $fMonoid[] $fFunctor[]$fFunctorMaybe $fFunctor(,) $fFunctor(->)$fApplicativeIO$fApplicative[]$fApplicativeMaybe$fApplicative(->) $fMonoidIO$fApplicative(,)$fAlternativeIO$fAlternative[]$fAlternativeMaybe $fMonadIO $fFunctorIO $fMonad[] $fMonadMaybe $fMonad(->) $fMonad(,) $fMonadPlusIO $fMonadPlus[]$fMonadPlusMaybe realWorld# GHC.CStringunpackCStringUtf8#unpackFoldrCString#unpackCString#void#divInt#modInt# unsafeCoerce#bindIOreturnIO nullAddr#thenIOnoinline magicDictproxy#IPipAddr#Array# ByteArray#Char#Double#Float#Int#Int32#Int64#Weak# MutableArray#MutableByteArray#MVar# StablePtr# ArrayArray#MutableArrayArray#State# StableName#~#MutVar#Void#Word#Word32#Word64# ThreadId#BCO#TVar#Compact#OpaqueOProxy#SPECSPEC2 SmallArray#SmallMutableArray#Int8X16#Int16X8#Int32X4#Int64X2#Int8X32# Int16X16#Int32X8#Int64X4#Int8X64# Int16X32# Int32X16#Int64X8# Word8X16# Word16X8# Word32X4# Word64X2# Word8X32# Word16X16# Word32X8# Word64X4# Word8X64# Word16X32# Word32X16# Word64X8#FloatX4# DoubleX2#FloatX8# DoubleX4# FloatX16# DoubleX8#TrNameTrNameSTrNameDgtChar#geChar#eqChar#neChar#ltChar#leChar#ord#+#-#*#mulIntMayOflo#quotInt#remInt# quotRemInt#andI#orI#xorI#notI# negateInt#addIntC#subIntC#>#>=#==#/=#<#<=#chr# int2Word# int2Float# int2Double# word2Float# word2Double#uncheckedIShiftL#uncheckedIShiftRA#uncheckedIShiftRL# plusWord# subWordC# plusWord2# minusWord# timesWord# timesWord2# quotWord#remWord# quotRemWord# quotRemWord2#and#or#xor#not#uncheckedShiftL#uncheckedShiftRL# word2Int#gtWord#geWord#eqWord#neWord#ltWord#leWord#popCnt8# popCnt16# popCnt32# popCnt64#popCnt#clz8#clz16#clz32#clz64#clz#ctz8#ctz16#ctz32#ctz64#ctz# byteSwap16# byteSwap32# byteSwap64# byteSwap# narrow8Int# narrow16Int# narrow32Int# narrow8Word# narrow16Word# narrow32Word#>##>=##==##/=##<##<=##+##-##*##/## negateDouble# fabsDouble# double2Int# double2Float# expDouble# logDouble# sqrtDouble# sinDouble# cosDouble# tanDouble# asinDouble# acosDouble# atanDouble# sinhDouble# coshDouble# tanhDouble#**##decodeDouble_2Int#decodeDouble_Int64#gtFloat#geFloat#eqFloat#neFloat#ltFloat#leFloat# plusFloat# minusFloat# timesFloat# divideFloat# negateFloat# fabsFloat# float2Int# expFloat# logFloat# sqrtFloat# sinFloat# cosFloat# tanFloat# asinFloat# acosFloat# atanFloat# sinhFloat# coshFloat# tanhFloat# powerFloat# float2Double#decodeFloat_Int# newArray#sameMutableArray# readArray# writeArray# sizeofArray#sizeofMutableArray# indexArray#unsafeFreezeArray#unsafeThawArray# copyArray#copyMutableArray# cloneArray#cloneMutableArray# freezeArray# thawArray# casArray#newSmallArray#sameSmallMutableArray#readSmallArray#writeSmallArray#sizeofSmallArray#sizeofSmallMutableArray#indexSmallArray#unsafeFreezeSmallArray#unsafeThawSmallArray#copySmallArray#copySmallMutableArray#cloneSmallArray#cloneSmallMutableArray#freezeSmallArray#thawSmallArray#casSmallArray# newByteArray#newPinnedByteArray#newAlignedPinnedByteArray#isMutableByteArrayPinned#isByteArrayPinned#byteArrayContents#sameMutableByteArray#shrinkMutableByteArray#resizeMutableByteArray#unsafeFreezeByteArray#sizeofByteArray#sizeofMutableByteArray#getSizeofMutableByteArray#indexCharArray#indexWideCharArray#indexIntArray#indexWordArray#indexAddrArray#indexFloatArray#indexDoubleArray#indexStablePtrArray#indexInt8Array#indexInt16Array#indexInt32Array#indexInt64Array#indexWord8Array#indexWord16Array#indexWord32Array#indexWord64Array#readCharArray#readWideCharArray# readIntArray#readWordArray#readAddrArray#readFloatArray#readDoubleArray#readStablePtrArray#readInt8Array#readInt16Array#readInt32Array#readInt64Array#readWord8Array#readWord16Array#readWord32Array#readWord64Array#writeCharArray#writeWideCharArray#writeIntArray#writeWordArray#writeAddrArray#writeFloatArray#writeDoubleArray#writeStablePtrArray#writeInt8Array#writeInt16Array#writeInt32Array#writeInt64Array#writeWord8Array#writeWord16Array#writeWord32Array#writeWord64Array#copyByteArray#copyMutableByteArray#copyByteArrayToAddr#copyMutableByteArrayToAddr#copyAddrToByteArray# setByteArray#atomicReadIntArray#atomicWriteIntArray# casIntArray#fetchAddIntArray#fetchSubIntArray#fetchAndIntArray#fetchNandIntArray#fetchOrIntArray#fetchXorIntArray#newArrayArray#sameMutableArrayArray#unsafeFreezeArrayArray#sizeofArrayArray#sizeofMutableArrayArray#indexByteArrayArray#indexArrayArrayArray#readByteArrayArray#readMutableByteArrayArray#readArrayArrayArray#readMutableArrayArrayArray#writeByteArrayArray#writeMutableByteArrayArray#writeArrayArrayArray#writeMutableArrayArrayArray#copyArrayArray#copyMutableArrayArray# plusAddr# minusAddr#remAddr# addr2Int# int2Addr#gtAddr#geAddr#eqAddr#neAddr#ltAddr#leAddr#indexCharOffAddr#indexWideCharOffAddr#indexIntOffAddr#indexWordOffAddr#indexAddrOffAddr#indexFloatOffAddr#indexDoubleOffAddr#indexStablePtrOffAddr#indexInt8OffAddr#indexInt16OffAddr#indexInt32OffAddr#indexInt64OffAddr#indexWord8OffAddr#indexWord16OffAddr#indexWord32OffAddr#indexWord64OffAddr#readCharOffAddr#readWideCharOffAddr#readIntOffAddr#readWordOffAddr#readAddrOffAddr#readFloatOffAddr#readDoubleOffAddr#readStablePtrOffAddr#readInt8OffAddr#readInt16OffAddr#readInt32OffAddr#readInt64OffAddr#readWord8OffAddr#readWord16OffAddr#readWord32OffAddr#readWord64OffAddr#writeCharOffAddr#writeWideCharOffAddr#writeIntOffAddr#writeWordOffAddr#writeAddrOffAddr#writeFloatOffAddr#writeDoubleOffAddr#writeStablePtrOffAddr#writeInt8OffAddr#writeInt16OffAddr#writeInt32OffAddr#writeInt64OffAddr#writeWord8OffAddr#writeWord16OffAddr#writeWord32OffAddr#writeWord64OffAddr# newMutVar# readMutVar# writeMutVar# sameMutVar#atomicModifyMutVar# casMutVar#catch#raise#raiseIO#maskAsyncExceptions#maskUninterruptible#unmaskAsyncExceptions#getMaskingState# atomically#retry# catchRetry# catchSTM#check#newTVar# readTVar# readTVarIO# writeTVar# sameTVar#newMVar# takeMVar# tryTakeMVar#putMVar# tryPutMVar# readMVar# tryReadMVar# sameMVar# isEmptyMVar#delay# waitRead# waitWrite#fork#forkOn# killThread#yield# myThreadId# labelThread#isCurrentThreadBound# noDuplicate# threadStatus#mkWeak#mkWeakNoFinalizer#addCFinalizerToWeak# deRefWeak# finalizeWeak#touch#makeStablePtr#deRefStablePtr# eqStablePtr#makeStableName# eqStableName#stableNameToInt# compactNew#compactResize#compactContains#compactContainsAny#compactGetFirstBlock#compactGetNextBlock#compactAllocateBlock#compactFixupPointers# compactAdd#compactAddWithSharing# compactSize#reallyUnsafePtrEquality#par#spark#seq# getSpark# numSparks# dataToTag# tagToEnum# addrToAny# anyToAddr# mkApUpd0#newBCO#unpackClosure#getApStackVal# getCCSOf#getCurrentCCS# clearCCS# traceEvent# traceMarker#broadcastInt8X16#broadcastInt16X8#broadcastInt32X4#broadcastInt64X2#broadcastInt8X32#broadcastInt16X16#broadcastInt32X8#broadcastInt64X4#broadcastInt8X64#broadcastInt16X32#broadcastInt32X16#broadcastInt64X8#broadcastWord8X16#broadcastWord16X8#broadcastWord32X4#broadcastWord64X2#broadcastWord8X32#broadcastWord16X16#broadcastWord32X8#broadcastWord64X4#broadcastWord8X64#broadcastWord16X32#broadcastWord32X16#broadcastWord64X8#broadcastFloatX4#broadcastDoubleX2#broadcastFloatX8#broadcastDoubleX4#broadcastFloatX16#broadcastDoubleX8# packInt8X16# packInt16X8# packInt32X4# packInt64X2# packInt8X32# packInt16X16# packInt32X8# packInt64X4# packInt8X64# packInt16X32# packInt32X16# packInt64X8# packWord8X16# packWord16X8# packWord32X4# packWord64X2# packWord8X32#packWord16X16# packWord32X8# packWord64X4# packWord8X64#packWord16X32#packWord32X16# packWord64X8# packFloatX4# packDoubleX2# packFloatX8# packDoubleX4# packFloatX16# packDoubleX8#unpackInt8X16#unpackInt16X8#unpackInt32X4#unpackInt64X2#unpackInt8X32#unpackInt16X16#unpackInt32X8#unpackInt64X4#unpackInt8X64#unpackInt16X32#unpackInt32X16#unpackInt64X8#unpackWord8X16#unpackWord16X8#unpackWord32X4#unpackWord64X2#unpackWord8X32#unpackWord16X16#unpackWord32X8#unpackWord64X4#unpackWord8X64#unpackWord16X32#unpackWord32X16#unpackWord64X8#unpackFloatX4#unpackDoubleX2#unpackFloatX8#unpackDoubleX4#unpackFloatX16#unpackDoubleX8#insertInt8X16#insertInt16X8#insertInt32X4#insertInt64X2#insertInt8X32#insertInt16X16#insertInt32X8#insertInt64X4#insertInt8X64#insertInt16X32#insertInt32X16#insertInt64X8#insertWord8X16#insertWord16X8#insertWord32X4#insertWord64X2#insertWord8X32#insertWord16X16#insertWord32X8#insertWord64X4#insertWord8X64#insertWord16X32#insertWord32X16#insertWord64X8#insertFloatX4#insertDoubleX2#insertFloatX8#insertDoubleX4#insertFloatX16#insertDoubleX8# plusInt8X16# plusInt16X8# plusInt32X4# plusInt64X2# plusInt8X32# plusInt16X16# plusInt32X8# plusInt64X4# plusInt8X64# plusInt16X32# plusInt32X16# plusInt64X8# plusWord8X16# plusWord16X8# plusWord32X4# plusWord64X2# plusWord8X32#plusWord16X16# plusWord32X8# plusWord64X4# plusWord8X64#plusWord16X32#plusWord32X16# plusWord64X8# plusFloatX4# plusDoubleX2# plusFloatX8# plusDoubleX4# plusFloatX16# plusDoubleX8# minusInt8X16# minusInt16X8# minusInt32X4# minusInt64X2# minusInt8X32#minusInt16X16# minusInt32X8# minusInt64X4# minusInt8X64#minusInt16X32#minusInt32X16# minusInt64X8#minusWord8X16#minusWord16X8#minusWord32X4#minusWord64X2#minusWord8X32#minusWord16X16#minusWord32X8#minusWord64X4#minusWord8X64#minusWord16X32#minusWord32X16#minusWord64X8# minusFloatX4#minusDoubleX2# minusFloatX8#minusDoubleX4#minusFloatX16#minusDoubleX8# timesInt8X16# timesInt16X8# timesInt32X4# timesInt64X2# timesInt8X32#timesInt16X16# timesInt32X8# timesInt64X4# timesInt8X64#timesInt16X32#timesInt32X16# timesInt64X8#timesWord8X16#timesWord16X8#timesWord32X4#timesWord64X2#timesWord8X32#timesWord16X16#timesWord32X8#timesWord64X4#timesWord8X64#timesWord16X32#timesWord32X16#timesWord64X8# timesFloatX4#timesDoubleX2# timesFloatX8#timesDoubleX4#timesFloatX16#timesDoubleX8#divideFloatX4#divideDoubleX2#divideFloatX8#divideDoubleX4#divideFloatX16#divideDoubleX8# quotInt8X16# quotInt16X8# quotInt32X4# quotInt64X2# quotInt8X32# quotInt16X16# quotInt32X8# quotInt64X4# quotInt8X64# quotInt16X32# quotInt32X16# quotInt64X8# quotWord8X16# quotWord16X8# quotWord32X4# quotWord64X2# quotWord8X32#quotWord16X16# quotWord32X8# quotWord64X4# quotWord8X64#quotWord16X32#quotWord32X16# quotWord64X8# remInt8X16# remInt16X8# remInt32X4# remInt64X2# remInt8X32# remInt16X16# remInt32X8# remInt64X4# remInt8X64# remInt16X32# remInt32X16# remInt64X8# remWord8X16# remWord16X8# remWord32X4# remWord64X2# remWord8X32# remWord16X16# remWord32X8# remWord64X4# remWord8X64# remWord16X32# remWord32X16# remWord64X8#negateInt8X16#negateInt16X8#negateInt32X4#negateInt64X2#negateInt8X32#negateInt16X16#negateInt32X8#negateInt64X4#negateInt8X64#negateInt16X32#negateInt32X16#negateInt64X8#negateFloatX4#negateDoubleX2#negateFloatX8#negateDoubleX4#negateFloatX16#negateDoubleX8#indexInt8X16Array#indexInt16X8Array#indexInt32X4Array#indexInt64X2Array#indexInt8X32Array#indexInt16X16Array#indexInt32X8Array#indexInt64X4Array#indexInt8X64Array#indexInt16X32Array#indexInt32X16Array#indexInt64X8Array#indexWord8X16Array#indexWord16X8Array#indexWord32X4Array#indexWord64X2Array#indexWord8X32Array#indexWord16X16Array#indexWord32X8Array#indexWord64X4Array#indexWord8X64Array#indexWord16X32Array#indexWord32X16Array#indexWord64X8Array#indexFloatX4Array#indexDoubleX2Array#indexFloatX8Array#indexDoubleX4Array#indexFloatX16Array#indexDoubleX8Array#readInt8X16Array#readInt16X8Array#readInt32X4Array#readInt64X2Array#readInt8X32Array#readInt16X16Array#readInt32X8Array#readInt64X4Array#readInt8X64Array#readInt16X32Array#readInt32X16Array#readInt64X8Array#readWord8X16Array#readWord16X8Array#readWord32X4Array#readWord64X2Array#readWord8X32Array#readWord16X16Array#readWord32X8Array#readWord64X4Array#readWord8X64Array#readWord16X32Array#readWord32X16Array#readWord64X8Array#readFloatX4Array#readDoubleX2Array#readFloatX8Array#readDoubleX4Array#readFloatX16Array#readDoubleX8Array#writeInt8X16Array#writeInt16X8Array#writeInt32X4Array#writeInt64X2Array#writeInt8X32Array#writeInt16X16Array#writeInt32X8Array#writeInt64X4Array#writeInt8X64Array#writeInt16X32Array#writeInt32X16Array#writeInt64X8Array#writeWord8X16Array#writeWord16X8Array#writeWord32X4Array#writeWord64X2Array#writeWord8X32Array#writeWord16X16Array#writeWord32X8Array#writeWord64X4Array#writeWord8X64Array#writeWord16X32Array#writeWord32X16Array#writeWord64X8Array#writeFloatX4Array#writeDoubleX2Array#writeFloatX8Array#writeDoubleX4Array#writeFloatX16Array#writeDoubleX8Array#indexInt8X16OffAddr#indexInt16X8OffAddr#indexInt32X4OffAddr#indexInt64X2OffAddr#indexInt8X32OffAddr#indexInt16X16OffAddr#indexInt32X8OffAddr#indexInt64X4OffAddr#indexInt8X64OffAddr#indexInt16X32OffAddr#indexInt32X16OffAddr#indexInt64X8OffAddr#indexWord8X16OffAddr#indexWord16X8OffAddr#indexWord32X4OffAddr#indexWord64X2OffAddr#indexWord8X32OffAddr#indexWord16X16OffAddr#indexWord32X8OffAddr#indexWord64X4OffAddr#indexWord8X64OffAddr#indexWord16X32OffAddr#indexWord32X16OffAddr#indexWord64X8OffAddr#indexFloatX4OffAddr#indexDoubleX2OffAddr#indexFloatX8OffAddr#indexDoubleX4OffAddr#indexFloatX16OffAddr#indexDoubleX8OffAddr#readInt8X16OffAddr#readInt16X8OffAddr#readInt32X4OffAddr#readInt64X2OffAddr#readInt8X32OffAddr#readInt16X16OffAddr#readInt32X8OffAddr#readInt64X4OffAddr#readInt8X64OffAddr#readInt16X32OffAddr#readInt32X16OffAddr#readInt64X8OffAddr#readWord8X16OffAddr#readWord16X8OffAddr#readWord32X4OffAddr#readWord64X2OffAddr#readWord8X32OffAddr#readWord16X16OffAddr#readWord32X8OffAddr#readWord64X4OffAddr#readWord8X64OffAddr#readWord16X32OffAddr#readWord32X16OffAddr#readWord64X8OffAddr#readFloatX4OffAddr#readDoubleX2OffAddr#readFloatX8OffAddr#readDoubleX4OffAddr#readFloatX16OffAddr#readDoubleX8OffAddr#writeInt8X16OffAddr#writeInt16X8OffAddr#writeInt32X4OffAddr#writeInt64X2OffAddr#writeInt8X32OffAddr#writeInt16X16OffAddr#writeInt32X8OffAddr#writeInt64X4OffAddr#writeInt8X64OffAddr#writeInt16X32OffAddr#writeInt32X16OffAddr#writeInt64X8OffAddr#writeWord8X16OffAddr#writeWord16X8OffAddr#writeWord32X4OffAddr#writeWord64X2OffAddr#writeWord8X32OffAddr#writeWord16X16OffAddr#writeWord32X8OffAddr#writeWord64X4OffAddr#writeWord8X64OffAddr#writeWord16X32OffAddr#writeWord32X16OffAddr#writeWord64X8OffAddr#writeFloatX4OffAddr#writeDoubleX2OffAddr#writeFloatX8OffAddr#writeDoubleX4OffAddr#writeFloatX16OffAddr#writeDoubleX8OffAddr#indexInt8ArrayAsInt8X16#indexInt16ArrayAsInt16X8#indexInt32ArrayAsInt32X4#indexInt64ArrayAsInt64X2#indexInt8ArrayAsInt8X32#indexInt16ArrayAsInt16X16#indexInt32ArrayAsInt32X8#indexInt64ArrayAsInt64X4#indexInt8ArrayAsInt8X64#indexInt16ArrayAsInt16X32#indexInt32ArrayAsInt32X16#indexInt64ArrayAsInt64X8#indexWord8ArrayAsWord8X16#indexWord16ArrayAsWord16X8#indexWord32ArrayAsWord32X4#indexWord64ArrayAsWord64X2#indexWord8ArrayAsWord8X32#indexWord16ArrayAsWord16X16#indexWord32ArrayAsWord32X8#indexWord64ArrayAsWord64X4#indexWord8ArrayAsWord8X64#indexWord16ArrayAsWord16X32#indexWord32ArrayAsWord32X16#indexWord64ArrayAsWord64X8#indexFloatArrayAsFloatX4#indexDoubleArrayAsDoubleX2#indexFloatArrayAsFloatX8#indexDoubleArrayAsDoubleX4#indexFloatArrayAsFloatX16#indexDoubleArrayAsDoubleX8#readInt8ArrayAsInt8X16#readInt16ArrayAsInt16X8#readInt32ArrayAsInt32X4#readInt64ArrayAsInt64X2#readInt8ArrayAsInt8X32#readInt16ArrayAsInt16X16#readInt32ArrayAsInt32X8#readInt64ArrayAsInt64X4#readInt8ArrayAsInt8X64#readInt16ArrayAsInt16X32#readInt32ArrayAsInt32X16#readInt64ArrayAsInt64X8#readWord8ArrayAsWord8X16#readWord16ArrayAsWord16X8#readWord32ArrayAsWord32X4#readWord64ArrayAsWord64X2#readWord8ArrayAsWord8X32#readWord16ArrayAsWord16X16#readWord32ArrayAsWord32X8#readWord64ArrayAsWord64X4#readWord8ArrayAsWord8X64#readWord16ArrayAsWord16X32#readWord32ArrayAsWord32X16#readWord64ArrayAsWord64X8#readFloatArrayAsFloatX4#readDoubleArrayAsDoubleX2#readFloatArrayAsFloatX8#readDoubleArrayAsDoubleX4#readFloatArrayAsFloatX16#readDoubleArrayAsDoubleX8#writeInt8ArrayAsInt8X16#writeInt16ArrayAsInt16X8#writeInt32ArrayAsInt32X4#writeInt64ArrayAsInt64X2#writeInt8ArrayAsInt8X32#writeInt16ArrayAsInt16X16#writeInt32ArrayAsInt32X8#writeInt64ArrayAsInt64X4#writeInt8ArrayAsInt8X64#writeInt16ArrayAsInt16X32#writeInt32ArrayAsInt32X16#writeInt64ArrayAsInt64X8#writeWord8ArrayAsWord8X16#writeWord16ArrayAsWord16X8#writeWord32ArrayAsWord32X4#writeWord64ArrayAsWord64X2#writeWord8ArrayAsWord8X32#writeWord16ArrayAsWord16X16#writeWord32ArrayAsWord32X8#writeWord64ArrayAsWord64X4#writeWord8ArrayAsWord8X64#writeWord16ArrayAsWord16X32#writeWord32ArrayAsWord32X16#writeWord64ArrayAsWord64X8#writeFloatArrayAsFloatX4#writeDoubleArrayAsDoubleX2#writeFloatArrayAsFloatX8#writeDoubleArrayAsDoubleX4#writeFloatArrayAsFloatX16#writeDoubleArrayAsDoubleX8#indexInt8OffAddrAsInt8X16#indexInt16OffAddrAsInt16X8#indexInt32OffAddrAsInt32X4#indexInt64OffAddrAsInt64X2#indexInt8OffAddrAsInt8X32#indexInt16OffAddrAsInt16X16#indexInt32OffAddrAsInt32X8#indexInt64OffAddrAsInt64X4#indexInt8OffAddrAsInt8X64#indexInt16OffAddrAsInt16X32#indexInt32OffAddrAsInt32X16#indexInt64OffAddrAsInt64X8#indexWord8OffAddrAsWord8X16#indexWord16OffAddrAsWord16X8#indexWord32OffAddrAsWord32X4#indexWord64OffAddrAsWord64X2#indexWord8OffAddrAsWord8X32#indexWord16OffAddrAsWord16X16#indexWord32OffAddrAsWord32X8#indexWord64OffAddrAsWord64X4#indexWord8OffAddrAsWord8X64#indexWord16OffAddrAsWord16X32#indexWord32OffAddrAsWord32X16#indexWord64OffAddrAsWord64X8#indexFloatOffAddrAsFloatX4#indexDoubleOffAddrAsDoubleX2#indexFloatOffAddrAsFloatX8#indexDoubleOffAddrAsDoubleX4#indexFloatOffAddrAsFloatX16#indexDoubleOffAddrAsDoubleX8#readInt8OffAddrAsInt8X16#readInt16OffAddrAsInt16X8#readInt32OffAddrAsInt32X4#readInt64OffAddrAsInt64X2#readInt8OffAddrAsInt8X32#readInt16OffAddrAsInt16X16#readInt32OffAddrAsInt32X8#readInt64OffAddrAsInt64X4#readInt8OffAddrAsInt8X64#readInt16OffAddrAsInt16X32#readInt32OffAddrAsInt32X16#readInt64OffAddrAsInt64X8#readWord8OffAddrAsWord8X16#readWord16OffAddrAsWord16X8#readWord32OffAddrAsWord32X4#readWord64OffAddrAsWord64X2#readWord8OffAddrAsWord8X32#readWord16OffAddrAsWord16X16#readWord32OffAddrAsWord32X8#readWord64OffAddrAsWord64X4#readWord8OffAddrAsWord8X64#readWord16OffAddrAsWord16X32#readWord32OffAddrAsWord32X16#readWord64OffAddrAsWord64X8#readFloatOffAddrAsFloatX4#readDoubleOffAddrAsDoubleX2#readFloatOffAddrAsFloatX8#readDoubleOffAddrAsDoubleX4#readFloatOffAddrAsFloatX16#readDoubleOffAddrAsDoubleX8#writeInt8OffAddrAsInt8X16#writeInt16OffAddrAsInt16X8#writeInt32OffAddrAsInt32X4#writeInt64OffAddrAsInt64X2#writeInt8OffAddrAsInt8X32#writeInt16OffAddrAsInt16X16#writeInt32OffAddrAsInt32X8#writeInt64OffAddrAsInt64X4#writeInt8OffAddrAsInt8X64#writeInt16OffAddrAsInt16X32#writeInt32OffAddrAsInt32X16#writeInt64OffAddrAsInt64X8#writeWord8OffAddrAsWord8X16#writeWord16OffAddrAsWord16X8#writeWord32OffAddrAsWord32X4#writeWord64OffAddrAsWord64X2#writeWord8OffAddrAsWord8X32#writeWord16OffAddrAsWord16X16#writeWord32OffAddrAsWord32X8#writeWord64OffAddrAsWord64X4#writeWord8OffAddrAsWord8X64#writeWord16OffAddrAsWord16X32#writeWord32OffAddrAsWord32X16#writeWord64OffAddrAsWord64X8#writeFloatOffAddrAsFloatX4#writeDoubleOffAddrAsDoubleX2#writeFloatOffAddrAsFloatX8#writeDoubleOffAddrAsDoubleX4#writeFloatOffAddrAsFloatX16#writeDoubleOffAddrAsDoubleX8#prefetchByteArray3#prefetchMutableByteArray3#prefetchAddr3#prefetchValue3#prefetchByteArray2#prefetchMutableByteArray2#prefetchAddr2#prefetchValue2#prefetchByteArray1#prefetchMutableByteArray1#prefetchAddr1#prefetchValue1#prefetchByteArray0#prefetchMutableByteArray0#prefetchAddr0#prefetchValue0# compareWord# compareWordleWordltWordgeWordgtWord compareInt# compareIntleIntltIntgeIntgtIntneInteqInteqDoubleeqFloatneWordeqWord unpackNBytes#unpackAppendCString#KindBndrmapFB unsafeChrminIntmaxIntunIOquotIntremIntdivIntmodInt quotRemInt divModInt divModInt#[::]PArr $fNumInteger $fNumWord$fNumInt mkInteger smallInteger integerToWord integerToInt plusInteger timesInteger minusInteger negateInteger eqInteger# neqInteger# absInteger signumInteger leInteger# gtInteger# ltInteger# geInteger#compareInteger quotInteger remInteger divInteger modInteger divModIntegerquotRemIntegerfloatFromIntegerdoubleFromIntegerencodeFloatIntegerencodeDoubleInteger andInteger orInteger xorIntegercomplementInteger shiftLInteger shiftRInteger wordToIntegerdecodeDoubleIntegertestBitInteger geInteger gtInteger ltInteger leInteger eqInteger neqInteger hashInteger$fEqMVarunsafeDupableInterleaveIO noDuplicate GHCiSandboxIONoIO$fGHCiSandboxIOIO$fGHCiSandboxIONoIO $fMonadNoIO$fApplicativeNoIO $fFunctorNoIO ghciStepIOnoioproperFractionFloatInt floorFloatIntceilingFloatInt roundFloatIntproperFractionFloatIntegertruncateFloatIntegerfloorFloatIntegerceilingFloatIntegerroundFloatIntegerproperFractionDoubleIntfloorDoubleIntceilingDoubleIntroundDoubleIntproperFractionDoubleIntegertruncateDoubleIntegerfloorDoubleIntegerceilingDoubleIntegerroundDoubleInteger double2Int int2Double float2Int int2FloatelimZerosInteger elimZerosInt#BAArrsizeerrorEmptyList showLitStringshowMultiLineString $fShowInteger$fShow(,,,,,,,,,,,,,,)$fShow(,,,,,,,,,,,,,)$fShow(,,,,,,,,,,,,)$fShow(,,,,,,,,,,,)$fShow(,,,,,,,,,,)$fShow(,,,,,,,,,)$fShow(,,,,,,,,)$fShow(,,,,,,,)$fShow(,,,,,,) $fShow(,,,,,) $fShow(,,,,) $fShow(,,,) $fShow(,,) $fShow(,)$fShowCallStack $fShowModule $fShowTrName $fShowTyCon $fShowWord $fShowInt $fShowChar$fShow[] showList__appPrecappPrec1 showSpaceshowCommaSpace protectEscasciiTab showSignedInt$fShowST $fMonadST$fApplicativeST $fFunctorSTSTretSTRepliftST $fEqSTRef $fShowUniqueasInt UniqueSource newSourceUS $fBoundedWord $fBoundedInt $fBoundedChar $fEnumInteger $fEnumWord $fEnumInt $fEnumChar$fEnumOrdering $fEnumBool$fEnum() $fEnumVecElem$fBoundedVecElem$fEnumVecCount$fBoundedVecCount$fBoundedOrdering $fBoundedBool$fBounded(,,,,,,,,,,,,,,)$fBounded(,,,,,,,,,,,,,)$fBounded(,,,,,,,,,,,,)$fBounded(,,,,,,,,,,,)$fBounded(,,,,,,,,,,)$fBounded(,,,,,,,,,)$fBounded(,,,,,,,,)$fBounded(,,,,,,,)$fBounded(,,,,,,)$fBounded(,,,,,)$fBounded(,,,,)$fBounded(,,,) $fBounded(,,) $fBounded(,) $fBounded()boundedEnumFromboundedEnumFromThen toEnumError fromEnumError succError predErrorreduce $fShowRatio $fRealInteger $fRealRatio $fNumRatio $fOrdRatio$fIntegralInteger$fIntegralWord $fRealWord $fIntegralInt $fRealInt$fFractionalRatio $fEnumRatio$fRealFracRatio:% divZeroErrorratioZeroDenominatorError overflowError ratioPrec ratioPrec1infinity notANumbernumericEnumFromnumericEnumFromThennumericEnumFromTonumericEnumFromThenTo^%^^^%^^gcdInt'gcdWord'integralEnumFromintegralEnumFromThenintegralEnumFromTointegralEnumFromThenToSTArrayArray unsafeIndexunsafeRangeSizearraybounds listArray! numElementsindiceselems foldrElems foldlElems foldrElems' foldlElems' foldl1Elems foldr1Elemsassocs accumArray//accumixmap $fIx(,,,,) $fIx(,,,)$fIx(,,)$fIx(,)$fIx() $fIxOrdering$fIxBool $fIxInteger$fIxWord$fIxInt$fIxChar $fShowArray $fOrdArray $fEqArray$fFunctorArray $fEqSTArray indexErrorhopelessIndexError arrEleBottom unsafeArray unsafeArray'filldone safeRangeSizenegRange safeIndex lessSafeIndex badSafeIndexunsafeAtunsafeAccumArrayunsafeAccumArray'adjust unsafeReplace unsafeAccumamapeqArraycmpArray cmpIntArray newSTArray boundsSTArraynumElementsSTArray readSTArrayunsafeReadSTArray writeSTArrayunsafeWriteSTArray freezeSTArrayunsafeFreezeSTArray thawSTArrayunsafeThawSTArray$fApplicativeStateL$fFunctorStateL$fApplicativeStateR$fFunctorStateRStateR runStateRStateL runStateL#. isBitSubType $fEnumDouble $fEnumFloat $fShowDouble$fFractionalDouble $fRealDouble $fNumDouble $fShowFloat$fFractionalFloat $fRealFloat $fNumFloat$fFloatingDouble$fFloatingFloat$fRealFloatDouble$fRealFracDouble$fRealFloatFloat$fRealFracFloatshowSignedFloatrationalToFloatrationalToDoubleFFFormat FFGeneric FFExponentFFFixed expm1Float log1pFloat expm1Double log1pDoubleisDoubleFiniteisDoubleNegativeZeroisDoubleDenormalizedisDoubleInfinite isDoubleNaN isFloatFiniteisFloatNegativeZeroisFloatDenormalizedisFloatInfinite isFloatNaNformatRealFloatAltroundTofromRat'minExptmaxExptexptexpts maxExpt10expts10integerLogBase fromRat'' plusFloat minusFloat timesFloat divideFloat negateFloatgtFloatgeFloatltFloatleFloatexpFloatlogFloat sqrtFloat fabsFloatsinFloatcosFloattanFloat asinFloat acosFloat atanFloat sinhFloat coshFloat tanhFloat powerFloat plusDouble minusDouble timesDouble divideDouble negateDoublegtDoublegeDoubleltDoubleleDouble double2Float float2Double expDouble logDouble sqrtDouble fabsDouble sinDouble cosDouble tanDouble asinDouble acosDouble atanDouble sinhDouble coshDouble tanhDouble powerDouble word2Double word2FloatclampPrioElem singleton toAscList toDescListfindMin deleteMinminViewatMostomegaplay unsafePlay $fShowSequPSQKeyEvaluekeyprioSequTourViewNullSinglePlayLTreeStartLLoserRLoserWinnerwgencatrunFinalizerBatchPGetLookFailResultFinal isPuncCharMkNumber MkDecimalparenlistchoose$fRead(,,,,,,,,,,,,,,)$fRead(,,,,,,,,,,,,,)$fRead(,,,,,,,,,,,,)$fRead(,,,,,,,,,,,)$fRead(,,,,,,,,,,)$fRead(,,,,,,,,,)$fRead(,,,,,,,,)$fRead(,,,,,,,)$fRead(,,,,,,) $fRead(,,,,,) $fRead(,,,,) $fRead(,,,) $fRead(,,) $fRead(,)$fRead() $fReadRatio $fReadDouble $fReadFloat $fReadInteger $fReadWord $fReadInt $fReadLexeme $fReadArray$fRead[] $fReadMaybe$fReadOrdering $fReadBool $fReadCharexpectP readNumber $fShowPtr $fShowFunPtr $fEqStablePtr unpackCString packCString#MutableByteArray ByteArray$fFiniteBitsWord8 $fBitsWord8 $fReadWord8 $fIxWord8$fBoundedWord8$fIntegralWord8 $fEnumWord8 $fRealWord8 $fNumWord8 $fShowWord8 $fOrdWord8 $fEqWord8$fFiniteBitsWord16 $fBitsWord16 $fReadWord16 $fIxWord16$fBoundedWord16$fIntegralWord16 $fEnumWord16 $fRealWord16 $fNumWord16 $fShowWord16 $fOrdWord16 $fEqWord16 $fReadWord32 $fIxWord32$fBoundedWord32 $fRealWord32 $fShowWord32$fFiniteBitsWord32 $fBitsWord32$fIntegralWord32 $fEnumWord32 $fNumWord32 $fOrdWord32 $fEqWord32 $fReadWord64 $fIxWord64$fBoundedWord64 $fRealWord64 $fShowWord64$fFiniteBitsWord64 $fBitsWord64$fIntegralWord64 $fEnumWord64 $fNumWord64 $fOrdWord64 $fEqWord64W8#W16#W32#W64#eqWord8neWord8gtWord8geWord8ltWord8leWord8eqWord16neWord16gtWord16geWord16ltWord16leWord16eqWord32neWord32gtWord32geWord32ltWord32leWord32eqWord64neWord64gtWord64geWord64ltWord64leWord64getMonotonicTime$fFiniteBitsInt8 $fBitsInt8 $fReadInt8$fIxInt8 $fBoundedInt8$fIntegralInt8 $fEnumInt8 $fRealInt8 $fNumInt8 $fShowInt8 $fOrdInt8$fEqInt8$fFiniteBitsInt16 $fBitsInt16 $fReadInt16 $fIxInt16$fBoundedInt16$fIntegralInt16 $fEnumInt16 $fRealInt16 $fNumInt16 $fShowInt16 $fOrdInt16 $fEqInt16 $fIxInt32$fBoundedInt32 $fRealInt32$fFiniteBitsInt32 $fBitsInt32 $fReadInt32$fIntegralInt32 $fEnumInt32 $fNumInt32 $fShowInt32 $fOrdInt32 $fEqInt32 $fIxInt64$fBoundedInt64 $fRealInt64$fFiniteBitsInt64 $fBitsInt64 $fReadInt64$fIntegralInt64 $fEnumInt64 $fNumInt64 $fShowInt64 $fOrdInt64 $fEqInt64I8#I16#I32#I64#eqInt8neInt8gtInt8geInt8ltInt8leInt8eqInt16neInt16gtInt16geInt16ltInt16leInt16eqInt32neInt32gtInt32geInt32ltInt32leInt32eqInt64neInt64gtInt64geInt64ltInt64leInt64readWideCharOffPtr readIntOffPtrreadWordOffPtr readPtrOffPtrreadFunPtrOffPtrreadFloatOffPtrreadDoubleOffPtrreadStablePtrOffPtrreadInt8OffPtrreadWord8OffPtrreadInt16OffPtrreadWord16OffPtrreadInt32OffPtrreadWord32OffPtrreadInt64OffPtrreadWord64OffPtrwriteWideCharOffPtrwriteIntOffPtrwriteWordOffPtrwritePtrOffPtrwriteFunPtrOffPtrwriteFloatOffPtrwriteDoubleOffPtrwriteStablePtrOffPtrwriteInt8OffPtrwriteWord8OffPtrwriteInt16OffPtrwriteWord16OffPtrwriteInt32OffPtrwriteWord32OffPtrwriteInt64OffPtrwriteWord64OffPtr gcdNatural lcmNatural plusNatural timesNatural minusNaturalbigNatToNaturalBigNat nullBigNat intToNatural~nonEmptySubsequences SnocBuildernatSingWrapNSNat symbolSingWrapSSSymbolSingKind DemoteRepfromSingSingIsingSingD:R:UReckWordp0D:R:UReckIntp0D:R:UReckFloatp0D:R:UReckDoublep0D:R:UReckCharp0D:R:UReckPtrp0uAddr#uChar#uDouble#uFloat#uInt#uWord#D:R:SingDecidedStrictnessa0 SDecidedLazySDecidedStrictSDecidedUnpackD:R:SingSourceStrictnessa0SNoSourceStrictness SSourceLazy SSourceStrictD:R:SingSourceUnpackednessa0SNoSourceUnpackednessSSourceNoUnpack SSourceUnpackD:R:SingAssociativitya0SLeftAssociativeSRightAssociativeSNotAssociativeD:R:SingFixityIa0SPrefixSInfixD:R:SingMaybeb0SNothingSJustD:R:SingBoola0STrueSFalseD:R:SingSymbols0SSymtypeNatTypeReptypeSymbolTypeRepmkTrFunGiftmkTyCon#typeLitTypeRep$fShowSomeTypeRep $fOrdTypeRep $fEqTypeRepmkTyConFingerprinttypeRep#KindRepTypeLitTrTyConTrAppTrFunSomeKindedTypeRep$fExceptionSomeException$fShowSomeException$fShowErrorCall$fExceptionErrorCall$fShowArithException$fExceptionArithExceptionerrorCallWithCallStackExceptionerrorCallExceptionunderflowExceptiondivZeroExceptionoverflowExceptionratioZeroDenomException showCCSStackprettyCallStackLinesioToSTcatchExceptioncatchAnyfailIOmplusIO unsafeUnmask $fEqIORefMyWeaknewConcForeignPtrmallocForeignPtrAlignedBytesmallocPlainForeignPtrmallocPlainForeignPtrBytes!mallocPlainForeignPtrAlignedBytesaddForeignPtrConcFinalizer$fShowForeignPtr$fOrdForeignPtr$fEqForeignPtrForeignPtrContentsPlainForeignPtr MallocPtrPlainPtr Finalizers NoFinalizers CFinalizersHaskellFinalizers insertWithIntTable updateWithBucketEmpty bucketKey bucketValue bucketNextITtabArrtabSizecopycopy' firstPowerOf2 duplicatecapacity unsafeRead unsafeWrite unsafeLoadensureCapacityuseAsPtrsnocclearremoveAtACIOArray newIOArrayunsafeReadIOArrayunsafeWriteIOArray readIOArray writeIOArray $fEqIOArray boundsIOArray$fShowHandleType $fShowHandle $fEqHandle HandleType ClosedHandleSemiClosedHandle ReadHandle WriteHandle AppendHandleReadWriteHandle BufferList BufferListNilBufferListConsHandle__haDevicehaType haByteBuffer haBufferMode haLastDecode haCharBuffer haBuffers haEncoder haDecoderhaCodec haInputNL haOutputNL haOtherSide FileHandle DuplexHandleisReadableHandleTypeisWritableHandleTypeisReadWriteHandleTypecheckHandleInvariants showHandle$fShowBlockedIndefinitelyOnMVar$$fExceptionBlockedIndefinitelyOnMVar$fShowBlockedIndefinitelyOnSTM#$fExceptionBlockedIndefinitelyOnSTM$fShowDeadlock$fExceptionDeadlock$fShowAllocationLimitExceeded"$fExceptionAllocationLimitExceeded$fShowAsyncException$fExceptionAsyncException$fShowIOErrorType$fEqIOErrorType$fShowIOException$fEqIOException$fExceptionIOException$fExceptionExitCode$fShowArrayException$fExceptionArrayException$fExceptionSomeAsyncException$fShowSomeAsyncException$fShowAssertionFailed$fExceptionAssertionFailed$fShowCompactionFailed$fExceptionCompactionFailed assertError ioe_handleioe_type ioe_locationioe_description ioe_errno ioe_filenameunsupportedOperation AlreadyExists NoSuchThing ResourceBusyResourceExhaustedIllegalOperationPermissionDenied UserErrorUnsatisfiedConstraints SystemError ProtocolError OtherErrorInvalidArgumentInappropriateType HardwareFaultUnsupportedOperation TimeExpiredResourceVanished InterruptedblockedIndefinitelyOnMVarblockedIndefinitelyOnSTMallocationLimitExceededcannotCompactFunctioncannotCompactPinnedcannotCompactMutable stackOverflow heapOverflow ioExceptionuntangleunrepresentableCharmemcpypeekEncodedCStringwithEncodedCStringnewEncodedCStringBackend_bePoll _beModifyFd_beModifyFdOnceTimeout EventLifetimeevtClose elSupremummodifyFd modifyFdOncethrowErrnoIfMinus1NoRetry $fMonoidEvent $fShowEvent$fMonoidLifetime$fMonoidEventLifetimeForevereventIs eventLifetime elLifetimeelEventbackendpoll_beState _beDeleteEL available CFilePathFDCUtsnameCUtimbufCTmsCTmCTermiosCStatCSigset CSigactionCPasswdCLconvCGroupCFLocksEEK_ENDsEEK_SETsEEK_CURdEFAULT_BUFFER_SIZE c_s_issockptr_c_cc poke_c_lflagc_lflagsizeof_sigset_tsizeof_termiosconst_fd_cloexec const_f_setfd const_f_setfl const_f_getflconst_sig_setmaskconst_sig_block const_sigttou const_vtime const_vmin const_icanon const_tcsanow const_echost_inost_devst_modest_sizest_mtime sizeof_stat c_s_isfifo c_s_isdir c_s_isblk c_s_ischr c_s_isrego_BINARY o_NONBLOCKo_NOCTTYo_TRUNCo_EXCLo_CREATo_APPENDo_RDWRo_WRONLYo_RDONLY c_waitpid c_tcsetattr c_tcgetattr c_sigprocmask c_sigaddset c_sigemptysetc_mkfifoc_linkc_fork c_fcntl_lock c_fcntl_write c_fcntl_read c_ftruncatec_statc_getpidc_utimec_unlinkc_pipe c_safe_writec_writec_umask c_safe_readc_readc_isattyc_dup2c_dupc_creatc_closec_chmodc_accessc_lseeklstatc_fstat c_safe_openc_openset_saved_termiosget_saved_termiosputs fdFileSizefileTypefdStatfdType statGetTypeioe_unknownfiletype fdGetMode withFilePath newFilePath peekFilePathpeekFilePathLen setCooked tcSetAttrsetNonBlockingFDsetCloseOnExecs_isregs_ischrs_isblks_isdirs_isfifos_issock epollOneShot$fStorableEvent EventType unEventType ControlOp eventTypeseventFdEPollFd fromEPollFdEPollepollFd epollEventscheckInvmkIconvEncodinglocaleEncodingName iconvEncodinginitFileSystemEncodinginitForeignEncodingrecoveringEncode flushBufferflushCharBufferHandleFinalizer withHandle withHandle' withHandle_ withHandle_'withAllHandles__ withHandle__'augmentIOErrorwantWritableHandlewantReadableHandlewantReadableHandle_wantSeekableHandleioe_closedHandleioe_semiclosedHandleioe_EOFioe_notReadableioe_notWritableioe_finalizedHandle ioe_bufsizhandleFinalizerdEFAULT_CHAR_BUFFER_SIZEflushByteWriteBufferwriteCharBufferflushCharReadBufferflushByteReadBuffermkHandleinitBufferStateopenTextEncodingcloseTextCodecs hLookAhead_debugIOreadTextDevicereadTextDeviceNonBlocking decodeByteBuf$fStorablePollFdPollFdpfdFd pfdEvents pfdReventsPoll pollChangespollFd controlIsDead newControl closeControlcontrolWriteFd controlReadFdControlMessage CMsgWakeupCMsgDie CMsgSignal wakeupReadFdreadControlMessage sendWakeupsendDieWcontrolEventFddidRegisterWakeupFd TimeoutEdit TimeoutQueueshutdown wakeManager emControlnewDefaultBackendnewWithfinishedcleanup emBackend emTimeoutsemStateemUniqueSourceStateCreatedRunningDyingFinishedTKrelease registerFd_closeFd_ onFdEventFdDatacallbackTableVaremFdsemLock Releasing keyUniquefdKeyfdEvents _fdCallback ioManagerLock eventManagerblockedOnBadFDmkFD$fBufferedIOFD $fIODeviceFD $fRawIOFD$fShowFDfdFDfdIsNonBlockingsetNonBlockingModereadRawBufferPtrreadRawBufferPtrNoBlockwriteRawBufferPtr commitBuffer'OpenNewFileResultNewFileCreated FileExists OpenNewErrorhsprsprreadSymbolicLinkOptKindOptUnreqOptNonOpt EndOfOptsOptErrcClockToIntegercTimeToIntegercsuSecondsToIntegergetCpuTimePrecision withTimespecnoDup $fMonadFailSTS#unSTpeekCStringOptSessionAddrChunk chunksList peekLocation locationSize showLocation chunkFrames chunkNextchunkFirstFrame runMainIOrunIO runIOFastExitrunNonIO topHandlertopHandlerFastExitflushStdHandlesChItemMpQrQi mkPrimTypeconrep constring confields confixitydatatypetycondatarepunMpunQr makeStatictoAnnotationWrapperAnnotationWrapper