HOOGXi6!#tt[_wx**   04$%&'<<()*+ - . /1;;  \\ppHHRRnn11??IIYY2 PP]]qtzzSSoo22::@@JJZZ3 ]]ttSSoo,-22::@@JJZZabef4 ^^uuTTpp33AAKK[[6\\^^ppuuRRTTnnpp1133??AAIIKKYY[[8 __vvUUqq  44BBLL\\: <=>[]^_ ..77wx==a TYY__adiinnqqu~""$%'58;AAIMPPSSZZbcmnrrxx{  )/5599>>Dx~?bE "&&//@ALLNNTsz{!!')++>@IJLLNOSTggqqww{{  44IIKMcfii57CERTcX#)//33;<??AAGGINRRVYddkkt 69@CFFKKOPUUhhwx)*//8;HHLL[]aaddffhhmmw} ##((9:DDXXdc&&),1133569:FFIIKLUUXY[_ddmmss !((**-48:FFIIKKMMSS``dhnnqqwx!"004468Jt|~    !"()57:BEEHHPPX^e!"&&)+//11339<?@DFHHJNSTWY[]`dfnpquuz{}}   %'),<>MRWYYahkkmnqqssw  "#%(,-/1479<@EHf_'')+//FFHHWX\]eruwyy""$$'*44;@GGNOTTVVZZfgrrxx}  '(//5599IIKMOPRVXXZZ\\bfiikkmrvx  (CGIMOOQTVVX]g<)*--SSWWuu  &>EOOTTabmmssy""**@@CE~~   99__h9((99<<CCQQ]]|~'Znn~%&//LLNNQQ]]mmss%%57:=DDHHXXdgi)+--11<<??ACFFJJMNRRUUWXcdilppssuu}}   ##+,//3389<<?@DDFLOOSTVVZ""&&**/02299@@BCEHNNR]mmstzz~ j,,k""VYad@@JJMMOORR)*ddff 6688l""&')+-399@@FFRRVZhlssz{ !"$$-24469;=@@DDFFIMOOVVYYbbjknnqrwx{ ##'(//35;;GGMMOOQQY]ddffiissux{{~LmD#$++44::@@RSYY\]``ggmm~~((,,KKSS}  /1>>ACLL^^ttPPn!!)+--5:<<??BCFFIQSSUUWY[_cdkluwyy}}    ##++-2?@BBDEHHKKOOSTWWZZa""**,-/099@@BEGGPV``ddffssyyo""%*//::<<?@EJRRU_cdkkmmuuwwy{}}!"((/0336799;;@@BCEHMMOOSSUUWXZZacegqrwx{{} (00457;?CFHLMOPRX^^bbddffiimrttvvbp)*--0044668<??HJ``bdggoorru{}}  /0225579;;EEHHNQWWZZbcff   $$)>HHMMOPRV[\_befhimrzz||q<<?Cr!!$$)+--//11;@DFIIKNWWYY\]_dforru{   $$'),,1134;;??AAIIKLPQSTZZaceelnssy     (*13;=>@sX "%(,,13ANTT^_ilnnpqu{~~$$))+,/03367<=BBELQXghnn{{##&&**--0033::<<EEY\gk{{~)//66::TVt!"'')*,-//11<<?ADFHHJJMSXX]]_`cdggilnoqru~    "&,,//2589>EKLNQSWYZbcggiin   _uS"$&&,,//33SSWW[`esvwyy!!$$')4489=@NQTTZZggqqww}   113488>CIIKMPPZZ\\cf|}/CEGGRSv++YY;;KK'(>>llWWw!23MNiirr44;;LLXXZZ&(45IIcfmt%'0]dgx11<<??JJ}}dgy7$$1378>?HNRRXX__gg2255SSccWWjj~~!"%'NNUU^^z)+pp<<VVEE  +._g|hhtE6D==(()DArithExceptionDArrayExceptionCAsyncExceptionCBoolC BufferModeC BufferStateCCharC ConsoleEventsCDouble,C Exception#CExitCodeCFloatBHandleB HandlePosnB HandleTypeBIOB IOErrorTypeB IOExceptionBIOModewBIntCBInt16 BInt32AInt64AInt8_AInteger3ALexeme-AOrdering ASTM@SeekMode@TVar@ThreadId@Weak@Words@Word16:@Word32@Word64?Word8?[::]?[]q?FunctorMonadFunctorMonad ShowNumRealEnumIntegralBoundedIxReadBitsOrdEq EqOrdNumEnumIntegralBitsShowRealBoundedIxRead NumEnumIntegralBitsShowRealBoundedIxReadOrdEq ShowNumRealEnumIntegralBoundedIxReadBitsOrdEq ShowNumRealEnumIntegralBoundedIxReadBitsOrdEq Typeable1ShowEqOrdTypeable Typeable1ShowReadEnumIxOrdEq Typeable1FunctorMonadReadShowBoundedEnumIxOrdEqRead ReadEqOrdNumEnumShowIxRealIntegral ShowNumRealEnumIntegralBoundedIxReadBitsOrdEq EqOrdShowNumEnumIntegralReadBitsRealBoundedIx ShowNumEnumIntegralReadBitsRealBoundedIxOrdEq ShowNumRealEnumIntegralBoundedIxReadBitsOrdEq ReadShowNumBoundedEnumIxRealIntegralEqOrdShowReadEnumIxOrdEqEqShowEqShowFunctorMonadShowEqShowEqShow EqOrdNumReal FractionalRealFracFloating RealFloatShowEnumReadShowReadOrdEqShowEq EqOrdNumReal FractionalFloatingRealFrac RealFloatShowEnumReadReadShowEnumOrdEqTypeableReadShowBoundedEnumIxEqOrdEqShowReadOrdEqReadShowBoundedEnumIxOrdEqShowOrdEqShowOrdEqShowOrdEqReadShowBoundedEnumIxEqOrd:D FDEFilePathE FinalizerPtrEHandlePositionEIOErrorEIPr|ERationaliE RawBufferHEReadSESTRepDShowSDStringD[]Char[]CharStringsaState#s(#,#)State#saa[]Char[](,)aStringMutableByteArray# RealWorldRatioInteger(,)IntInt IOExceptionIntegeraFunPtrPtraIO()[]CharCInt(t:mt[9tapbmckd=ie$gf@cg+chtai\j[lZm)Yn;WoUpTrOs)LtJurHwRF#hH1NH34H6H8HeGo*Gr|FiFtFeFbFhFmFoFdFeFIOModeaFnFdFlFeF HandleTypeuFfGf GeGrG BufferStater1Gd8GWord#G1G3G6nG8_GWord84uGWord64#GWord64#2GWord326GWord16Word#aGkGWeak#GWeak##HWord84!H#(HWord642;H#BHWord326UH#\HWord16WordnHs~HeHrHeHrHrHoHrH IOErrorTypedJiIsHa^IuHpHpHoHrHtIeIdIoIpIe#Ir*Ia1It8Ii?IoFInMI IOErrorTypeteIilIssIfzIiIeIdIcIoInIsItIrIaIiInItIsI IOErrorTypetIUnite JfEJrJfJl#Jo*Jw1JArithExceptioniLJnSJeZJdaJehJloJevJm}JeJnJtJArrayExceptionhKiIKr1KvKyJpJeJaJbJlJeJTypeable1K Typeable1aKr#KTVaru8Ke?KBoolmPKeWKe^KxeKplKisKrzKeKdK IOErrorTyperKeKaKdKiKkKiKlKlKeKdKAsyncExceptiondKThreadId#L ThreadId##OeNhZNtLyDLsKLtRLeYLm`LegLrnLruLo|LrL IOErrorTypeSTa^MmQMoMrLeLiLnLgLStringf MpLtLSTretSTRepSTRefr#Ma*Mb1Ml8Me?MStorableSTMb NcMrMttMe{M#MState#rMaMyMSTArraykMoMvMeMrMfMlMoMwMAsyncExceptionlNeNp Nt'Nr.N StablePtr#FN StablePtr#oNufNtmNdtNo{NwNnN ConsoleEventwNShowsNShowSe;OmNiNcNlNoNsNeNdOhOaOnOdOl$Oe+O HandleTypekBOfuOmNOoUOd\OecOSeekModer|OoOmOeOnOdOSeekModeIntegeraSeOaQcQlPsOoOuOrOcOeObPeRPvPaPnPi%Ps,Ph3Pe:PdAP IOErrorTypexYPh`PagPunPsuPt|PePdP IOErrorTypeuPsPyP IOErrorTypeaPtPiPvPePsPePePkQSeekModecQs_QuQp&Qd-Qe4Qr;QrBQoIQrPQ ExceptionefQlmQetQr{QrQoQrQ ExceptionoQnQeQrQrQoQrQ ExceptiondRlQRealf2RwRo RrRlRdR RealWorldl^Rr>RaERcLRRealFracoeRalRtsR RealFloatReadbShSmqSp=Ss.SwRrRiRtReRhRmRoRdReRIOModeaSn SdSlSeS HandleTypeReadSReadPrQSeXSc_SReadPrecoxSdSeSIOModeaSnSdSlSeS HandleTypeuSfSfSeSrS BufferStatetBTwTb TuTfTf!Te(Tr/T RawBufferiIToPTRationdTakTlrTRationalaUe UrTtTrTPtroTtToTcToTlTeTrTrToTrT IOErrorTyperUmUi!Us(Us/Ui6Uo=UnDUdKUeRUnYUi`UegUdnU IOErrorTypetUtUeUrUnUmUaUtUcUhUfUaUiUlU ExceptionOpaquebWpVrVtSVvVeVr#Vf*Vl1Vo8Vw?VArithExceptionhZVeaVrhVeoVrvVr}VoVrV IOErrorTypedVOrdeVrViVnVgVOrderingaVqVuVeVOpaquejWeWc$Wt+WObjecteXo`WuLWmSWNumbpXmXnWsvWu}WcWhWtWhWiWnWgW IOErrorTypetWeWrWmWiWnWaWtWiWoXn X Exceptione"Xt)Xh0Xo7Xd>XeEXrLXrSXoZXraX ExceptionuwXf~XfXeXrXiXnXgX BufferModesXtXeXdXaXtXoXmXiXcXaYl YlYyY ExceptionaZo]ZuoYv?YaFYrMYMVar#`YMVar#tvYaYvYaYrY#YMutVar#bYlYeYa#ZbYyYtYeYaYrYrYaYyZ#ZMutableByteArray#r*Zr1Za8Zy?Z#FZ MutableArray#ndZakZdrZMonadyZbZeZMaybee[id[oZtZOrderingg=[sZsZoZfZpZrZeZc[i [s[i[o"[n)[ArithExceptionoD[fK[fR[ ConsoleEventnk[er[by[u[f[f[e[r[i[n[g[ BufferModex[e[m[e[Lexeme#[Integer #ka1Ra39a6 a8ag`ls`n]o\p\sK\x?\IxsR\tY\r`\ig\nn\gu\IsStringr\IPrIOa]e\m\r\e\f\IORefo\d\e\IOModerO]x ]c]e]p]t%]i,]o3]n:] IOExceptionrV]o]]rd]IOErrortz]y]p]e] IOErrorTyper]r]a]y]IOArraya`d_l_r_tV^v]a]l]i^d ^a^r^g"^u)^m0^e7^n>^tE^ IOErrorTypeInt#q_1[_3E_6_8 _e^g^r^r^u^p^t^e^d^ IOErrorTypee^r^a^l^Integralr^IntegerInt84!_Int64#5_Int64#2L_Int326b_Int16Int#:+::+:e_x_o_u_t_o_f_b_o_u_n_d_s_ArrayExceptionp`p`r`o`p#`r*`i1`a8`t?`eF`tM`yT`p[`eb` IOErrorTypelz`e`g`a`l`o`p`e`r`a`t`i`o`n` IOErrorTypen`o`r`eaHandler#aInt84'a#.aInt642@a#GaInt326Ya#`aInt16IntaaeaaapaoavaearafalaoawaAsyncExceptionn=bradawaaarbe bfbabubl%bt,b IOErrorTypedDblKbeRbHandle_cpbrbtvby}bpbeb HandleTypeHandlerobsbibnb HandlePosntbibobnbHandlePosition_cHandle__t2cOrdering #gafdffeieldodrcuocnvcccpctcrcFunPtrtcocrcFunctoraccctcicocncaclc Fractionalrde di'dg.dn5dprtEriLroSrnZrArrayExceptionArray#trhrerxrcrerprtrirornrArithExceptionprernrdsh0smsosdse$sIOModea7sn>sdEslLseSs HandleTyperjseqsaxsdsysesxsissstsss IOErrorTypedsrs#sAddr#ssoslsutttetstete$tk+tSeekMode:Qt]Et[]:Xt]_t[::]*t+yt:t:+::t:*:)t()t)4ق( bw-wvv2vStringChar[] ~x%Stringa(,)[]Char[]asState#(#,#)sState#jbsState#(#,#)sState#eiArraysState#(#,#)sState#4()ArithExceptionArrayExceptionAsyncExceptionBoolsU8)";.Bufferrm BufferListl BufferModeVh BufferState ByteArray#CIntW Chark&# ConsoleEventDoublel6-*( Exception_3.ExitCodemFFFormatFloatn;97+Handle HandlePosnM HandleTypeXHandle__!Handler'  IOErrorType`/! IOExceptiongIOMode"Intto:,$C53/,#Int#Int16Int32Int64Int64#Int8Integery$OpaqueOrderingw<9%SeekMode&StringThreadIdUnit'WordWord#Word16Word32Word64Word64#Word8a/}z2   V*)(b  -ce#"EDlst$()IO ConsoleEventMVar eisSTArray()sSTIntInt(,)pIntInteger(,)IntegerIntArrayIntegerInteger(,)a RealWorldSTQa RealWorldSTretUaa(,)ab(,)asSTRasSTRefiasSTretba:*:ba:+:biArray eiArray ! @>84210eiIOArrayesSTii(,):eisSTArraysST=7asSTRefsSTeiArraysSTInt[]Int(,)rC()IO-daQONLJIHGFD=50~|ywtda_][LHG()Ptr()STMBoolIOK>ebBufferIOjBufferIORefR BufferListIORefS BufferModeIO?CIntIOCharIO@{Char[] ^4 DoubleIO}FloatIOHandleIOAHandleMaybe] HandlePosnIOBHandlerIOYIntIOEqMInt[::]Int16IOInt32IOInt64IOInt8IOIntegerIOCIntegerRatio Integer[]LexemeReadPrec RealWorldMutableByteArray#ThreadIdIOeNWordIOWord16IOWord32IOWord64IOWord8IOa ForeignPtr aFunPtraIO[Z1c^XWOaIORefaMVarfaObjectaPtrI aRatioaReadP aReadPrecaSTMSa StablePtrza[::] {ga[]&%|i+amb ForeignPtrFbFunPtrJbIOsYPbMaybebPtrKb[::] b[] bf bmc[::]c[]d[::]d[]eIO\Ze[::]qe[]Ai[]BvWeakcba(,,)[::]cba(,,)[] IntChar(,)IOpIntInt(,)IOvuStringChar(,)[]StringString(,)[]Stringa(,)[]ba(,)[::]ba(,)[]ei(,)[]?eiIOArrayIO6 ExceptionMaybeHandle__(,)IOPIntInt[](,)IntIntegerRatio(,)aChar[]Eithera RealWorldState#(#,#)Tc[::]b[::]a[::](,,)c[]b[]a[](,,)a[::]a[::](,)fa[]a[](,)hb[::]a[::](,)b[]a[](,)()PtrIOonkBoolTVarIOcChar[]IO<Char[]Maybe\Char[][]Handle__MVarMaybeTa ForeignPtrIObaFunPtrIOuaIORefIOaMVarIOaMaybeIO`aPtrIOva StablePtrIOxaTVarIOaTVarSTMa[]ReadPrec vMaybeIOvWeakIOInt()Ptr(,)IOStringa[](,)[]Char[][]IOg"ծA=ؘl7 єpbbbba&%StringChar[]adcba aaChar aaaababbIntegerbbacbaeae! eee#"lstlstelt$BoolCharBoolaaaba     cbelta$ji8asSTa aIOAddr#aIO ExceptionWaIOHandle__aIO IOExceptionXaSTM ExceptionbIOAddr#sbIOaYb[::]ab[]abmaaHandle__(,)IOHandle__StringChar[]Stringa(,)[]Char[]Addr#a RealWorldState#(#,,#) RealWorldState#asState#(#,#)sState#jbsState#(#,#)sState#:Addr#     ArithExceptionArrayExceptionAsyncExceptionBoolG!! Buffer BufferListl BufferModeH! BufferStatejrm ByteArray#CInt! onkCSizeonkCharI%$#"|qChar#& ConsoleEvent'Double,+**))(~Double#-Dynamic/. Exception210ExitCode3FFFormat4Fd5Float:998876Float#;ForeignPtrContents HandleNMLKJJIHGFEDCBA@?>=< HandlePosnO HandleType!Handle__ XWVUTSRQPHandlerY IOErrorTypeg IOException`_^]\[ZIOModeInt!~}|{zyxxwwvvvvuuuttssrrqqpponmlkjihgfedcbaKED~}|{yxwvتInt# Int16Int32Int64Int64#Int8IntegerNMLSeekModeNThreadId ThreadId#WordWord#Word16Word32Word64Word64#Word8a$ ǩb e #! ][76i ]\E5klst$v"~}|{4  ed_/.- utrrrqpm[ZD54()IOaPtrFunPtrLIntIOaPtrFunPtrMei RealWorldSTArrayeisSTArrayaInt(,)a RealWorldMVar#fa RealWorldSTa RealWorldSTRefaa(,)/.-,+aiArray asMutVar#iasSTasSTRefeInt(,)jeIntArray99eiArrayEDCBA@?>=<<;;:eiIOArray]\[ZejArray8es MutableArray#jii(,) ! 876543210=()IOe'aNH()PtrzBoolSTMBool[::]Bool[]BufferIORef! BufferListIORef!CCharPtrCharPtr|{Char[]'Fgg-DoublePtr~}FDTypeMaybeFloatPtrHandleMaybegHandle__MVarIntMaybe4hIntPtrInt[::]Int[]rInt16PtrInt32PtrInt64PtrInt8PtrIntegerRatio RealWorldMutableByteArray# vrqponnmlkk RealWorldState#UTWordPtrWord16PtrWord32PtrWord64PtrWord8Ptra ForeignPtrLIHGFaFunPtrtKJaIO YXWVUTSRQPOaIORef_^aMVaredcba`aObjectsaPtruEDwoMaRatioaReadPrecaSTMa StablePtrya StablePtr#aTVara[::] gfa[]& ihaf ambIOPbPtrb[::]b[]bmc[::]c[]eArray#e[::]#"qe[]2sState#vWeakvWeak#CInoCDevFDType(,,)Maybecba(,,)[::]cba(,,)[]aInt(,)[]! ai(,)[]ba(,)[::]ba(,)[]eInt(,)[]>40ei(,)[]@1a RealWorldState#(#,#) ()IOArray#a()IOMaybeChar[]MaybegHandle__MVarMaybe!aFunPtrPtrutaPtrPtrwva StablePtrPtryxa[::][::]a[][]aReadPrecChar[](,)[]&TI/$}k`NC8 LA.sXM:'qaQA1!|l\L<, eZOD9.# ti^SH)oZOD9.# ~sh]RG<1&wcB~n^N>3(xmbWL=.# uj_P7#y_A6jP8wlUF;0%teZO@5&wdV?(o`U:/ o`U:/ }rcXE3$wl^SH=&}ncTI6+  xmbK3~sdMB0%wlUF;0%}jOD9){p\I3 yc|`@*w_5uY,!{^SC8- ufWD5*|qf[PA6+  |m^CLHIxiIxiPSTRepGIxiIxi0-ShowS8MNQ IK$GFunctorfABDXIxiOJPR[2b@T\3cA7ShowSSTRepFSTRepVIxiSTRepLfHIxi3 RealFloataShowS2RealaShowS1ShowaShowS+ RealFloataShowSBIntegralbNumaC FractionalaIntegralb7B IntegralbRealFraca]IntegralaNumb FractionalbRealaIntegrala FractionalaOrdaEnumaEnuma RealFloataGOOrda)+/XNumah%WIntegrala1 Fractionala*3FloatingauOrda9:<=Orda3;EqaIntegrala FractionalaOrda Fractionala EnumaBoundedaIntegralaBoundedaEnuma Enuma%Integrala5Integrala: RealFloataD^;Numa FractionalaILno2<=DdeFloatingaYEnuma#$? RealFloatawIntegralan= RealFloataZEnuma RealFloataIntegralaMonadmyEqa4 FractionalaEnumaBoundedaIntegralaBoundedaEnuma)ShowaString8EqazEqa9Eqanm|RealaRationalokjiIntegralbRealFraca RealFloata@ RealFloata$%&'js!String A RealFloata\Numai& RealFloataString     XaReadaReadS6ShowaShowS RealFloatauEnuma4ShowS|~{}Tl >aS^B`CUh>@ StringFilePathIOErrorsFDqtu~rpF{HandlePositionStringCString !<SkK5`;mnV RealFloataStringopqrz{RjJ4_*.ShowSx}xFDDFD1EFD0FD'FDFilePath(FDFilePath&FD RawBuffer/ShowSReadSp&wwyhjacSqStringeg?Monadm>Monadm,ShowaShowS""'{,-]yFString7ShowSString[ShowaStringReadaStringbIsStringaStringZString5ShowSvShowaStringFilePathIOErrorStringStringStringStringrsrsStringFDStringFD RawBufferStringString"MonadmStringStringReadaReadS)*+ReadSReadSReadaReadS-FilePathFilePath#String?FilePathReadaStringYStringJQOrda[Numa#(}^. Z4UHXWVIxiIxiIxiIxiYIxi.W0Integrala_` RealFloataRationala FractionalaRationalRationalQUN RawBufferdgE RawBuffer RawBuffer RawBufferM RawBufferL RawBuffere RawBuffer RawBufferK RawBuffer/STRepRFilePathString\_OIxiIxiIxiIxiIOError-g TvN FinalizerPtrM5~!IxiIxiIxiIxiIxi2IxitIxiIxifIxiIxiOrdeEqeIxiIxiOrdeIxiIxjlIxihIxiIxiIxiIxi1IxigIxiIxiIxaIxaShowaStringIxaIxaFloatingaHPBoundedaElF! o<`I^_U v\t]#MNO)*, bctu 6789/p$IJkl :;(@mStringReada,ReadaReadaxRational~]qmStringf=?Storablea|0%&**//1133558;=CFHMPRVY]bbefitvvxx~""$*5799;=C]__dg  #%)//5577::>]__ ##))+.EGIMQQSTX]`g%xy{|  !!$$&&()//::>BDGIQTTX]__.579=DDGM__  ##**57:=EFHHTT^^ !$$&.77:=Cg  )//5=C_)5=DDFFHHNNRUWXhJi:i*iiihhhhhhhh|hnh^hNh@h0hhhggggggggxgjgZgHg*ggffff~fhf(feeee~eVeBeeeddddd|dXd4ddcccycUc9c%ccbbbbsbQbbaaaaaoaYa9aa````q`?`+``___w_Y_4__^^^^v^V^*^ ^]]]z]`]F]*]]\\\\p\V\,\[[[[g[M[5[[ZZZZZkZIZ/ZZYYYYYiYAYYYXXXXXcXEX'XXWWWWWgWGWWWVVVVyV[V7V#V VUUUUyUcUEU%UUTTTTyTST1T TSSS]SASSRRRRgRUR=R#RRQQQQyQSQ7Q QPPPPPqP]PIP5PPPOOOOkOQO5OONNNNYNAN'N NMMMMoMKM-M MLLLLsLOL%LKKKKKiKQK;K!K KJJJJ{JQJ1J JIIII]IGI-IIHHHH}H]HAH'HHGGGGGiGUG;GGFFFFyFYF7FFEEEE{EgE-EEDDDDkDGD+DDCCCCC_C1CCBBBBoBYB1B BAAAAA]AIA5A!A A@@@@y@c@C@'@??????o?G?-??>>>>>w>I>>====m=9==<<<e<M</<<;;;;[;;;;:::q:Y:G:-: :9999e9K99888s8]8+88777o7M7+7766666_6E6+66555555m5K5755 544444k4W4?4'443333{3_3C3+33222q2;211111o1]1A1'1 1000_0M0100/////q/W/A/%//....Y.+..---{-a-=---,,,,[,/, ,+++++q+[+A++++***g*5*))))))i)A)%))(((((v(V(0(('''''t'H','''&&&&r&J&*&&%%%%~%d%D%%%$$$$x$V$6$$###d#D##"""x"V"8""!!!z!Z!D!&! !   ^ $  sW'yQ'T>~^F(b6 XB~X8t\:vX<qK-oW9%sI+iQ9 q[1qQ)cK) _E{a+   k ;       G !    e C      i +    i 9  k=g7mU(f6jN6nBnDf8pBzXF2||||zipwithpzipWithP zipwith3p zipWith3Pzipwith3zipWith3zipwithzipWithzippzipPzip3p&zip3Pzip3;zip3zipNzip zerointegerh zeroIntegeryieldyieldwritewordoffptrwriteWordOffPtrwriteword8offptrwriteWord8OffPtrwriteword64offptrwriteWord64OffPtrwriteword32offptr*writeWord32OffPtrwriteword16offptrXwriteWord16OffPtrwritewidecharoffptrwriteWideCharOffPtr writetvar writeTVar writestref writeSTRef writestarray writeSTArraywritestableptroffptrwriteStablePtrOffPtrwriterawbufferptrNwriteRawBufferPtrwriterawbufferywriteRawBufferwriteptroffptrwritePtrOffPtr writemode WriteMode writeioref writeIORef writeioarray  writeIOArraywriteintoffptr/writeIntOffPtrwriteint8offptrXwriteInt8OffPtrwriteint64offptrwriteInt64OffPtrwriteint32offptrwriteInt32OffPtrwriteint16offptrwriteInt16OffPtr writehandle WriteHandlewritefunptroffptr*writeFunPtrOffPtrwritefloatoffptrWwriteFloatOffPtrwritedoubleoffptrwriteDoubleOffPtrwritecharintobufferwriteCharIntoBuffer writebuffer WriteBufferword8Word8word64Word64word32)Word32word16AWord16wordWWord  withhandle_z withHandle_ withhandle' withHandle' withhandle withHandlewin32consolehandlerwin32ConsoleHandlerwgencat wgencatweak#WeakwantwritablehandleMwantWritableHandlewantseekablehandle}wantSeekableHandlewantreadablehandlewantReadableHandlew8#W8#w64#W64#w32#W32#w16# W16#w#W# usererror6 UserError userErrorunzipp`unzipPunzip3pyunzip3Punzip3unzip3unzipunzipuntiluntilunsupportedoperationUnsupportedOperationunsatisfiedconstraintsUnsatisfiedConstraintsunsafewritestarrayNunsafeWriteSTArrayunsafewriteioarray~unsafeWriteIOArrayunsafethawstarrayunsafeThawSTArray unsafesttoio unsafeSTToIO unsafereplace unsafeReplaceunsafereadstarray%unsafeReadSTArrayunsafereadioarraySunsafeReadIOArrayunsaferangesizeunsafeRangeSizeunsafeperformiounsafePerformIO unsafeiotostm unsafeIOToSTM unsafeiotost unsafeIOToSTunsafeinterleavest unsafeInterleaveSTunsafeinterleaveioP unsafeInterleaveIO unsafeindexy  unsafeIndexunsafefreezestarray unsafeFreezeSTArrayunsafeforeignptrtoptr unsafeForeignPtrToPtrunsafedupableperformio unsafeDupablePerformIOunsafedupableinterleaveioI unsafeDupableInterleaveIO unsafechrw  unsafeChrunsafeat unsafeAt unsafearray'  unsafeArray' unsafearray  unsafeArrayunsafeaccumarray' unsafeAccumArray'unsafeaccumarray, unsafeAccumArray unsafeaccumS  unsafeAccum unpacknbytes#w  unpackNBytes#unpackfoldrcstring# unpackFoldrCString#unpackcstringutf8# unpackCStringUtf8#unpackcstring# unpackCString# unpackcstring3  unpackCStringunpackappendcstring#` unpackAppendCString#unmarshalstring unmarshalStringunmarshalobject unmarshalObjectunit Unitunio unIOunicode Unicode underflow'  UnderflowundefinedelementP UndefinedElement undefinedy  undefineduncheckedshiftrl64# uncheckedShiftRL64#uncheckedshiftl64# uncheckedShiftL64#uncheckedishiftra64# uncheckedIShiftRA64#uncheckedishiftl64#CuncheckedIShiftL64#unblockmunblocktvarTVar trytakemvar tryTakeMVar tryputmvar tryPutMVartruncatetruncatetrueTruetoupper toUppertouchforeignptr/touchForeignPtr~totitleQtoTitle} torationaln toRational|tophandlerfastexittopHandlerFastExit{ tophandler TopHandler topHandlerztoptoPytolowertoLowerx tointeger toIntegerw toenumerror9 toEnumErrorvtoenumVtoEnumu timeexpireds TimeExpiredtthrowtothrowTosthrowiothrowIOqrthrowthrowopthreadwaitwritethreadWaitWritenthreadwaitreadthreadWaitReadm threadkilled: ThreadKilledklthreadid^ThreadIdij threaddelay threadDelayhtheniothenIOg thawstarray thawSTArrayftanhtanhetantand takewhilep takeWhilePc takewhile! takeWhilebtakeuint_appendEtakeUInt_appendatakepetakeP`takemvar~takeMVar_taketake^tailtail] systemerror SystemError\sumpsumP[ succerror succErrorZsuccsuccYsubtract*subtractXsttoioDstToIOWstring\StringVstretsSTretTUstrepSTRepSstrefSTRefQRstorableStorablestmSTMPstdoutstdoutOstdinstdinNstderrstderrMstarray7STArrayKL stackoverflow[ StackOverflowIJ stableptr StablePtrGHstableStablestSTEFsqrtsqrtDsplitatpsplitAtPCsplitatsplitAtBspanpspanPAspan.span@ slurpfileG slurpFile?slicepbsliceP>sinhxsinh=sinsin<signumsignum; significand significand:shutdownShutdown89 showstring showString7 showsprec showsPrec6 showspace; showSpace5 showsignedint] showSignedInt4showsignedfloatshowSignedFloat3 showsigned showSigned2showsShowS0shows1 showparen showParen/ showlitchar  showLitChar. showlist__+ showList__-showlistIshowList, showfloatf showFloat+showcharshowChar*showShow(show)shiftrl#shiftRL#&'shiftl#shiftL#$%semiclosedhandleSemiClosedHandle#seekmode+SeekMode" seekfromendJ SeekFromEnd!scanrpgscanrP scanr1pscanr1Pscanr1scanr1scanrscanrscanlpscanlPscanl1pscanl1Pscanl1scanl1scanlscanlscalerat)scaleRat scalefloatG scaleFloat saferangesizej safeRangeSize safeindex safeIndexs#S#runstreprunSTReprunstrunSTrunnoniorunNonIO runmainio  runMainIO runiofastexit. runIOFastExitrunioLrunIO runfinalizerbatchnrunFinalizerBatch roundtoroundTo roundround reversepreverseP reversereversereturnioreturnIOreturnreturnretry*retryresourcevanishedKResourceVanishedresourceexhaustedxResourceExhausted resourcebusy ResourceBusyreportstackoverflowreportStackOverflow reporterror reportError replicatep replicateP replicate6 replicaterepeatQrepeat remintegerm remIntegerremrem relativeseek RelativeSeek registerdelay registerDelayreducereduce recupderror RecUpdError recselerror( RecSelErrorrecipHrecip recconerrord RecConError recConError realtofrac realToFracrealfracRealFrac realfloat RealFloatrealReal readwritemode ReadWriteModereadwritehandle;ReadWriteHandlereadwordoffptrdreadWordOffPtrreadword8offptrreadWord8OffPtrreadword64offptrreadWord64OffPtrreadword32offptrreadWord32OffPtrreadword16offptrreadWord16OffPtrreadwidecharoffptr>readWideCharOffPtrreadtvardreadTVar readstref readSTRef readstarray readSTArrayreadstableptroffptrreadStablePtrOffPtr readsprec readsPrecreads ReadSreadsreadrawbufferptrnoblock@ readRawBufferPtrNoBlockreadrawbufferptrs readRawBufferPtrreadrawbuffernoblock readRawBufferNoBlock readrawbuffer  readRawBuffer readptroffptr  readPtrOffPtrreadprec!readPrec readparen4! readParenreadpN!readpreadmodeg!ReadMode readlitchar! readLitCharreadlistprecdefault!readListPrecDefault readlistprec! readListPrecreadlistdefault"readListDefaultreadlist)"readList readiorefF" readIORef readioarrayf" readIOArray readintoffptr" readIntOffPtrreadint8offptr"readInt8OffPtrreadint64offptr"readInt64OffPtrreadint32offptr#readInt32OffPtrreadint16offptr.#readInt16OffPtr readhandleS# ReadHandlereadfunptroffptry#readFunPtrOffPtrreadfloatoffptr#readFloatOffPtr readeither# readEitherreaddoubleoffptr#readDoubleOffPtrreadcharfrombuffer$readCharFromBuffer readbufferE$ ReadBufferread_$Readread rawbuffer$ RawBuffer ratioprec1$ ratioPrec1rational$Rationalratio$Ratio rangesize$ rangeSizerange%rangequotreminteger/%quotRemInteger quotremintS% quotRemIntquotremp%quotRem quotinteger% quotIntegerquot%quotputmvar%putMVarptr%Ptrpseq%pseq protocolerror& ProtocolError protectesc9& protectEscproperfraction]&properFractionproductp&productP prederror& predErrorpred&pred powerfloat& powerFloat powerdouble& powerDoubleplusptr'plusPtrpi#'pipermutep9'permutePpermissiondenied]'PermissionDeniedpatternmatchfail'PatternMatchFailparr'PArrparens'parensparen'parenpar'par packcstring# ( packCString#pack%(Pack overflowerrorB( overflowErroroverflowc(Overflow otherwise( otherwise othererror( OtherErrororp(orPorelse(orElseordering(Orderingord)Ordordor)oropenfile2)openFileopenbinaryfileT)openBinaryFileopaquet)Opaqueoneint)oneIntodd)oddobject)Objecto)Onumericenumfromto)numericEnumFromTonumericenumfromthento*numericEnumFromThenTonumericenumfromthenM*numericEnumFromThennumericenumfrom{*numericEnumFrom numerator* numeratornumelementsstarray*numElementsSTArray numelements* numElementsnumcapabilities+numCapabilitiesnum3+NumnullptrM+nullPtr~nullpe+nullP} nullfunptr+ nullFunPtr|null+null{notelemp+notElemPznotelem+notElemy notanumber+ notANumberxnot,notw nosuchthing, NoSuchThingvnonterminationB,NonTerminationtu nomethoderrorm, NoMethodErrorrs noduplicate, noDuplicateq nobuffering, NoBufferingp newtvario, newTVarIOonewtvar,newTVarnnewstref-newSTRefm newstarray,- newSTArrayl newstableptrN- newStablePtrknewmvarm-newMVarjnewioref-newIORefi newioarray- newIOArrayhnewforeignptr_-newForeignPtr_g newemptymvar- newEmptyMVarfnewemptybuffer.newEmptyBufferenewconcforeignptrA.newConcForeignPtrdnestedatomicallyn.NestedAtomicallybc negateint. negateInta negatefloat. negateFloat` negatedouble. negateDouble_negate.negate^ mythreadid/ myThreadId]mvar./MVarZ[\monadK/MonadYmodint#c/modInt#Xmody/modWmkweak/mkWeakVminusptr/minusPtrUminusint/minusIntT minusfloat/ minusFloatS minusdouble0 minusDoubleRminimump"0minimumPQminbound>0minBoundPminU0minOmemcpy_ptr_baofft0memcpy_ptr_baoffNmemcpy_baoff_ptr0memcpy_baoff_ptrMmemcpy_baoff_ba0memcpy_baoff_baLmemcpy_ba_baoff0memcpy_ba_baoffKmaximump1maximumPJmaxexpt31maxExptImaxboundN1maxBoundHmaxe1maxG marshalstring1 marshalStringF marshalobject1 marshalObjectEmapp1mapPDmapfb1mapFBCmap1mapABmallocplainforeignptrbytes2mallocPlainForeignPtrBytes@mallocplainforeignptrU2mallocPlainForeignPtr?mallocforeignptrbytes2mallocForeignPtrBytes>mallocforeignptr2mallocForeignPtr=lt2LT<lossofprecision2LossOfPrecision:;lookupp3lookupP9lookup63lookup8logoffN3Logoff67logfloatl3logFloat5 logdouble3 logDouble4logbase3logBase3log3log2 listarray3 listArray1list3Listlist0 linebuffering4 LineBuffering/liftst24liftST.liftioJ4liftIO-lexp`4lexP, lexlitcharz4 lexLitChar+ lexdigits4 lexDigits*lex4lex)lengthp4lengthP(length4length' lcminteger4 lcmInteger&lcm5lcm%lazy(5lazy#$last@5last" labelthread[5 labelThread! killthread|5 killThread jtos5jtosj#5J#ixmap5ixmapix5Ixiterate5iterateisupper6isUpperisstring6IsStringisspace76isSpaceisprintQ6isPrint isoctdigitn6 isOctDigitisnegativezero6isNegativeZeroisnan6isNaNislower6isLowerislatin16isLatin1 isinfinite7 isInfiniteisieee7isIEEE ishiftrl#97 iShiftRL#  ishiftra#[7 iShiftRA#  ishiftl#|7iShiftL#   ishexdigit7 isHexDigitisfloatnegativezero7isFloatNegativeZero isfloatnan7 isFloatNaNisfloatinfinite8isFloatInfiniteisfloatdenormalizedC8isFloatDenormalizediseofg8isEOF isemptymvar8 isEmptyMVarisdoublenegativezero8isDoubleNegativeZero isdoublenan8 isDoubleNaNisdoubleinfinite9isDoubleInfiniteisdoubledenormalized09isDoubleDenormalizedisdigitW9isDigitisdenormalizedx9isDenormalized iscontrol9 isControl isasciiupper9 isAsciiUpper isasciilower9 isAsciiLowerisascii9isAscii isalphanum: isAlphaNumisalpha9:isAlphaiprO:IPriotostd:ioToSTioref{:IORefiomode:IOMode ioexception: IOException ioException ioerrortype: IOErrorTypeioerror;IOErrorioErrorioe_typeH;ioe_type ioe_locationl; ioe_location ioe_handle; ioe_handle ioe_filename; ioe_filenameioe_eof;ioe_EOFioe_description;ioe_descriptioniobase"<IOBaseioarray;<IOArrayioT<IOinvalidargumenty<InvalidArgument inttodigit< intToDigit interrupted< Interruptedintegralenumfromto<integralEnumFromTointegralenumfromthento=integralEnumFromThenTointegralenumfromthenR=integralEnumFromThenintegralenumfrom=integralEnumFromintegral=Integralintegerlogbase=integerLogBase integer2int= integer2Intinteger >Integerint_encodefloat#2>int_encodeFloat#int_encodedouble#_>int_encodeDouble#int8>Int8int64>Int64int32>Int32 int2integer> int2Integer int2float> int2Float int2double? int2Doubleint16!?Int16int5?IntinstallhandlerZ?installHandlerinrange{?inRangeinr?Inrinline?inlineinl?Inlinit?initindices?indicesindexoutofbounds @IndexOutOfBoundsindexofp4@indexOfP indexerrorR@ indexErrorindexm@indexinappropriatetype@InappropriateTypeillegaloperation@IllegalOperationignore@Ignoreid@idi8#AI8#i64#AI64#i32#*AI32#i16#>AI16#i#PAI# hwaitforinputoA hWaitForInputhtellAhTellhshowAhShowhsetposnAhSetPosn hsetfilesizeA hSetFileSizehsetechoAhSetEcho hsetbufferingB hSetBufferinghsetbinarymodeDBhSetBinaryModehseekcBhSeekhputstr{BhPutStrhputcharBhPutCharhputbufnonblockingBhPutBufNonBlockinghputbufBhPutBuf hlookaheadB hLookAhead hiswritableC hIsWritablehisterminaldeviceGChIsTerminalDevice hisseekableoC hIsSeekable hisreadableC hIsReadablehisopenChIsOpenhiseofChIsEOF hisclosedC hIsClosedhgetposnDhGetPosnhgetlineDhGetLinehgetecho8DhGetEcho hgetcontentsXD hGetContentshgetcharxDhGetCharhgetbufnonblockingDhGetBufNonBlocking hgetbufferingD hGetBufferinghgetbufDhGetBufhflushEhFlush hfilesizeE hFileSize heapoverflow>E HeapOverflow heapOverflowheadpEhead hduplicatetoE hDuplicateTo hduplicateE hDuplicate hclose_helpE hClose_helphcloseEhClosehatypeFhaType hardwarefault#F HardwareFault haothersideGF haOtherSide~ handletypehF HandleType}handlerFHandler| handleposnF HandlePosnz{handlepositionFHandlePositionyhandle__FHandle__wxhandle GHandle v haisstream*G haIsStreamuhaisbinGGhaIsBinthafd^GhaFDs habufferswG haBuffersr habuffermodeG haBufferModeqhabufferGhaBufferpgtGGTogettagGgetTagn getfullargsG getFullArgsmgeintHgeIntlgefloat3HgeFloatkgedoubleNHgeDoublej gcdintegerlH gcdIntegerigcdHgcdhfunptrHFunPtrdefgfunctorHFunctorc fromstringH fromStringb fromrationalH fromRationalafromrat'IfromRat'`fromrat9IfromRat_frompQIfromP^ fromintegralnI fromIntegral] fromintegerI fromInteger\ fromenumerrorI fromEnumError[fromenumIfromEnumZ freezestarrayI freezeSTArrayY freestableptrJ freeStablePtrX fractional@J FractionalWformatrealfloateJformatRealFloatVforkonioJforkOnIOUforkioJforkIOT foreignptrJ ForeignPtr RSfoldrpJfoldrPQfoldr1pJfoldr1PPfoldr1Kfoldr1Ofoldr+KfoldrMNfoldpEKfoldPLfoldlp\KfoldlPKfoldl1puKfoldl1PJfoldlKfoldlIfold1pKfold1PHfmapKfmapGflushwritebufferonlyKflushWriteBufferOnlyFflushwritebufferLflushWriteBufferEflushreadbuffer9LflushReadBufferD flushconsole`L flushConsoleCfloor}LfloorB floattodigitsL floatToDigitsA floatrangeL floatRange@ floatradixL floatRadix?floatingLFloating> floatdigitsM floatDigits= float2int;M float2Int< float2double\M float2Double;floatyMFloat 9:flipMflip8fixstMfixST7 finalizerptrM FinalizerPtr6finalizeforeignptrMfinalizeForeignPtr5finalizeNfinalize4filterp3NfilterP3filterLNfilter2fillreadbufferwithoutblocking{NfillReadBufferWithoutBlocking1fillreadbufferNfillReadBuffer0fillNfill/filepathNFilePath. filehandleO FileHandle- ffgeneric%O FFGeneric,ffformatBOFFFormat+fffixed]OFFFixed* ffexponentzO FFExponent)fdtohandle_statOfdToHandle_stat( fdtohandle'O fdToHandle'' fdtohandleO fdToHandle&fdOFD%falsePFalse$failio(PfailIO#fail>Pfail"f#PPF# !extsfPExts expts{PexptsexptPexptexponentPexponentexpPexp exitsuccessP ExitSuccess exitfailureP ExitFailure exitexceptionQ ExitExceptionexitcodeDQExitCode exceptionaQ Exception evaluateQevaluateerroremptylistQerrorEmptyList errorcallQ ErrorCallerrorQerrorerrQErreqstringReqStringeqarray/ReqArrayeqDREQ Eq eof]REOF  environmentwR Environment enumfromtopR enumFromToP  enumfromtoR enumFromTo enumfromthentopRenumFromThenToPenumfromthentoSenumFromThenTo enumfromthen.S enumFromThenenumfromNSenumFromenumdeltaintegerfbtSenumDeltaIntegerFBenumdeltaintegerSenumDeltaIntegerenumSEnumensureiomanagerisrunningSensureIOManagerIsRunning encodefloat#T encodeFloat# encodefloatAT encodeFloat encodedouble#eT encodeDouble#elemsTelemselempTelemPelemTelem dynioerrorT DynIOError dynexceptionT DynException duplexhandleU DuplexHandle dropwhilep4U dropWhileP dropwhileSU dropWhiledroppmUdropPdropUdrop dpermutepU dpermuteP double2intU double2Int double2floatU double2FloatdoubleUDoubledotnetVDotnetdone,Vdone divzeroerrorHV divZeroError divmodintiV divModIntdivmodVdivModdivint#VdivInt# dividebyzeroV DivideByZerodivexactVdivExactdivVdiv derefweakW deRefWeakderefstableptr2WdeRefStablePtrdenormalTWDenormal denominatorwW denominatordefaultWDefault decodefloatW decodeFloatdeadlockWDeadlockd#WD#cycleXcyclecrosspXcrossP crossmapp5X crossMapP coshfloatSX coshFloat coshdoublerX coshDoublecoshXcoshcosfloatXcosFloat cosdoubleX cosDoublecosXcoscontrolcXControlCconst Yconstconsolehandler,YConsoleHandler consoleeventRY ConsoleEventconcatpuYconcatP concatmappY concatMapP concatmapY concatMapconcatYconcatconcYConc compareint#Y compareInt# compareintZ compareIntcompare;Zcompare cmpintarrayYZ cmpIntArraycmparrayxZcmpArray closedhandleZ ClosedHandlecloseZClosechrZchrchooseZchoose childhandler[ childHandler checkresult#[ checkResultchar>[CharceilingY[ceilingcatchstmt[catchSTMcatchexception[catchExceptioncatch[Catchcatchcaststableptrtoptr[castStablePtrToPtrcastptrtostableptr\castPtrToStablePtrcastptrtofunptr@\castPtrToFunPtrcastptrb\castPtrcastfunptrtoptr\castFunPtrToPtr castfunptr\ castFunPtrcastforeignptr\castForeignPtrc#\C#build]buildbufwptr]bufWPtrbufstate7]bufStatebufsizeR]bufSizebufrptrl]bufRPtr bufferstate] BufferState buffermode] BufferMode bufferlistnil] BufferListNilbufferlistcons]BufferListCons bufferlist^ BufferListbufferiswritable?^bufferIsWritable bufferfulle^ bufferFull bufferempty^ bufferEmptybuffer^Bufferbufbuf^bufBufbreakpointcond^breakpointCond breakpoint_ breakpointbreakp'_breakPbreak>_Breakbreak bpermutepg_ bpermuteP boundsstarray_ boundsSTArraybounds_boundsboundedenumfromthen_boundedEnumFromThenboundedenumfrom_boundedEnumFrombounded`Boundedbool4`BoolblockedondeadmvarU`BlockedOnDeadMVarblockedindefinitely`BlockedIndefinitelyblockbuffering`BlockBufferingblock`blockbindio`bindIObaseaBasebaseaugment'aaugment atomicallyHa atomicallyatanhcaatanhatan2yaatan2atanaatan asyncwritebaa asyncWriteBA~ asyncwritea asyncWrite} asyncreadbaa asyncReadBA| asyncread b asyncRead{asyncexception0bAsyncExceptionwxyz asyncdoprocab asyncDoProcvastypeofbasTypeOfuassocsbassocstassertionfailedbAssertionFailedrs asserterrorb assertErrorqassertcassertpasinhcasinhoasin.casinnasciitabFcasciiTabm arrelebottomfc arrEleBottomlarrayexceptioncArrayExceptionhijkarraycArrayefarraygarrcArrarithexceptioncArithExceptionabcdappprec1%dappPrec1` appendmodeCd AppendMode^_ appendhandleid AppendHandle]anypdanyP\anydany[andpdandPZanddandYamapdamapXalwayssucceedsdalwaysSucceedsWalwaysealwaysV alreadyexists.e AlreadyExistsUallpKeallPTallocatebufferieallocateBufferSalleallRalignptrealignPtrQadjusteadjustPaddmvarfinalizereaddMVarFinalizerOaddforeignptrfinalizer faddForeignPtrFinalizerNaddforeignptrconcfinalizerGfaddForeignPtrConcFinalizerMacoshrfacoshL acosfloatf acosFloatK acosdoublef acosDoubleJacosfacosI accumarrayf accumArrayHaccumfaccumG absoluteseekg AbsoluteSeekF absenterr8g absentErrEabsPgabsD^^ag^^C^pg^B[a]g[a]A[]g[]@>>=g>>=?>>g>>>>=g>==>g><==g==;<=g<=:<h<9:+:h:+:8:*:"h:*:67:%7h:%5:Fh:4/=Uh/=3//eh//2/th/1.h.0-h-/+:+h+:+.++h++,-+h++**h****h*)()h()'(&&i&&&%i%%$"i$$!:1i!:#!!Ai!!"!Pi!!s2p4[Q޼qFb4Ѹi\ڶw$[p3!$^ްh߯BϮh"ܫ`}b,hC1ˣG^"ՠ%Ǟd%G<yIBtjˈ,4F݄OvW8~}|{zzyx.T0( 'e=n#"  yxVH4CABtSiO~ yA\uF= [#[#?חݔw OYPƇ-~a}U{WzyxwHwv?vuctrhqxomihe edIb_a`]]<]\\B\[[_[[Z'ZYXΎ6eDw;Y~5~}#}k|{}{+zyxwTwwvYut]t|srqp?on:n~mlNlk,kjidihFhggPggeLednc;baza_T^\[ZYX~XWPWVvV VU\UTT2SRwRQLQP/PO(NcKPJ1IHGkGGF FED CB{A@??>>a=<~<;:):`910/.&.-,+**!)d(''+'_&&%N%$$3$#&#  +#t1r_yZ Y  !  Y   J nd+kT".:s I.l4,j2eb)gIlTuEh<8^ojm$o$ް0v [zN $)ESQѢe%X^2kє3ޒ8|*ޏ8-FVs\km͂aTd~1~|C{yzy`y|| (||) :: Bool -> Bool -> BoolyyBoolBoolBool Boolean "or" zipWithP zipWithP ::  (a -> b -> c) -> [:a:] -> [:b:] -> [:c:]uzFzabc[::]a[::]b[::]c zipWith3P  zipWith3P :: (a -> b -> c -> d) -> [:a:] -> [:b:] -> [:c:] -> [:d:]?{{abcd[::]a[::]b[::]c[::]d zipWith3 zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]{{abcd[]a[]b[]c[]dThe zipWith3 function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to zipWith.  zipWith zipWith ::  (a -> b -> c) -> [a] -> [b] -> [c]B}}abc[]a[]b[]czipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums. zipPzipP :: [:a:] -> [:b:] ->  [:(a, b):]~~[::]a[::]b[::](,)abzip3P zip3P :: [:a:] -> [:b:] -> [:c:] ->  [:(a, b, c):]`#[::]a[::]b[::]c[::](,,)abc zip3 zip3 :: [a] -> [b] -> [c] ->  [(a, b, c)][]a[]b[]c[](,,)abcVzip3 takes three lists and returns a list of triples, analogous to zip.  zipzip :: [a] -> [b] -> [(a, b)]ɀ[]a[]b[](,)abzip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded.  zeroInteger zeroInteger :: IntegerIntegeryieldyield :: IO ()݁IO()The yield 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. writeWordOffPtr writeWordOffPtr :: Ptr Word -> Int -> Word -> IO ()iDPtrWordIntWordIO()writeWord8OffPtr writeWord8OffPtr ::  Ptr Word8 -> Int -> Word8 -> IO ()PtrWord8IntWord8IO()writeWord64OffPtr writeWord64OffPtr ::  Ptr Word64 -> Int -> Word64 -> IO ()PtrWord64IntWord64IO()writeWord32OffPtr writeWord32OffPtr ::  Ptr Word32 -> Int -> Word32 -> IO ()g>PtrWord32IntWord32IO()writeWord16OffPtr writeWord16OffPtr ::  Ptr Word16 -> Int -> Word16 -> IO ()PtrWord16IntWord16IO()writeWideCharOffPtr writeWideCharOffPtr :: Ptr Char -> Int -> Char -> IO ()PtrCharIntCharIO() writeTVar writeTVar :: TVar a -> a -> STM ()3TVaraaSTM()%Write the supplied value into a TVar  writeSTRef writeSTRef ::  STRef s a -> a -> ST s ()܇STRefsaaSTs()'Write a new value into an STRef  writeSTArray  writeSTArray :: Ix i =>  STArray s i e -> i -> e -> ST s ()IxiSTArraysieieSTs()writeStablePtrOffPtr writeStablePtrOffPtr :: Ptr (StablePtr a) -> Int ->  StablePtr a -> IO ()JPtr StablePtraInt StablePtraIO()writeRawBufferPtrwriteRawBufferPtr :: String -> FD -> Bool ->  Ptr CChar -> Int -> CInt -> IO CInto5StringFDBoolPtrCCharIntCIntIOCIntwriteRawBufferwriteRawBuffer :: String -> FD -> Bool ->  RawBuffer -> Int -> CInt -> IO CIntRStringFDBool RawBufferIntCIntIOCIntwritePtrOffPtr writePtrOffPtr ::  Ptr (Ptr a) -> Int -> Ptr a -> IO ()ϋPtrPtraIntPtraIO() WriteMode WriteMode :: IOModeB9IOMode WriteMode WriteMode :: IOModeIOMode writeIORef writeIORef :: IORef a -> a -> IO ()IORefaaIO()'Write a new value into an IORef  writeIOArray  writeIOArray :: Ix i =>  IOArray i e -> i -> e -> IO ()эIxiIOArrayieieIO())Write a new value into an IOArray writeIntOffPtr writeIntOffPtr :: Ptr Int -> Int -> Int -> IO ()qPtrIntIntIntIO()writeInt8OffPtr writeInt8OffPtr :: Ptr Int8 -> Int -> Int8 -> IO ()4PtrInt8IntInt8IO()writeInt64OffPtr writeInt64OffPtr ::  Ptr Int64 -> Int -> Int64 -> IO ()ڏPtrInt64IntInt64IO()writeInt32OffPtr writeInt32OffPtr ::  Ptr Int32 -> Int -> Int32 -> IO ()YPtrInt32IntInt32IO()writeInt16OffPtr writeInt16OffPtr ::  Ptr Int16 -> Int -> Int16 -> IO ()&PtrInt16IntInt16IO() WriteHandle WriteHandle ::  HandleTypexk HandleTypewriteFunPtrOffPtr writeFunPtrOffPtr :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO ()4PtrFunPtraIntFunPtraIO()writeFloatOffPtr writeFloatOffPtr ::  Ptr Float -> Int -> Float -> IO ()ڒPtrFloatIntFloatIO()writeDoubleOffPtr writeDoubleOffPtr ::  Ptr Double -> Int -> Double -> IO ()]PtrDoubleIntDoubleIO()writeCharIntoBuffer writeCharIntoBuffer ::  RawBuffer -> Int -> Char -> IO Int/  RawBufferIntCharIOInt WriteBuffer WriteBuffer ::  BufferStateu BufferStateWord8data Word88-bit unsigned integer type Word64data Word6464-bit unsigned integer type Word32data Word32J32-bit unsigned integer type Word16data Word1616-bit unsigned integer type Worddata WordNA Word is an unsigned integral type, with the same size as Int. Worddata WordZNA Word is an unsigned integral type, with the same size as Int.  withHandle_  withHandle_ :: String -> Handle -> (Handle__ -> IO a) -> IO aZ)StringHandleHandle__IOaIOa withHandle'  withHandle' :: String -> Handle ->  MVar Handle__ -> (Handle__ -> IO (Handle__, a)) -> IO aTStringHandleMVarHandle__Handle__IO(,)Handle__aIOa withHandle  withHandle :: String -> Handle -> (Handle__ -> IO (Handle__, a)) -> IO a!ߘStringHandleHandle__IO(,)Handle__aIOawin32ConsoleHandlerwin32ConsoleHandler :: MVar (ConsoleEvent -> IO ())MVar ConsoleEventIO()wgencatwgencat :: CInt -> CIntCIntCIntWeakWeak :: Weak# v -> Weak vaGWeak#vWeakvWeakdata Weak v~A weak pointer object with a key and a value. The value has type v. A 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. A 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 finalisers. 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 Weak 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. wantWritableHandle wantWritableHandle :: String -> Handle -> (Handle__ -> IO a) -> IO a͢StringHandleHandle__IOaIOawantSeekableHandle wantSeekableHandle :: String -> Handle -> (Handle__ -> IO a) -> IO a\StringHandleHandle__IOaIOawantReadableHandle wantReadableHandle :: String -> Handle -> (Handle__ -> IO a) -> IO aMStringHandleHandle__IOaIOaW8#W8# :: Word# -> Word8Word#Word8W64#W64# :: Word64# -> Word64Word64#Word64W32#W32# :: Word# -> Word32O=Word#Word32W16#W16# :: Word# -> Word16Word#Word16W#W# :: Word# -> WordWord#WordW#W# :: Word# -> WordA1Word#Word userError userError :: String -> IOErrorStringIOErrorConstruct an IOError value with a string describing the error. The fail method of the IO instance of the Monad class raises a userError, thus: 
instance Monad IO where 
  ...
  fail s = ioError (userError s)
 UserError UserError ::  IOErrorType IOErrorTypeunzipPunzipP ::  [:(a, b):] -> ([:a:], [:b:])J[::](,)ab(,)[::]a[::]bunzip3Punzip3P ::  [:(a, b, c):] -> ([:a:], [:b:], [:c:])%[::](,,)abc(,,)[::]a[::]b[::]c unzip3unzip3 ::  [(a, b, c)] -> ([a], [b], [c])|[](,,)abc(,,)[]a[]b[]cgThe unzip3 function takes a list of triples and returns three lists, analogous to unzip.  unzipunzip :: [(a, b)] ->  ([a], [b])m[](,)ab(,)[]a[]biunzip transforms a list of pairs into a list of first components and a list of second components. until until ::  (a -> Bool) -> (a -> a) -> a -> amaBoolaaaa[until p f yields the result of applying f until p holds. UnsupportedOperationUnsupportedOperation ::  IOErrorTypeJ< IOErrorTypeUnsatisfiedConstraintsUnsatisfiedConstraints ::  IOErrorType IOErrorTypeunsafeWriteSTArray unsafeWriteSTArray :: Ix i =>  STArray s i e -> Int -> e -> ST s ()vAIxiSTArraysieInteSTs()unsafeWriteIOArray unsafeWriteIOArray :: Ix i =>  IOArray i e -> Int -> e -> IO ().IxiIOArrayieInteIO())Write a new value into an IOArray unsafeThawSTArrayunsafeThawSTArray :: Ix i =>  Array i e -> ST s (STArray s i e)ϮIxiArrayieSTsSTArraysie unsafeSTToIO unsafeSTToIO :: ST s a -> IO arZSTsaIOa unsafeReplace unsafeReplace :: Ix i =>  Array i e ->  [(Int, e)] ->  Array i e,IxiArrayie[](,)InteArrayieunsafeReadSTArrayunsafeReadSTArray :: Ix i =>  STArray s i e -> Int -> ST s eڰIxiSTArraysieIntSTseunsafeReadIOArrayunsafeReadIOArray :: Ix i =>  IOArray i e -> Int -> IO e~SIxiIOArrayieIntIOe$Read a value from an IOArray unsafeRangeSizeunsafeRangeSize :: Ix a => (a, a) -> Int Ixa(,)aaIntunsafePerformIOunsafePerformIO :: IO a -> atIOaaThis is the "back door" into the IO monad, allowing IO computation to be performed at any time. For this to be safe, the IO computation should be free of side effects and independent of its environment. If the I/O computation wrapped in unsafePerformIO 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 unsafePerformIO) is indeterminate. You have to be careful when writing and compiling modules that use unsafePerformIO:
  • Use {-# NOINLINE foo #-} as a pragma on any function foo that calls unsafePerformIO. 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).
  • Make sure that the either you switch off let-floating, or that the call to unsafePerformIO cannot float outside a lambda. For example, if you say: f x = unsafePerformIO (newIORef []) you may get only one reference cell shared between all calls to f. Better would be f x = unsafePerformIO (newIORef [x]) because now it can't float outside the lambda.
It is less well known that unsafePerformIO 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 unsafePerformIO. Indeed, it is possible to write coerce :: a -> b with the help of unsafePerformIO. So be careful!  unsafeIOToSTM unsafeIOToSTM :: IO a -> STM aպIOaSTMa'Unsafely performs IO in the STM monad.  unsafeIOToST unsafeIOToST :: IO a -> ST s a}eIOaSTsaunsafeInterleaveSTunsafeInterleaveST :: ST s a -> ST s a޻STsaSTsaunsafeInterleaveIOunsafeInterleaveIO :: IO a -> IO akVIOaIOa unsafeIndex unsafeIndex :: Ix a => (a, a) -> a -> IntмIxa(,)aaaIntunsafeFreezeSTArrayunsafeFreezeSTArray :: Ix i =>  STArray s i e -> ST s (Array i e)mIxiSTArraysieSTsArrayieunsafeForeignPtrToPtrunsafeForeignPtrToPtr ::  ForeignPtr a -> Ptr a/ ForeignPtraPtraThis function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to unsafeForeignPtrToPtr 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, touchForeignPtr must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence. To avoid subtle coding errors, hand written marshalling code should preferably use Foreign.ForeignPtr.withForeignPtr rather than combinations of unsafeForeignPtrToPtr and touchForeignPtr. However, the later routines are occasionally preferred in tool generated marshalling code. unsafeDupablePerformIOunsafeDupablePerformIO :: IO a -> aIOaaunsafeDupableInterleaveIOunsafeDupableInterleaveIO :: IO a -> IO aIOaIOa unsafeChr unsafeChr :: Int -> Chari[IntCharunsafeAtunsafeAt :: Ix i =>  Array i e -> Int -> eIxiArrayieInte unsafeArray'  unsafeArray' :: Ix i => (i, i) -> Int ->  [(Int, e)] ->  Array i esIxi(,)iiInt[](,)InteArrayie unsafeArray unsafeArray :: Ix i => (i, i) ->  [(Int, e)] ->  Array i ef)Ixi(,)ii[](,)InteArrayieunsafeAccumArray'unsafeAccumArray' :: Ix i =>  (e -> a -> e) -> e -> (i, i) -> Int ->  [(Int, a)] ->  Array i ekIxieaee(,)iiInt[](,)IntaArrayieunsafeAccumArray unsafeAccumArray :: Ix i =>  (e -> a -> e) -> e -> (i, i) ->  [(Int, a)] ->  Array i eZIxieaee(,)ii[](,)IntaArrayie unsafeAccum  unsafeAccum :: Ix i =>  (e -> a -> e) ->  Array i e ->  [(Int, a)] ->  Array i e4IxieaeArrayie[](,)IntaArrayie unpackNBytes# unpackNBytes# :: Addr# -> Int# -> [Char]Addr#Int#[]Char unpackNBytes# unpackNBytes# :: Addr# -> Int# -> [Char]8Addr#Int#[]CharunpackFoldrCString# unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> aAddr#CharaaaaunpackFoldrCString# unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> abAddr#CharaaaaunpackCStringUtf8#unpackCStringUtf8# :: Addr# -> [Char]Addr#[]CharunpackCString#unpackCString# :: Addr# -> [Char]dNAddr#[]CharunpackCString#unpackCString# :: Addr# -> [Char]Addr#[]Char unpackCString unpackCString :: Ptr a -> [Char]A(Ptra[]CharunpackAppendCString#unpackAppendCString# :: Addr# -> [Char] -> [Char]Addr#[]Char[]CharunpackAppendCString#unpackAppendCString# :: Addr# -> [Char] -> [Char]qOAddr#[]Char[]CharunmarshalStringunmarshalString :: Addr# -> StringAddr#StringunmarshalObjectunmarshalObject :: Addr# -> Object aP9Addr#ObjectaUnitUnit :: UnitUnitUnitdata UnitunIOunIO :: IO a -> State# RealWorld -> (# State# RealWorld, a #)h&IOaState# RealWorld(#,#)State# RealWorlda Underflow Underflow :: ArithExceptionArithException Underflow Underflow :: ArithExceptionArithExceptionUndefinedElementUndefinedElement :: String -> ArrayExceptionyStringArrayExceptionVAn attempt was made to evaluate an element of an array that had not been initialized. UndefinedElementUndefinedElement :: String -> ArrayExceptionjOStringArrayExceptionVAn attempt was made to evaluate an element of an array that had not been initialized.  undefined undefined :: aaA special case of error. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined appears. uncheckedShiftRL64#uncheckedShiftRL64# :: Word64# -> Int# -> Word64#E*Word64#Int#Word64#uncheckedShiftRL64#uncheckedShiftRL64# :: Word64# -> Int# -> Word64#Word64#Int#Word64#uncheckedShiftL64#uncheckedShiftL64# :: Word64# -> Int# -> Word64#cHWord64#Int#Word64#uncheckedShiftL64#uncheckedShiftL64# :: Word64# -> Int# -> Word64#Word64#Int#Word64#uncheckedIShiftRA64#uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#fInt64#Int#Int64#uncheckedIShiftRA64#uncheckedIShiftRA64# :: Int64# -> Int# -> Int64# Int64#Int#Int64#uncheckedIShiftL64#uncheckedIShiftL64# :: Int64# -> Int# -> Int64#Int64#Int#Int64#uncheckedIShiftL64#uncheckedIShiftL64# :: Int64# -> Int# -> Int64#% Int64#Int#Int64#unblockunblock :: IO a -> IO alIOaIOaTo re-enable asynchronous exceptions inside the scope of block, unblock can be used. It scopes in exactly the same way, so on exit from unblock asynchronous exception delivery will be disabled again. TVardata TVar aAShared memory locations that support atomic memory transactions.  tryTakeMVar tryTakeMVar :: MVar a ->  IO (Maybe a)F&MVaraIOMaybeaA non-blocking version of takeMVar. The tryTakeMVar function returns immediately, with Nothing if the MVar was empty, or Just a if the MVar was full with contents a. After tryTakeMVar, the MVar is left empty.  tryPutMVar tryPutMVar :: MVar a -> a -> IO BoolMVaraaIOBoolA non-blocking version of putMVar. The tryPutMVar function attempts to put the value a into the MVar, returning True if it was successful, or False otherwise. truncatetruncate :: (RealFrac a, Integral b) => a -> b.RealFracaIntegralbabTrueTrue :: Boolf_BooltoUppertoUpper :: Char -> CharCharCharlConvert a letter to the corresponding upper-case letter, if any. Any other character is returned unchanged. touchForeignPtrtouchForeignPtr ::  ForeignPtr a -> IO () ForeignPtraIO()This function ensures that the foreign object in question is alive at the given place in the sequence of IO actions. In particular Foreign.ForeignPtr.withForeignPtr does a touchForeignPtr after it executes the user action. Note that this function should not be used to express dependencies between finalizers on ForeignPtrs. For example, if the finalizer for a ForeignPtr F1 calls touchForeignPtr on a second ForeignPtr F2, then the only guarantee is that the finalizer for F2 is never started before the finalizer for F1. They might be started together if for example both F1 and F2 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 MVars 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. toTitletoTitle :: Char -> CharCharCharConvert 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.  toRational toRational ::  Real a => a -> Rational0RealaaRationaltopHandlerFastExittopHandlerFastExit ::  Exception -> IO a ExceptionIOa topHandler topHandler ::  Exception -> IO a ExceptionIOatoPtoP :: [a] -> [:a:]hQ[]a[::]atoLowertoLower :: Char -> CharCharCharlConvert a letter to the corresponding lower-case letter, if any. Any other character is returned unchanged.  toInteger toInteger :: Integral a => a -> IntegerIntegralaaInteger toEnumError  toEnumError ::  Show a => String -> Int -> (a, a) -> bEShowaStringInt(,)aab toEnumtoEnum ::  Enum a => Int -> aEnumaInta TimeExpired TimeExpired ::  IOErrorType IOErrorTypethrowTothrowTo :: ThreadId ->  Exception -> IO ()}[ThreadId ExceptionIO()7throwTo raises an arbitrary exception in the target thread (GHC only). throwTo 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. This is a useful property to know when dealing with race conditions: eg. 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. If the target thread is currently making a foreign call, then the exception will not be raised (and hence throwTo will not return) until the call has completed. This is the case regardless of whether the call is inside a block or not. Important note: the behaviour of throwTo differs from that described in the paper "Asynchronous exceptions in Haskell" (http://research.microsoft.com/~simonpj/Papers/asynch-exns.htm). In the paper, throwTo is non-blocking; but the library implementation adopts a more synchronous design in which throwTo does not return until the exception is received by the target thread. The trade-off is discussed in Section 8 of the paper. Like any blocking operation, throwTo is therefore interruptible (see Section 4.3 of the paper). There is currently no guarantee that the exception delivered by throwTo will be delivered at the first possible opportunity. In particular, if a thread may unblock and then re-block exceptions (using unblock and block) without receiving a pending throwTo. This is arguably undesirable behaviour. throwIOthrowIO ::  Exception -> IO a ExceptionIOaA variant of throw that can be used within the IO monad. Although throwIO has a type that is an instance of the type of throw, the two functions are subtly different: 
throw e   `seq` x  ===> throw e
throwIO e `seq` x  ===> x
The first example will cause the exception e to be raised, whereas the second one won't. In fact, throwIO will only cause an exception to be raised when it is used within the IO monad. The throwIO variant should be used in preference to throw to raise an exception within the IO monad because it guarantees ordering with respect to other IO operations, whereas throw does not. throwIOthrowIO ::  Exception -> IO a@) ExceptionIOaA variant of throw that can be used within the IO monad. Although throwIO has a type that is an instance of the type of throw, the two functions are subtly different: 
throw e   `seq` x  ===> throw e
throwIO e `seq` x  ===> x
The first example will cause the exception e to be raised, whereas the second one won't. In fact, throwIO will only cause an exception to be raised when it is used within the IO monad. The throwIO variant should be used in preference to throw to raise an exception within the IO monad because it guarantees ordering with respect to other IO operations, whereas throw does not. throwthrow ::  Exception -> a\K Exceptiona}Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad. throwthrow ::  Exception -> a/ Exceptiona}Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad. threadWaitWritethreadWaitWrite :: Fd -> IO ()FdIO()\Block the current thread until data can be written to the given file descriptor (GHC only). threadWaitReadthreadWaitRead :: Fd -> IO ()FdIO()bBlock the current thread until data is available to read on the given file descriptor (GHC only).  ThreadKilled ThreadKilled :: AsyncExceptionAsyncExceptionThis exception is raised by another thread calling Control.Concurrent.killThread, or by the system if it needs to terminate the thread for some reason.  ThreadKilled ThreadKilled :: AsyncExceptionuAsyncExceptionThis exception is raised by another thread calling Control.Concurrent.killThread, or by the system if it needs to terminate the thread for some reason. ThreadIdThreadId ::  ThreadId# -> ThreadIdp ThreadId#ThreadIdThreadIddata ThreadId?A ThreadId is an abstract type representing a handle to a thread. ThreadId is an instance of Eq, Ord and Show, where the Ord instance implements an arbitrary total ordering over ThreadIds. The Show instance lets you convert an arbitrary-valued ThreadId to string form; showing a ThreadId value is occasionally useful when debugging or diagnosing the behaviour of a concurrent program. Note: in GHC, if you have a ThreadId, you essentially have a pointer to the thread itself. This means the thread itself can't be garbage collected until you drop the ThreadId. This misfeature will hopefully be corrected at a later date. Note: Hugs does not provide any operations on other threads; it defines ThreadId as a synonym for ().  threadDelay threadDelay :: Int -> IO ()\JIntIO()Suspends 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. thenIOthenIO :: IO a -> IO b -> IO bIOaIObIOb thawSTArray thawSTArray :: Ix i =>  Array i e -> ST s (STArray s i e)g/IxiArrayieSTsSTArraysietanhtanh :: Floating a => a -> aFloatingaaatantan :: Floating a => a -> a'Floatingaaa takeWhileP takeWhileP ::  (a -> Bool) -> [:a:] -> [:a:]aBool[::]a[::]a takeWhile takeWhile ::  (a -> Bool) -> [a] -> [a]1aBool[]a[]a/takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p: 
takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []
 takeUInt_append takeUInt_append :: Int# -> [b] -> [b] -> [b]Int#[]b[]b[]btakePtakeP :: Int -> [:a:] -> [:a:]jLInt[::]a[::]atakeMVartakeMVar :: MVar a -> IO aMVaraIOaReturn the contents of the MVar. If the MVar is currently empty, takeMVar will wait until it is full. After a takeMVar, the MVar is left empty. There are two further important properties of takeMVar:
  • takeMVar is single-wakeup. That is, if there are multiple threads blocked in takeMVar, and the MVar becomes full, only one thread will be woken up. The runtime guarantees that the woken thread completes its takeMVar operation.
  • When multiple threads are blocked on an MVar, they are woken up in FIFO order. This is useful for providing fairness properties of abstractions built using MVars.
 taketake :: Int -> [a] -> [a]Int[]a[]atake n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length 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 Data.List.genericTake, in which n may be of any integral type.  tailtail :: [a] -> [a][]a[]aHExtract the elements after the head of a list, which must be non-empty.  SystemError SystemError ::  IOErrorType   IOErrorTypesumPsumP ::  Num a => [:a:] -> a  Numa[::]aa succError succError :: String -> aU G Stringa succsucc ::  Enum a => a -> a  Enumaaa subtractsubtract ::  Num a => a -> a -> a  NumaaaastToIOstToIO :: ST RealWorld a -> IO a l ST RealWorldaIOa'A monad transformer embedding strict state transformers in the IO monad. The RealWorld parameter indicates that the internal state used by the ST computation is a special one supplied by the IO monad, and thus distinct from those used by invocations of runST. Stringtype String = [Char] gA String is a list of characters. String constants in Haskell are values of type String. STretSTret :: State# s -> a ->  STret s a  State#saSTretsaSTretdata STret s aSTReptype STRep s a = State# s -> (# State# s, a #)VSTRefSTRef ::  MutVar# s a ->  STRef s aMutVar#saSTRefsaSTRefdata STRef s a{a value of type STRef s a is a mutable variable in state thread s, containing a value of type a STMdata STM a/A monad supporting atomic memory transactions. stdoutstdout :: HandleHandleKA handle managing output to the Haskell program's standard output channel. stdinstdin :: HandleHandleKA handle managing input from the Haskell program's standard input channel. stderrstderr :: Handle$HandleJA handle managing output to the Haskell program's standard error channel. STArray STArray :: i -> i -> Int -> MutableArray# s e ->  STArray s i e-iiInt MutableArray#seSTArraysieSTArraydata STArray s i ee;Mutable, boxed, non-strict arrays in the ST monad. The type arguments are as follows:
  • s: the state variable argument for the ST type
  • i: the index type of the array (should be an instance of Ix)
  • e: the element type of the array.
 StackOverflow StackOverflow :: AsyncExceptionAsyncExceptionThe 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.  StackOverflow StackOverflow :: AsyncException'AsyncExceptionThe 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.  StablePtr StablePtr ::  StablePtr# a ->  StablePtr apL StablePtr#a StablePtra StablePtrdata  StablePtr aA 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 a is a stable pointer to a Haskell expression of type a. STST ::  STRep s a -> ST s aSTRepsaSTsaSTnewtype ST s aNThe strict state-transformer monad. A computation of type ST s a transforms an internal state indexed by s, and returns a value of type a. The s parameter is either
  • an uninstantiated type variable (inside invocations of runST), or
  • RealWorld (inside invocations of Control.Monad.ST.stToIO).
It serves to keep the internal states of different invocations of runST separate from each other and from invocations of Control.Monad.ST.stToIO. The >>= and >> operations are strict in the state (though not in values stored in the state). For example, 
runST (writeSTRef _|_ v >>= f) = _|_
sqrtsqrt :: Floating a => a -> apFloatingaaasplitAtPsplitAtP :: Int -> [:a:] -> ([:a:], [:a:])Int[::]a(,)[::]a[::]a splitAtsplitAt :: Int -> [a] ->  ([a], [a])vInt[]a(,)[]a[]aqsplitAt n xs returns a tuple where first element is xs prefix of length n 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 (take n xs, drop n xs). splitAt is an instance of the more general Data.List.genericSplitAt, in which n may be of any integral type. spanPspanP ::  (a -> Bool) -> [:a:] -> ([:a:], [:a:]) v aBool[::]a(,)[::]a[::]a spanspan ::  (a -> Bool) -> [a] ->  ([a], [a])9! !aBool[]a(,)[]a[]aspan, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p 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])
span p xs is equivalent to (takeWhile p xs, dropWhile p xs)  slurpFile slurpFile :: FilePath -> IO (Ptr (), Int)#}#FilePathIO(,)Ptr()IntsliceP sliceP :: Int -> Int -> [:e:] -> [:e:]/$ $IntInt[::]e[::]esinhsinh :: Floating a => a -> a$x$Floatingaaasinsin :: Floating a => a -> a$$Floatingaaa signumsignum ::  Num a => a -> aJ%7%Numaaa significand significand :: RealFloat a => a -> a%% RealFloataaaShutdownShutdown ::  ConsoleEvent &% ConsoleEventShutdownShutdown ::  ConsoleEvent[&L& ConsoleEvent showString showString :: String -> ShowS&&StringShowSjutility function converting a String to a show function that simply prepends the string unchanged.  showsPrec showsPrec ::  Show a => Int -> a -> ShowS''ShowaIntaShowS showSpace showSpace :: ShowS''ShowS showSignedInt showSignedInt :: Int -> Int -> ShowS`(L(IntIntShowSshowSignedFloat showSignedFloat :: RealFloat a => a -> ShowS -> Int -> a -> ShowS)( RealFloataaShowSIntaShowS showSigned  showSigned ::  Real a => a -> ShowS -> Int -> a -> ShowS))RealaaShowSIntaShowS<Converts a possibly-negative Real value to a string.  showsshows ::  Show a => a -> ShowSe*M*ShowaaShowS7equivalent to showsPrec with a precedence of 0.  ShowStype ShowS = String -> String*The shows functions return a function that prepends the output String to an existing String. This allows constant-time concatenation of results using function composition.  showParen showParen :: Bool -> ShowS -> ShowS,+BoolShowSShowSxutility function that surrounds the inner show function with parentheses when the Bool parameter is True.  showLitChar showLitChar :: Char -> ShowS,,CharShowSConvert a character to a string using only printable characters, using Haskell source-language escape conventions. For example: 
showLitChar '\n' s  =  "\\n" ++ s
 showList__ showList__ ::  (a -> ShowS) -> [a] -> ShowS"..aShowS[]aShowS showListshowList ::  Show a => [a] -> ShowS.u.Showa[]aShowS showFloat showFloat :: RealFloat a => a -> ShowS/. RealFloataaShowSShow a signed RealFloat 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.  showCharshowChar :: Char -> ShowS10!0CharShowSkutility function converting a Char to a show function that simply prepends the character unchanged.  showshow ::  Show a => a -> String00ShowaaString Showclass Show a.1.Conversion of values to readable Strings. Minimal complete definition: showsPrec or show. Derived instances of Show have the following properties, which are compatible with derived instances of Text.Read.Read:
  • The result of show 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 showsPrec will produce infix applications of the constructor.
  • the 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 11 it is always surrounded in parentheses, unless it is an atomic expression.
  • If the constructor is defined using record syntax, then show will produce the record-syntax form, with the fields given in the same order as the original declaration.
For example, given the declarations 
infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a
the derived instance of Show 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,
  • show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
shiftRL#shiftRL# :: Word# -> Int# -> Word#99Word#Int#Word#WShift the argument right by the specified number of bits (which must be non-negative). shiftRL#shiftRL# :: Word# -> Int# -> Word#::Word#Int#Word#WShift the argument right by the specified number of bits (which must be non-negative). shiftL#shiftL# :: Word# -> Int# -> Word#^;G;Word#Int#Word#VShift the argument left by the specified number of bits (which must be non-negative). shiftL#shiftL# :: Word# -> Int# -> Word#$< <Word#Int#Word#VShift the argument left by the specified number of bits (which must be non-negative). SemiClosedHandleSemiClosedHandle ::  HandleType<< HandleTypeSeekModedata SeekMode =SA mode that determines the effect of hSeek hdl mode i, as follows:  SeekFromEnd SeekFromEnd :: SeekMode==SeekModeSthe position of hdl is set to offset i from the end of the file. scanrP scanrP ::  (a -> b -> b) -> b -> [:a:] -> [:b:]>k>abbb[::]a[::]bscanr1Pscanr1P ::  (a -> a -> a) -> [:a:] -> [:a:]?>aaa[::]a[::]a scanr1scanr1 ::  (a -> a -> a) -> [a] -> [a]?t?aaa[]a[]aPscanr1 is a variant of scanr that has no starting value argument.  scanr scanr ::  (a -> b -> b) -> b -> [a] -> [b]n@K@abbb[]a[]buscanr is the right-to-left dual of scanl. Note that 
head (scanr f z xs) == foldr f z xs.
scanlP scanlP ::  (a -> b -> a) -> a -> [:b:] -> [:a:]wAPAabaa[::]b[::]ascanl1Pscanl1P ::  (a -> a -> a) -> [:a:] -> [:a:]AAaaa[::]a[::]a scanl1scanl1 ::  (a -> a -> a) -> [a] -> [a]yBYBaaa[]a[]ascanl1 is a variant of scanl that has no starting value argument: 
scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
 scanl scanl ::  (a -> b -> a) -> a -> [b] -> [a]CmCabaa[]b[]ascanl is similar to foldl, 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.
scaleRatscaleRat :: Rational -> Int -> Rational -> Rational -> Int -> Rational -> (Rational, Int)E7ERationalIntRationalRationalIntRational(,)RationalInt scaleFloat scaleFloat :: RealFloat a => Int -> a -> aFE RealFloataIntaa safeRangeSize safeRangeSize :: Ix i => (i, i) -> IntFaFIxi(,)iiInt safeIndex  safeIndex :: Ix i => (i, i) -> Int -> i -> IntGFIxi(,)iiIntiInt S#S# :: Int# -> IntegergGUGInt#IntegerS#S# :: Int# -> IntegerGGInt#IntegerrunSTReprunSTRep ::  STRep s a -> aHHSTRepsaarunSTrunST :: ST s a -> amH[HSTsaaReturn the value computed by a state transformer computation. The forall ensures that the internal state used by the ST computation is inaccessible to the rest of the program. runNonIOrunNonIO :: a -> IO aIsIaIOaThe same as runIO, but for non-IO computations. Used for wrapping foreign export and foreign import "wrapper" when these are used to export Haskell functions with non-IO types.  runMainIO runMainIO :: IO a -> IO aJJIOaIOarunMainIO is wrapped around Main.main (or whatever main is called in the program). It catches otherwise uncaught exceptions, and also flushes stdout/stderr before exiting.  runIOFastExit runIOFastExit :: IO a -> IO aKKIOaIOa]Like runIO, 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, try main = 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. runIOrunIO :: IO a -> IO a|NgNIOaIOarunIO is wrapped around every foreign export and foreign import "wrapper" to mop up any uncaught exceptions. Thus, the result of running System.Exit.exitWith in a foreign-exported function is the same as in the main thread: it terminates the program. runFinalizerBatchrunFinalizerBatch :: Int -> Array# (IO ()) -> IO ()+PPIntArray#IO()IO()roundTo roundTo :: Int -> Int -> [Int] ->  (Int, [Int])PPIntInt[]Int(,)Int[]Introundround :: (RealFrac a, Integral b) => a -> bHQ!QRealFracaIntegralbabreversePreverseP :: [:a:] -> [:a:]QQ[::]a[::]a reversereverse :: [a] -> [a]RQ[]a[]amreverse xs returns the elements of xs in reverse order. xs must be finite. returnIOreturnIO :: a -> IO aRRaIOareturnreturn ::  Monad m => a -> m a.SSMonadmamaretryretry :: STM amSbSSTMa-Retry 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) ResourceVanishedResourceVanished ::  IOErrorTypeTT IOErrorTypeResourceExhaustedResourceExhausted ::  IOErrorTypeXUJU IOErrorType ResourceBusy ResourceBusy ::  IOErrorTypeUU IOErrorTypereportStackOverflowreportStackOverflow :: IO aVUIOa reportError reportError ::  Exception -> IO arV[V ExceptionIOa replicateP replicateP :: Int -> a -> [:a:]VVInta[::]a replicate replicate :: Int -> a -> [a]LW8WInta[]a repeatrepeat :: a -> [a]WWa[]aZrepeat x is an infinite list, with x the value of every element.  remInteger remInteger :: Integer -> Integer -> IntegerzX\XIntegerIntegerIntegerremrem :: Integral a => a -> a -> aXXIntegralaaaa RelativeSeek RelativeSeek :: SeekMode9Y.YSeekModeTthe position of hdl is set to offset i from the current position.  registerDelay registerDelay :: Int -> IO (TVar Bool)ZYIntIOTVarBoolSet the value of returned TVar to True after a given number of microseconds. The caveats associated with threadDelay also apply. reducereduce :: Integral a => a -> a -> Ratio a [ZIntegralaaaRatioa RecUpdError RecUpdError :: String ->  Exceptionv[`[String Exception7An attempt was made to update a field in a record, where the record doesn't have the requested field. This can only occur with multi-constructor records, when one or more fields are missing from some of the constructors. The String argument gives the location of the record update in the source program.  RecUpdError RecUpdError :: String ->  Exception]]String Exception7An attempt was made to update a field in a record, where the record doesn't have the requested field. This can only occur with multi-constructor records, when one or more fields are missing from some of the constructors. The String argument gives the location of the record update in the source program.  RecSelError RecSelError :: String ->  Exception^^String Exception'A field selection was attempted on a constructor that doesn't have the requested field. This can happen with multi-constructor records when one or more fields are missing from some of the constructors. The String argument gives the location of the record selection in the source program.  RecSelError RecSelError :: String ->  ExceptionO`9`String Exception'A field selection was attempted on a constructor that doesn't have the requested field. This can happen with multi-constructor records when one or more fields are missing from some of the constructors. The String argument gives the location of the record selection in the source program. reciprecip :: Fractional a => a -> aaa Fractionalaaa recConError recConError :: Addr# -> a7b*bAddr#a RecConError RecConError :: String ->  ExceptionbbString ExceptionAn attempt was made to evaluate a field of a record for which no value was given at construction time. The String argument gives the location of the record construction in the source program.  RecConError RecConError :: String ->  ExceptionccString ExceptionAn attempt was made to evaluate a field of a record for which no value was given at construction time. The String argument gives the location of the record construction in the source program.  realToFrac realToFrac :: (Real a, Fractional b) => a -> b#edReala Fractionalbab%general coercion to fractional types RealFracclass (Real a, Fractional a) => RealFrac aeXExtracting components of fractions. Minimal complete definition: properFraction  RealFloatclass (RealFrac a, Floating a) =>  RealFloat aFfEfficient, machine-independent access to the components of a floating-point number. Minimal complete definition: all except exponent, significand, scaleFloat and atan2 Realclass (Num a, Ord a) => Real aLg ReadWriteMode ReadWriteMode :: IOModeggIOMode ReadWriteMode ReadWriteMode :: IOModeggIOModeReadWriteHandleReadWriteHandle ::  HandleTypeBh5h HandleTypereadWordOffPtrreadWordOffPtr :: Ptr Word -> Int -> IO WordhhPtrWordIntIOWordreadWord8OffPtrreadWord8OffPtr ::  Ptr Word8 -> Int -> IO Word8`i=iPtrWord8IntIOWord8readWord64OffPtrreadWord64OffPtr ::  Ptr Word64 -> Int ->  IO Word64iiPtrWord64IntIOWord64readWord32OffPtrreadWord32OffPtr ::  Ptr Word32 -> Int ->  IO Word32jkjPtrWord32IntIOWord32readWord16OffPtrreadWord16OffPtr ::  Ptr Word16 -> Int ->  IO Word16(kkPtrWord16IntIOWord16readWideCharOffPtrreadWideCharOffPtr :: Ptr Char -> Int -> IO CharkkPtrCharIntIOCharreadTVarreadTVar :: TVar a -> STM a llTVaraSTMa*Return the current value stored in a TVar  readSTRef readSTRef ::  STRef s a -> ST s allSTRefsaSTsa"Read the value of an STRef  readSTArray readSTArray :: Ix i =>  STArray s i e -> i -> ST s ezmKmIxiSTArraysieiSTsereadStablePtrOffPtrreadStablePtrOffPtr :: Ptr (StablePtr a) -> Int -> IO (StablePtr a)6nnPtr StablePtraIntIO StablePtra readsPrec readsPrec ::  Read a => Int -> ReadS annReadaIntReadSareadsreads ::  Read a => ReadS aonReadaReadSa7equivalent to readsPrec with a precedence of 0. ReadStype ReadS a = String -> [(a, String)]o A parser for a type a, represented as a function that takes a String and returns a list of possible parses as (a,String) pairs. Note that this kind of backtracking parser is very inefficient; reading a large structure may be quite slow (cf ReadP). readRawBufferPtrNoBlockreadRawBufferPtrNoBlock :: String -> FD -> Bool ->  Ptr CChar -> Int -> CInt -> IO CIntqeqStringFDBoolPtrCCharIntCIntIOCIntreadRawBufferPtrreadRawBufferPtr :: String -> FD -> Bool ->  Ptr CChar -> Int -> CInt -> IO CIntrOrStringFDBoolPtrCCharIntCIntIOCIntreadRawBufferNoBlockreadRawBufferNoBlock :: String -> FD -> Bool ->  RawBuffer -> Int -> CInt -> IO CIntxsAsStringFDBool RawBufferIntCIntIOCInt readRawBuffer readRawBuffer :: String -> FD -> Bool ->  RawBuffer -> Int -> CInt -> IO CIntYt"tStringFDBool RawBufferIntCIntIOCInt readPtrOffPtr readPtrOffPtr ::  Ptr (Ptr a) -> Int ->  IO (Ptr a)ttPtrPtraIntIOPtrareadPrecreadPrec ::  Read a =>  ReadPrec aUu:uReadaReadPreca readParen readParen :: Bool -> ReadS a -> ReadS auuBoolReadSaReadSareadParen True p parses what p parses, but surrounded with parentheses. readParen False p parses what p parses, but optionally surrounded with parentheses. readpreadp ::  Read a => ReadP a wvReadaReadPaReadModeReadMode :: IOModePwGwIOModeReadModeReadMode :: IOModewwIOMode readLitChar readLitChar ::  ReadS CharwwReadSCharRead 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")]
readListPrecDefaultreadListPrecDefault ::  Read a =>  ReadPrec [a]Cy"yReadaReadPrec[]apA possible replacement definition for the readListPrec method, defined using readPrec (GHC only).  readListPrec readListPrec ::  Read a =>  ReadPrec [a]'zzReadaReadPrec[]areadListDefaultreadListDefault ::  Read a =>  ReadS [a]z}zReadaReadS[]aA possible replacement definition for the readList method (GHC only). This is only needed for GHC, and even then only for Read instances where readListPrec isn't defined as readListPrecDefault. readListreadList ::  Read a =>  ReadS [a]{{ReadaReadS[]a readIORef readIORef :: IORef a -> IO aE|-|IORefaIOa"Read the value of an IORef  readIOArray readIOArray :: Ix i =>  IOArray i e -> i -> IO e||IxiIOArrayieiIOe$Read a value from an IOArray  readIntOffPtr readIntOffPtr :: Ptr Int -> Int -> IO Int}}PtrIntIntIOIntreadInt8OffPtrreadInt8OffPtr :: Ptr Int8 -> Int -> IO Int81~~PtrInt8IntIOInt8readInt64OffPtrreadInt64OffPtr ::  Ptr Int64 -> Int -> IO Int64~~PtrInt64IntIOInt64readInt32OffPtrreadInt32OffPtr ::  Ptr Int32 -> Int -> IO Int32U2PtrInt32IntIOInt32readInt16OffPtrreadInt16OffPtr ::  Ptr Int16 -> Int -> IO Int16PtrInt16IntIOInt16 ReadHandle ReadHandle ::  HandleType7* HandleTypereadFunPtrOffPtrreadFunPtrOffPtr :: Ptr (FunPtr a) -> Int ->  IO (FunPtr a)PtrFunPtraIntIOFunPtrareadFloatOffPtrreadFloatOffPtr ::  Ptr Float -> Int -> IO FloatsPPtrFloatIntIOFloat readEither readEither ::  Read a => String -> Either String aׁReadaStringEitherStringareadDoubleOffPtrreadDoubleOffPtr ::  Ptr Double -> Int ->  IO DoubleuPtrDoubleIntIODoublereadCharFromBufferreadCharFromBuffer ::  RawBuffer -> Int -> IO (Char, Int)@ RawBufferIntIO(,)CharInt ReadBuffer ReadBuffer ::  BufferState BufferStatereadread ::  Read a => String -> a܃ReadaStringalThe read function reads input from a string, which must be completely consumed by the input process. Readclass Read a Parsing of Strings, producing values. Minimal complete definition: readsPrec (or, for GHC only, readPrec) Derived instances of Read make the following assumptions, which derived instances of Text.Show.Show obey:
  • If the constructor is defined to be an infix operator, then the derived Read instance will parse only infix applications of the constructor (not the prefix form).
  • Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
  • If the constructor is defined using record syntax, the derived Read will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
  • The derived Read instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.
For example, given the declarations 
infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a
the derived instance of Read in Haskell 98 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 
instance (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
 RawBuffertype  RawBuffer = MutableByteArray# RealWorld ratioPrec1 ratioPrec1 :: IntʎĎIntRationaltype Rational = Ratio IntegerArbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator. Ratiodata Integral a => Ratio aORational numbers, with numerator and denominator of some Integral type.  rangeSize rangeSize :: Ix a => (a, a) -> IntIxa(,)aaIntrangerange :: Ix a => (a, a) -> [a]Ixa(,)aa[]a quotRemIntegerquotRemInteger :: Integer -> Integer -> (Integer, Integer)IntegerInteger(,)IntegerInteger quotRemInt quotRemInt :: Int -> Int ->  (Int, Int)@"IntInt(,)IntIntquotRemquotRem :: Integral a => a -> a -> (a, a)ƒIntegralaaa(,)aa quotInteger quotInteger :: Integer -> Integer -> IntegerL.IntegerIntegerIntegerquotquot :: Integral a => a -> a -> aIntegralaaaaputMVarputMVar :: MVar a -> a -> IO ()/MVaraaIO()Put a value into an MVar. If the MVar is currently full, putMVar will wait until it becomes empty. There are two further important properties of putMVar:
  • putMVar is single-wakeup. That is, if there are multiple threads blocked in putMVar, and the MVar becomes empty, only one thread will be woken up. The runtime guarantees that the woken thread completes its putMVar operation.
  • When multiple threads are blocked on an MVar, they are woken up in FIFO order. This is useful for providing fairness properties of abstractions built using MVars.
PtrPtr :: Addr# -> Ptr aAddr#PtraPtrdata Ptr a3A value of type Ptr a 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 Foreign.Storable.Storable 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. PtrPtr :: Addr# -> Ptr ao[Addr#PtraPtrdata Ptr aA value of type Ptr a 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 Foreign.Storable.Storable 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. pseqpseq :: a -> b -> b֛ʛabb ProtocolError ProtocolError ::  IOErrorType.  IOErrorType protectEsc protectEsc :: (Char -> Bool) -> ShowS -> ShowSCharBoolShowSShowSproperFractionproperFraction :: (RealFrac a, Integral b) => a -> (b, a)W&RealFracaIntegralba(,)baproductPproductP ::  Num a => [:a:] -> aNuma[::]aa predError predError :: String -> a Stringa predpred ::  Enum a => a -> as_Enumaaa powerFloat powerFloat :: Float -> Float -> FloatӞFloatFloatFloat powerDouble powerDouble :: Double -> Double -> DoublekPDoubleDoubleDoubleplusPtrplusPtr :: Ptr a -> Int -> Ptr bߟßPtraIntPtrb9Advances the given address by the given offset in bytes. pipi :: Floating a => acPFloatingaapermutePpermuteP :: [:Int:] -> [:e:] -> [:e:][::]Int[::]e[::]ePermissionDeniedPermissionDenied ::  IOErrorTypeE7 IOErrorTypePatternMatchFailPatternMatchFail :: String ->  ExceptionString ExceptionA pattern matching failure. The String argument should contain a descriptive message including the function name, source file and line number. PatternMatchFailPatternMatchFail :: String ->  ExceptionǢString ExceptionA pattern matching failure. The String argument should contain a descriptive message including the function name, source file and line number. parensparens ::  ReadPrec a ->  ReadPrec aϣReadPrecaReadPreca(parens p) parses "P", "(P0)", "((P0))", etc, where p parses "P" in the current precedence context and parses "P0" in precedence context zero parenparen ::  ReadPrec a ->  ReadPrec aߤReadPrecaReadPrecaY(paren p) parses "(P0)" where p parses "P0" in precedence context zero parpar :: a -> b -> b~abb packCString# packCString# :: [Char] ->  ByteArray#[]Char ByteArray# overflowError overflowError :: aB>aOverflowOverflow :: ArithExceptionArithExceptionOverflowOverflow :: ArithException٦ArithException otherwise otherwise :: Bool,%Boolotherwise is defined as the value True. It helps to make guards more readable. eg. 
f x | x < 0     = ...
    | otherwise = ...
 OtherError OtherError ::  IOErrorType IOErrorTypeorPorP :: [:Bool:] -> Boolv_[::]BoolBoolorElseorElse :: STM a -> STM a -> STM aΨSTMaSTMaSTMaCompose 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. Orderingdata Ordering:Represents an ordering relationship between two values: less than, equal to, or greater than. An Ordering is returned by compare. ordord :: Char -> IntCharIntCThe Prelude.fromEnum method restricted to the type Data.Char.Char. Ordclass Eq a => Ord aThe Ord class is used for totally ordered datatypes. Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects. Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.  oror :: [Bool] -> Bool߭[]BoolBoolor returns the disjunction of a Boolean list. For the result to be False, the list must be finite; True, however, results from a True value at a finite index of a finite or infinite list. openFileopenFile :: FilePath -> IOMode ->  IO HandleS0FilePathIOModeIOHandle/Computation openFile file mode allocates and returns a new, open handle to manage the file file. It manages input if mode is ReadMode, output if mode is WriteMode or AppendMode, and both input and output if mode is ReadWriteMode. If the file does not exist and it is opened for output, it should be created as a new file. If mode is WriteMode 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 openFile with mode WriteMode unless it is subsequently written to successfully. The handle is positioned at the end of the file if mode is AppendMode, 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: Note: if you will be working with files containing binary data, you'll want to be using openBinaryFile. openBinaryFileopenBinaryFile :: FilePath -> IOMode ->  IO HandleFilePathIOModeIOHandleLike openFile, 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.) Opaquedata Opaque"oneIntoneInt :: Int\VIntoddodd :: Integral a => a -> BoolIntegralaaBoolObjectdata Object aOO :: a -> Opaque;-aOpaquenumericEnumFromTonumericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]Orda Fractionalaaa[]anumericEnumFromThenTo numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]wOrda Fractionalaaaa[]anumericEnumFromThennumericEnumFromThen :: Fractional a => a -> a -> [a]B Fractionalaaa[]anumericEnumFromnumericEnumFrom :: Fractional a => a -> [a]ź Fractionalaa[]a numerator numerator :: Integral a => Ratio a -> a?IntegralaRatioaaExtract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive. numElementsSTArraynumElementsSTArray ::  STArray s i e -> IntI-STArraysieInt numElements numElements :: Ix i =>  Array i e -> IntļIxiArrayieIntnumCapabilitiesnumCapabilities :: Int Intthe 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 CPU cores on the machine.  Numclass (Eq a, Show a) => Num a"\Basic numeric class. Minimal complete definition: all except negate or (-) nullPtrnullPtr :: Ptr aPtra~The constant nullPtr contains a distinguished value of Ptr that is not associated with a valid memory location. nullPnullP :: [:a:] -> Bool[::]aBool nullFunPtr nullFunPtr :: FunPtr aؿFunPtraThe constant nullFunPtr contains a distinguished value of FunPtr that is not associated with a valid memory location.  nullnull :: [a] -> Bool[]aBoolTest whether a list is empty. notElemPnotElemP :: Eq a => a -> [:a:] -> BoolY9Eqaa[::]aBool notElemnotElem :: Eq a => a -> [a] -> BoolEqaa[]aBool/notElem is the negation of elem.  notANumber notANumber :: RationalMBRationalnotnot :: Bool -> BoolBoolBoolBoolean "not"  NoSuchThing NoSuchThing ::  IOErrorType IOErrorTypeNonTerminationNonTermination ::  ExceptionSG Exception~The current thread is stuck in an infinite loop. This exception may or may not be thrown when the program is non-terminating. NonTerminationNonTermination ::  Exception' Exception~The current thread is stuck in an infinite loop. This exception may or may not be thrown when the program is non-terminating.  NoMethodError NoMethodError :: String ->  ExceptionString ExceptionAn attempt was made to invoke a class method which has no definition in this instance, and there was no default definition given in the class declaration. GHC issues a warning when you compile an instance which has missing methods.  NoMethodError NoMethodError :: String ->  ExceptionmWString ExceptionAn attempt was made to invoke a class method which has no definition in this instance, and there was no default definition given in the class declaration. GHC issues a warning when you compile an instance which has missing methods.  noDuplicate noDuplicate :: IO ()IO()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 noDuplicate. This operation is used in the definition of unsafePerformIO to prevent the IO action from being executed multiple times, which is usually undesirable.  NoBuffering NoBuffering ::  BufferModesf BufferMode#buffering is disabled if possible.  newTVarIO newTVarIO :: a ->  IO (TVar a)aIOTVaraIO version of newTVar. This is useful for creating top-level TVars using System.IO.Unsafe.unsafePerformIO, because using atomically inside System.IO.Unsafe.unsafePerformIO isn't possible. newTVarnewTVar :: a ->  STM (TVar a):"aSTMTVara+Create a new TVar holding a value supplied newSTRefnewSTRef :: a -> ST s (STRef s a)aSTsSTRefsa5Build a new STRef in the current state thread  newSTArray newSTArray :: Ix i => (i, i) -> e -> ST s (STArray s i e)~Ixi(,)iieSTsSTArraysie newStablePtr newStablePtr :: a -> IO (StablePtr a)-aIO StablePtra>Create a stable pointer referring to the given Haskell value. newMVarnewMVar :: a ->  IO (MVar a)aIOMVara9Create an MVar which contains the supplied value. newIORefnewIORef :: a ->  IO (IORef a)lTaIOIORefaBuild a new IORef  newIOArray newIOArray :: Ix i => (i, i) -> e -> IO (IOArray i e)(Ixi(,)iieIOIOArrayieBuild a new IOArray newForeignPtr_newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)PtraIO ForeignPtraTurns a plain memory reference into a foreign pointer that may be associated with finalizers by using addForeignPtrFinalizer.  newEmptyMVar newEmptyMVar ::  IO (MVar a)IOMVara0Create an MVar which is initially empty. newEmptyBuffer newEmptyBuffer ::  RawBuffer ->  BufferState -> Int -> Buffer[ RawBuffer BufferStateIntBuffernewConcForeignPtrnewConcForeignPtr :: Ptr a -> IO () -> IO (ForeignPtr a)+PtraIO()IO ForeignPtra 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. NestedAtomicallyNestedAtomically ::  Exception ExceptionThe runtime detected an attempt to nest one STM transaction inside another one, presumably due to the use of unsafePeformIO with atomically. NestedAtomicallyNestedAtomically ::  Exceptionxl ExceptionThe runtime detected an attempt to nest one STM transaction inside another one, presumably due to the use of unsafePeformIO with atomically.  negateInt negateInt :: Int -> Int[NIntInt negateFloat negateFloat :: Float -> FloatFloatFloat negateDouble negateDouble :: Double -> Double%DoubleDouble negatenegate ::  Num a => a -> amNumaaa myThreadId myThreadId ::  IO ThreadIdIOThreadId>Returns the ThreadId of the calling thread (GHC only). MVarMVar :: MVar# RealWorld a -> MVar acMVar# RealWorldaMVaraMVardata MVar aAn MVar (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. MVardata MVar aAn MVar (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. Monadclass Monad myThe Monad class defines the basic operations over a monad, 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 do expressions provide a convenient syntax for writing monadic expressions. Minimal complete definition: >>= and return. Instances of Monad should satisfy the following laws: 
return a >>= k  ==  k a
m >>= return  ==  m
m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h
Instances of both Monad and Functor should additionally satisfy the law: 
fmap f xs  ==  xs >>= return . f
The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO defined in the Prelude satisfy these laws. modInt#modInt# :: Int# -> Int# -> Int#oZInt#Int#Int#modmod :: Integral a => a -> a -> aIntegralaaaamkWeak mkWeak :: k -> v ->  Maybe (IO ()) ->  IO (Weak v)zMkvMaybeIO()IOWeakvEstablishes a weak pointer to k, with value v and a finalizer. This is the most general interface for building a weak pointer. minusPtrminusPtr :: Ptr a -> Ptr b -> IntfPtraPtrbIntComputes the offset required to get from the first to the second argument. We have 
p2 == p1 `plusPtr` (p2 `minusPtr` p1)
minusIntminusInt :: Int -> Int -> Intq_IntIntInt minusFloat minusFloat :: Float -> Float -> FloatFloatFloatFloat minusDouble minusDouble :: Double -> Double -> DoubleiNDoubleDoubleDoubleminimumPminimumP ::  Ord a => [:a:] -> aOrda[::]aa minBoundminBound ::  Bounded a => a)Boundedaaminmin ::  Ord a => a -> a -> axOrdaaaamemcpy_ptr_baoff memcpy_ptr_baoff :: Ptr a ->  RawBuffer -> CInt -> CSize ->  IO (Ptr ())[%Ptra RawBufferCIntCSizeIOPtr()memcpy_baoff_ptr memcpy_baoff_ptr ::  RawBuffer -> CInt -> Ptr a -> CSize ->  IO (Ptr ())( RawBufferCIntPtraCSizeIOPtr()memcpy_baoff_ba memcpy_baoff_ba ::  RawBuffer -> CInt ->  RawBuffer -> CSize ->  IO (Ptr ()) RawBufferCInt RawBufferCSizeIOPtr()memcpy_ba_baoff memcpy_ba_baoff ::  RawBuffer ->  RawBuffer -> CInt -> CSize ->  IO (Ptr ()) RawBuffer RawBufferCIntCSizeIOPtr()maximumPmaximumP ::  Ord a => [:a:] -> a3Orda[::]aamaxExptmaxExpt :: IntoiInt maxBoundmaxBound ::  Bounded a => aBoundedaamaxmax ::  Ord a => a -> a -> a)Ordaaaa marshalString marshalString :: String -> (Addr# -> IO a) -> IO aStringAddr#IOaIOa marshalObject marshalObject :: Object a -> (Addr# -> IO b) -> IO b\1ObjectaAddr#IObIObmapPmapP :: (a -> b) -> [:a:] -> [:b:]ab[::]a[::]bmapFB mapFB :: (elt -> lst -> lst) ->  (a -> elt) -> a -> lst -> lstWeltlstlstaeltalstlst mapmap :: (a -> b) -> [a] -> [b]ab[]a[]bmap 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, ...]
mapmap :: (a -> b) -> [a] -> [b]3ab[]a[]bmap 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, ...]
mallocPlainForeignPtrBytesmallocPlainForeignPtrBytes :: Int -> IO (ForeignPtr a)IntIO ForeignPtraThis function is similar to mallocForeignPtrBytes, 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. mallocPlainForeignPtrmallocPlainForeignPtr :: Storable a => IO (ForeignPtr a)StorableaIO ForeignPtraAllocate some memory and return a ForeignPtr to it. The memory will be released automatically when the ForeignPtr is discarded. GHC notes: mallocPlainForeignPtr 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. mallocForeignPtrBytesmallocForeignPtrBytes :: Int -> IO (ForeignPtr a)nOIntIO ForeignPtraThis function is similar to mallocForeignPtr, except that the size of the memory required is given explicitly as a number of bytes. mallocForeignPtrmallocForeignPtr :: Storable a => IO (ForeignPtr a)]StorableaIO ForeignPtraAllocate some memory and return a ForeignPtr to it. The memory will be released automatically when the ForeignPtr is discarded. mallocForeignPtr is equivalent to 
do { p <- malloc; newForeignPtr finalizerFree p }
although it may be implemented differently internally: you may not assume that the memory returned by mallocForeignPtr has been allocated with Foreign.Marshal.Alloc.malloc. GHC notes: mallocForeignPtr has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, so the ForeignPtr does not require a finalizer to free the memory. Use of mallocForeignPtr and associated functions is strongly recommended in preference to newForeignPtr with a finalizer. LTLT :: OrderingOrderingLossOfPrecisionLossOfPrecision :: ArithException%ArithExceptionLossOfPrecisionLossOfPrecision :: ArithExceptionvArithExceptionlookupPlookupP :: Eq a => a ->  [:(a, b):] -> Maybe bEqaa[::](,)abMaybeb lookuplookup :: Eq a => a -> [(a, b)] -> Maybe b}Eqaa[](,)abMaybebIlookup key assocs looks up a key in an association list. LogoffLogoff ::  ConsoleEvent@1 ConsoleEventLogoffLogoff ::  ConsoleEvent} ConsoleEventlogFloatlogFloat :: Float -> FloatFloatFloat logDouble logDouble :: Double -> DoubleJ7DoubleDoublelogBaselogBase :: Floating a => a -> a -> aFloatingaaaaloglog :: Floating a => a -> a Floatingaaa listArray listArray :: Ix i => (i, i) -> [e] ->  Array i eIxi(,)ii[]eArrayielistlist ::  ReadPrec a ->  ReadPrec [a]0 ReadPrecaReadPrec[]ag(list p) parses a list of things parsed by p, using the usual square-bracket syntax.  LineBuffering LineBuffering ::  BufferMode BufferMode.line-buffering should be enabled if possible. liftSTliftST :: ST s a -> State# s ->  STret s a{STsaState#sSTretsaliftIOliftIO :: IO a -> State# RealWorld -> STret RealWorld aLIOaState# RealWorldSTret RealWorldalexPlexP :: ReadPrec LexemeReadPrecLexemeParse a single lexeme  lexLitChar lexLitChar ::  ReadS String ReadSStringRead a string representation of a character, using Haskell source-language escape conventions. For example: 
lexLitChar  "\\nHello"  =  [("\\n", "Hello")]
 lexDigits lexDigits ::  ReadS StringReadSString,Reads a non-empty string of decimal digits. lexlex ::  ReadS String|jReadSStringThe lex 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, lex returns a single successful `lexeme' consisting of the empty string. (Thus lex "" = [("","")].) If there is no legal lexeme at the beginning of the input string, lex fails (i.e. returns []). This lexer is not completely faithful to the Haskell lexical syntax in the following respects:
  • Qualified names are not handled properly
  • Octal and hexadecimal numerics are not recognized as a single token
  • Comments are not treated properly
lengthPlengthP :: [:a:] -> Int[::]aInt lengthlength :: [a] -> Int[]aIntlength returns the length of a finite list as an Int. It is an instance of the more general Data.List.genericLength, the result type of which may be any kind of number.  lcmInteger lcmInteger :: Integer -> Integer -> Integer+ IntegerIntegerIntegerlcmlcm :: Integral a => a -> a -> aIntegralaaaaelcm x y is the smallest positive integer that both x and y divide. lazylazy :: a -> aC:aaThe call '(lazy e)' means the same as e, but lazy has a magical strictness property: it is lazy in its first argument, even though its semantics is strict. lazylazy :: a -> a*!aaThe call '(lazy e)' means the same as e, but lazy has a magical strictness property: it is lazy in its first argument, even though its semantics is strict.  lastlast :: [a] -> a  []aaHExtract the last element of a list, which must be finite and non-empty.  labelThread labelThread :: ThreadId -> String -> IO ()  ThreadIdStringIO()labelThread 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). Other applications like the graphical Concurrent Haskell Debugger (http://www.informatik.uni-kiel.de/~fhu/chd/) may choose to overload labelThread for their purposes as well.  killThread killThread :: ThreadId -> IO ()'  ThreadIdIO()killThread terminates the given thread (GHC only). Any work already done by the thread isn't lost: the computation is suspended until required by another thread. The memory used by the thread will be garbage collected if it isn't referenced from anywhere. The killThread function is defined in terms of throwTo: 
killThread tid = throwTo tid (AsyncException ThreadKilled)
 jtosjtos :: Integer -> String -> String1IntegerStringString J#J# :: Int# ->  ByteArray# -> IntegerInt# ByteArray#IntegerJ#J# :: Int# ->  ByteArray# -> IntegerInt# ByteArray#Integerixmap ixmap :: (Ix i, Ix j) => (i, i) -> (i -> j) ->  Array j e ->  Array i eIxiIxj(,)iiijArrayjeArrayieIxclass  Ord a => Ix aWThe Ix 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) of each of these operations is a pair specifying the lower and upper bounds of a contiguous subrange of values. An implementation is entitled to assume the following laws about these operations: Minimal complete instance: range, index and inRange.  iterateiterate :: (a -> a) -> a -> [a]aaa[]aiterate f x returns an infinite list of repeated applications of f to x: 
iterate f x == [x, f x, f (f x), ...]
isUpperisUpper :: Char -> BoolCharBoolSelects 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. IsStringclass IsString amClass for string-like datastructures; used by the overloaded string extension (-foverloaded-strings in GHC). isSpaceisSpace :: Char -> Bool|mCharBool{Selects white-space characters in the Latin-1 range. (In Unicode terms, this includes spaces and some control characters.) isPrintisPrint :: Char -> BoolM>CharBoolaSelects printable Unicode characters (letters, numbers, marks, punctuation, symbols and spaces).  isOctDigit isOctDigit :: Char -> Bool CharBool=Selects ASCII octal digits, i.e. '0'..'7'. isNegativeZeroisNegativeZero :: RealFloat a => a -> Bool RealFloataaBoolisNaNisNaN :: RealFloat a => a -> Bool/ RealFloataaBoolisLowerisLower :: Char -> BoolvCharBool<Selects lower-case alphabetic Unicode characters (letters). isLatin1isLatin1 :: Char -> Bool CharBoolxSelects the first 256 characters of the Unicode character set, corresponding to the ISO 8859-1 (Latin-1) character set.  isInfinite isInfinite :: RealFloat a => a -> Bool RealFloataaBoolisIEEEisIEEE :: RealFloat a => a -> BoolsW RealFloataaBool iShiftRL# iShiftRL# :: Int# -> Int# -> Int#Int#Int#Int#bShift the argument right (unsigned) by the specified number of bits (which must be non-negative).  iShiftRL# iShiftRL# :: Int# -> Int# -> Int#Int#Int#Int#bShift the argument right (unsigned) by the specified number of bits (which must be non-negative).  iShiftRA# iShiftRA# :: Int# -> Int# -> Int#rInt#Int#Int#`Shift the argument right (signed) by the specified number of bits (which must be non-negative).  iShiftRA# iShiftRA# :: Int# -> Int# -> Int#WBInt#Int#Int#`Shift the argument right (signed) by the specified number of bits (which must be non-negative). iShiftL#iShiftL# :: Int# -> Int# -> Int#%Int#Int#Int#VShift the argument left by the specified number of bits (which must be non-negative). iShiftL#iShiftL# :: Int# -> Int# -> Int#Int#Int#Int#VShift the argument left by the specified number of bits (which must be non-negative).  isHexDigit isHexDigit :: Char -> Bool  CharBool{Selects ASCII hexadecimal digits, i.e. '0'..'9', 'a'..'f', 'A'..'F'. isFloatNegativeZeroisFloatNegativeZero :: Float -> Int!u!FloatInt isFloatNaN isFloatNaN :: Float -> Int!!FloatIntisFloatInfiniteisFloatInfinite :: Float -> IntF"7"FloatIntisFloatDenormalizedisFloatDenormalized :: Float -> Int""FloatIntisEOFisEOF :: IO Bool""IOBoolgThe computation isEOF is identical to hIsEOF, except that it works only on stdin.  isEmptyMVar isEmptyMVar :: MVar a -> IO Bool##MVaraIOBool9Check whether a given MVar 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 tryTakeMVar instead if possible. isDoubleNegativeZeroisDoubleNegativeZero :: Double -> Intw%g%DoubleInt isDoubleNaN isDoubleNaN :: Double -> Int%%DoubleIntisDoubleInfiniteisDoubleInfinite :: Double -> IntA&1&DoubleIntisDoubleDenormalizedisDoubleDenormalized :: Double -> Int&&DoubleIntisDigitisDigit :: Char -> Bool '&CharBool7Selects ASCII digits, i.e. '0'..'9'. isDenormalizedisDenormalized :: RealFloat a => a -> Bool'' RealFloataaBool isControl isControl :: Char -> Bool((CharBooldSelects control characters, which are the non-printing characters of the Latin-1 subset of Unicode.  isAsciiUpper isAsciiUpper :: Char -> Bool((CharBooleSelects ASCII upper-case letters, i.e. characters satisfying both isAscii and isUpper.  isAsciiLower isAsciiLower :: Char -> Bool))CharBooleSelects ASCII lower-case letters, i.e. characters satisfying both isAscii and isLower. isAsciiisAscii :: Char -> Bool[*L*CharBooliSelects the first 128 characters of the Unicode character set, corresponding to the ASCII character set.  isAlphaNum isAlphaNum :: Char -> Bool ++CharBool Selects alphabetic or numeric digit Unicode characters. Note that numeric digits outside the ASCII range are selected by this function but not by isDigit. Such digits may be part of identifiers but are not used by the printer and reader to represent numbers. isAlphaisAlpha :: Char -> Bool,r,CharBoolSelects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters). This function is equivalent to Data.Char.isLetter. IPrtype IPr = (Int, Int)|-ioToSTioToST :: IO a -> ST RealWorld a--IOaST RealWorldaIORefIORef :: STRef RealWorld a -> IORef ad.>.STRef RealWorldaIORefaIORefnewtype IORef a.*A mutable variable in the IO monad IOModedata IOMode.IOModedata IOMode!/ ioException ioException ::  IOException -> IO a/w/ IOExceptionIOa IOExceptiondata  IOException/Exceptions that occur in the IO monad. An IOException records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.  IOException IOException ::  IOException ->  Exception10 IOException ExceptionuThese are the standard IO exceptions generated by Haskell's IO operations. See also System.IO.Error.  IOExceptiondata  IOException1Exceptions that occur in the IO monad. An IOException records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.  IOException IOException ::  IOException ->  Exception22 IOException ExceptionuThese are the standard IO exceptions generated by Haskell's IO operations. See also System.IO.Error.  IOErrorTypedata  IOErrorType3KAn abstract type that contains a value for each variant of IOError. ioErrorioError :: IOError -> IO a>4)4IOErrorIOa0Raise an IOError in the IO monad. ioErrorioError :: IOError -> IO a44IOErrorIOa0Raise an IOError in the IO monad. IOErrorIOError ::  Maybe Handle ->  IOErrorType -> String -> String -> Maybe FilePath ->  IOException55MaybeHandle IOErrorTypeStringStringMaybeFilePath IOExceptionIOErrortype IOError = IOException;6%The Haskell 98 type for exceptions in the IO monad. Any I/O operation may raise an IOError instead of returning a result. For a more general type of exception, including also those that arise in pure code, see Control.Exception.Exception. In Haskell 98, this is an opaque type. IOErrorIOError ::  Maybe Handle ->  IOErrorType -> String -> String -> Maybe FilePath ->  IOException\8 8MaybeHandle IOErrorTypeStringStringMaybeFilePath IOExceptionioe_typeioe_type ::  IOException ->  IOErrorType88 IOException IOErrorTypeioe_typeioe_type ::  IOException ->  IOErrorTypeD9'9 IOException IOErrorType ioe_location ioe_location ::  IOException -> String99 IOExceptionString ioe_location ioe_location ::  IOException -> String(:: IOExceptionString ioe_handle ioe_handle ::  IOException ->  Maybe Handle:: IOExceptionMaybeHandle ioe_handle ioe_handle ::  IOException ->  Maybe Handle";; IOExceptionMaybeHandle ioe_filename ioe_filename ::  IOException -> Maybe FilePath;; IOExceptionMaybeFilePath ioe_filename ioe_filename ::  IOException -> Maybe FilePath,< < IOExceptionMaybeFilePathioe_EOFioe_EOF :: IO am<c<IOaioe_descriptionioe_description ::  IOException -> String<< IOExceptionStringioe_descriptionioe_description ::  IOException -> String]=E= IOExceptionStringIOArrayIOArray :: STArray RealWorld i e ->  IOArray i e==STArray RealWorldieIOArrayieIOArraynewtype IOArray i e%> An IOArray is a mutable, boxed, non-strict array in the IO monad. The type arguments are as follows:
  • i: the index type of the array (should be an instance of Ix)
  • e: the element type of the array.
IOIO :: State# RealWorld -> (# State# RealWorld, a #) -> IO a??State# RealWorld(#,#)State# RealWorldaIOaIOnewtype IO a @A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a. There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main. IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class. InvalidArgumentInvalidArgument ::  IOErrorTypeBB IOErrorType intToDigit intToDigit :: Int -> CharRCDCIntCharConvert an Int in the range 0..15 to the corresponding single digit Char. This function fails on other inputs, and generates lower-case hexadecimal digits.  Interrupted Interrupted ::  IOErrorTypebDTD IOErrorTypeintegralEnumFromTointegralEnumFromTo :: Integral a => a -> a -> [a]DDIntegralaaa[]aintegralEnumFromThenTo integralEnumFromThenTo :: Integral a => a -> a -> a -> [a]EEIntegralaaaa[]aintegralEnumFromThenintegralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a]XF)FIntegralaBoundedaaa[]aintegralEnumFromintegralEnumFrom :: (Integral a, Bounded a) => a -> [a]FFIntegralaBoundedaa[]aIntegralclass (Real a, Enum a) => Integral a?GqIntegral numbers, supporting integer division. Minimal complete definition: quotRem and toInteger integerLogBaseintegerLogBase :: Integer -> Integer -> Int4HHIntegerIntegerInt integer2Int integer2Int :: Integer -> IntHHIntegerInt Integerdata IntegerHArbitrary-precision integers. Integerdata IntegerIArbitrary-precision integers. int_encodeFloat#int_encodeFloat# :: Int# -> Int -> FloatIIInt#IntFloatint_encodeDouble#int_encodeDouble# :: Int# -> Int -> Double6J JInt#IntDoubleInt8data Int8bJ8-bit signed integer type Int64data Int64J64-bit signed integer type Int32data Int32J32-bit signed integer type  int2Integer int2Integer :: Int -> IntegerpK_KIntInteger int2Float int2Float :: Int -> FloatKKIntFloat int2Double int2Double :: Int -> Double(LLIntDoubleInt16data Int16VL16-bit signed integer type Intdata IntLA fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using Prelude.minBound and Prelude.maxBound from the Prelude.Bounded class. Intdata IntMA fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using Prelude.minBound and Prelude.maxBound from the Prelude.Bounded class. installHandlerinstallHandler :: Handler ->  IO HandlerNNHandlerIOHandlerdAllows Windows console events to be caught and handled. To handle a console event, call installHandler passing the appropriate Handler value. When the event is received, if the Handler value is Catch f, then a new thread will be spawned by the system to execute f e, where e is the ConsoleEvent that was received. Note that console events can only be received by an application running in a Windows console. Certain environments that look like consoles do not support console events, these include:
  • Cygwin shells with CYGWIN=tty set (if you don't set CYGWIN=tty, then a Cygwin shell behaves like a Windows console). * Cygwin xterm and rxvt windows * MSYS rxvt windows
In order for your application to receive console events, avoid running it in one of these environments. inRangeinRange :: Ix a => (a, a) -> a -> BoolRRIxa(,)aaaBoolInrInr :: b -> :+: a b2SSb:+:abinlineinline :: a -> azSqSaaThe call '(inline f)' reduces to f, but inline has a BuiltInRule that tries to inline f (if it has an unfolding) unconditionally The NOINLINE pragma arranges that inline only gets inlined (and hence eliminated) late in compilation, after the rule has had a god chance to fire. inlineinline :: a -> aTTaaThe call '(inline f)' reduces to f, but inline has a BuiltInRule that tries to inline f (if it has an unfolding) unconditionally The NOINLINE pragma arranges that inline only gets inlined (and hence eliminated) late in compilation, after the rule has had a god chance to fire. InlInl :: a -> :+: a bLV9Va:+:ab initinit :: [a] -> [a]VV[]a[]a^Return all the elements of a list except the last one. The list must be finite and non-empty. indicesindices :: Ix i =>  Array i e -> [i]uWQWIxiArrayie[]iIndexOutOfBoundsIndexOutOfBounds :: String -> ArrayExceptionWWStringArrayExceptionCAn attempt was made to index an array outside its declared bounds. IndexOutOfBoundsIndexOutOfBounds :: String -> ArrayExceptionXXStringArrayExceptionCAn attempt was made to index an array outside its declared bounds. indexOfPindexOfP ::  (a -> Bool) -> [:a:] -> [:Int:]Y_YaBool[::]a[::]Int indexError  indexError ::  Show a => (a, a) -> a -> String -> b#ZYShowa(,)aaaStringbindexindex :: Ix a => (a, a) -> a -> IntZ|ZIxa(,)aaaIntInappropriateTypeInappropriateType ::  IOErrorTypeZZ IOErrorTypeIllegalOperationIllegalOperation ::  IOErrorType[[M[ IOErrorTypeIgnoreIgnore :: Handler[[Handleridid :: a -> a[[aaIdentity function. I8#I8# :: Int# -> Int8>\/\Int#Int8I64#I64# :: Int64# -> Int64\\Int64#Int64I32#I32# :: Int# -> Int32\\Int#Int32I16#I16# :: Int# -> Int168](]Int#Int16I#I# :: Int# -> Int]t]Int#IntI#I# :: Int# -> Int]]Int#Int hWaitForInput hWaitForInput :: Handle -> Int -> IO BoolO^3^HandleIntIOBoolComputation hWaitForInput hdl t waits until input is available on handle hdl. It returns True as soon as input is available on hdl, or False if no input is available within t milliseconds. If t is less than zero, then hWaitForInput waits indefinitely. This operation may fail with: NOTE for GHC users: unless you use the -threaded flag, hWaitForInput t where t >= 0 will block all other Haskell threads for the duration of the call. It behaves like a safe foreign call in this respect. hTellhTell :: Handle ->  IO Integer[aAaHandleIOIntegerhShowhShow :: Handle ->  IO StringaaHandleIOStringhShow is in the IO monad, and gives more comprehensive output than the (pure) instance of Show for Handle. hSetPosnhSetPosn ::  HandlePosn -> IO ()bb HandlePosnIO()VIf a call to hGetPosn hdl returns a position p, then computation hSetPosn p sets the position of hdl to the position it held at the time of the call to hGetPosn. This operation may fail with:  hSetFileSize hSetFileSize :: Handle -> Integer -> IO ()dkdHandleIntegerIO()|hSetFileSize hdl size truncates the physical file with handle hdl to size bytes. hSetEchohSetEcho :: Handle -> Bool -> IO ()|eaeHandleBoolIO()<Set the echoing status of a handle connected to a terminal.  hSetBuffering hSetBuffering :: Handle ->  BufferMode -> IO ()Ef$fHandle BufferModeIO()uComputation hSetBuffering hdl mode sets the mode of buffering for handle hdl on subsequent reads and writes. If the buffer mode is changed from BlockBuffering or LineBuffering to NoBuffering, then
  • if hdl is writable, the buffer is flushed as for hFlush;
  • 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.
hSetBinaryModehSetBinaryMode :: Handle -> Bool -> IO ()=i"iHandleBoolIO()qSelect binary mode (True) or text mode (False) on a open handle. (See also openBinaryFile.) hSeek hSeek :: Handle -> SeekMode -> Integer -> IO ()CjjHandleSeekModeIntegerIO()Computation hSeek 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 hIsSeekable), 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: hPutStrhPutStr :: Handle -> String -> IO ()Fn)nHandleStringIO().Computation hPutStr hdl s writes the string s to the file or channel managed by hdl. This operation may fail with: hPutCharhPutChar :: Handle -> Char -> IO ()ooHandleCharIO()yComputation hPutChar 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: hPutBufNonBlocking hPutBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int rqHandlePtraIntIOInthPutBuf hPutBuf :: Handle -> Ptr a -> Int -> IO ()rtrHandlePtraIntIO()hPutBuf hdl buf count writes count 8-bit bytes from the buffer buf to the handle hdl. It returns (). This operation may fail with:
  • ResourceVanished 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).
 hLookAhead hLookAhead :: Handle -> IO CharttHandleIOCharComputation hLookAhead 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:  hIsWritable hIsWritable :: Handle -> IO Bool;v$vHandleIOBoolhIsTerminalDevicehIsTerminalDevice :: Handle -> IO BoolvvHandleIOBool'Is the handle connected to a terminal?  hIsSeekable hIsSeekable :: Handle -> IO BoolDw-wHandleIOBool hIsReadable hIsReadable :: Handle -> IO BoolwwHandleIOBoolhIsOpenhIsOpen :: Handle -> IO BoolxwHandleIOBoolhIsEOFhIsEOF :: Handle -> IO Boolsx\xHandleIOBoolyFor a readable handle hdl, hIsEOF hdl returns True if no further input can be taken from hdl or for a physical file, if the current I/O position is equal to the length of the file. Otherwise, it returns False. NOTE: hIsEOF may block, because it is the same as calling hLookAhead and checking for an EOF exception.  hIsClosed hIsClosed :: Handle -> IO BoolSz  IO HandlePosnzzHandleIO HandlePosnComputation hGetPosn hdl returns the current I/O position of hdl as a value of the abstract type HandlePosn. hGetLinehGetLine :: Handle ->  IO String{{HandleIOStringComputation hGetLine hdl reads a line from the file or channel managed by hdl. This operation may fail with:
  • isEOFError if the end of file is encountered when reading the first character of the line.
If hGetLine 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. hGetEchohGetEcho :: Handle -> IO Bool}}HandleIOBool<Get the echoing status of a handle connected to a terminal.  hGetContents hGetContents :: Handle ->  IO Stringo~V~HandleIOStringComputation hGetContents hdl 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, hdl is effectively closed, but items are read from hdl on demand and accumulated in a special list returned by hGetContents hdl. Any 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;
  • or 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. Any I/O errors encountered while a handle is semi-closed are simply discarded. This operation may fail with: hGetCharhGetChar :: Handle -> IO CharwHandleIOCharComputation hGetChar hdl reads a character from the file or channel managed by hdl, blocking until a character is available. This operation may fail with: hGetBufNonBlocking hGetBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int5HandlePtraIntIOInthGetBufNonBlocking 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, or there is no more data available to read immediately. hGetBufNonBlocking is identical to hGetBuf, 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 hGetBufNonBlocking, use hWaitForInput. If the handle is a pipe or socket, and the writing end is closed, hGetBufNonBlocking will behave as if EOF was reached.  hGetBuffering hGetBuffering :: Handle ->  IO BufferMode= HandleIO BufferModecComputation hGetBuffering hdl returns the current buffering mode for hdl. hGetBuf hGetBuf :: Handle -> Ptr a -> Int -> IO Int0 HandlePtraIntIOInthGetBuf 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). hGetBuf never raises an EOF exception, instead it returns a value smaller than count. If the handle is a pipe or socket, and the writing end is closed, hGetBuf will behave as if EOF was reached. hFlushhFlush :: Handle -> IO ()HandleIO()The action hFlush hdl causes any items buffered for output in handle hdl 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.
 hFileSize hFileSize :: Handle ->  IO IntegerHandleIOIntegerFor a handle hdl which attached to a physical file, hFileSize hdl returns the size of that file in 8-bit bytes.  heapOverflow heapOverflow ::  Exception Exception HeapOverflow HeapOverflow :: AsyncExceptionAsyncExceptionThe 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 does not throw HeapOverflow exceptions.
 HeapOverflow HeapOverflow :: AsyncExceptiondSAsyncExceptionThe 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 does not throw HeapOverflow exceptions.
 headhead :: [a] -> a[]aa>Extract the first element of a list, which must be non-empty.  hDuplicateTo hDuplicateTo :: Handle -> Handle -> IO ()cHandleHandleIO()Makes 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
 hDuplicate hDuplicate :: Handle ->  IO HandleܓHandleIOHandleReturns 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.  hClose_help hClose_help :: Handle__ -> IO (Handle__, Maybe Exception)~FHandle__IO(,)Handle__Maybe ExceptionhClosehClose :: Handle -> IO ()ەƕHandleIO()Computation hClose hdl makes handle hdl closed. Before the computation finishes, if hdl is writable its buffer is flushed as for hFlush. Performing hClose 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 hClose fails for any reason, any further operations (apart from hClose) on the handle will still fail as if hdl had been successfully closed. haTypehaType :: Handle__ ->  HandleType;"Handle__ HandleType HardwareFault HardwareFault ::  IOErrorType IOErrorType haOtherSide haOtherSide :: Handle__ -> Maybe (MVar Handle__)Handle__MaybeMVarHandle__ HandleTypedata  HandleTypeWHandlerdata Handler HandlePosn HandlePosn :: Handle -> HandlePosition ->  HandlePosnHandleHandlePosition HandlePosn HandlePosndata  HandlePosnWHandlePositiontype HandlePosition = IntegerHandle__Handle__ :: FD ->  HandleType -> Bool -> Bool ->  BufferMode ->  IORef Buffer -> IORef BufferList -> Maybe (MVar Handle__) -> Handle__ FD HandleTypeBoolBool BufferModeIORefBufferIORef BufferListMaybeMVarHandle__Handle__Handle__data Handle__9Handledata HandleiuHaskell defines operations to read and write characters from and to files, represented by values of type Handle. Each value of this type is a handle: a record used by the Haskell run-time system to manage 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;
  • whether 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 readable if it manages only input or both input and output; likewise, it is writable 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 Show and Eq 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 == only to itself; no attempt is made to compare the internal state of different handles for equality. GHC note: a Handle will be automatically closed when the garbage collector detects that it has become unreferenced by the program. However, relying on this behaviour is not generally recommended: the garbage collector is unpredictable. If possible, use explicit an explicit hClose to close Handles when they are no longer required. GHC does not currently attempt to free up file descriptors when they have run out, it is your responsibility to ensure that this doesn't happen.  haIsStream haIsStream :: Handle__ -> BoolB/Handle__BoolhaIsBinhaIsBin :: Handle__ -> BoolHandle__BoolhaFDhaFD :: Handle__ -> FDHandle__FD haBuffers haBuffers :: Handle__ -> IORef BufferListqOHandle__IORef BufferList haBufferMode haBufferMode :: Handle__ ->  BufferMode̥Handle__ BufferModehaBufferhaBuffer :: Handle__ ->  IORef BufferX:Handle__IORefBufferGTGT :: OrderingOrderinggetTaggetTag :: a -> Int#֦aInt# getFullArgs getFullArgs ::  IO [String]=(IO[]StringgeIntgeInt :: Int -> Int -> BoolIntIntBoolgeFloatgeFloat :: Float -> Float -> BoolFloatFloatBoolgeDoublegeDouble :: Double -> Double -> BoolnDoubleDoubleBool gcdInteger gcdInteger :: Integer -> Integer -> Integer IntegerIntegerIntegergcdgcd :: Integral a => a -> a -> az_Integralaaaagcd x y is the greatest (positive) integer that divides both x and y; for example gcd (-3) 6 = 3, gcd (-3) (-6) = 3, gcd 0 4 = 4. gcd 0 0 raises a runtime error. FunPtrFunPtr :: Addr# -> FunPtr aAddr#FunPtraFunPtrdata FunPtr a,A value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type, a function type with zero or more arguments where
  • the argument types are marshallable foreign types, i.e. Char, Int, Prelude.Double, Prelude.Float, Bool, Data.Int.Int8, Data.Int.Int16, Data.Int.Int32, Data.Int.Int64, Data.Word.Word8, Data.Word.Word16, Data.Word.Word32, Data.Word.Word64, Ptr a, FunPtr a, Foreign.StablePtr.StablePtr a or a renaming of any of these using newtype.
  • the return type is either a marshallable foreign type or has the form Prelude.IO t where t is a marshallable foreign type or ().
A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like 
foreign import ccall "stdlib.h &free"
  p_free :: FunPtr (Ptr a -> IO ())
or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example: 
type Compare = Int -> Int -> Bool
foreign import ccall "wrapper"
  mkCompare :: Compare -> IO (FunPtr Compare)
Calls to wrapper stubs like mkCompare allocate storage, which should be released with Foreign.Ptr.freeHaskellFunPtr when no longer required. To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g. 
type IntFunction = CInt -> IO ()
foreign import ccall "dynamic" 
  mkFun :: FunPtr IntFunction -> IntFunction
FunPtrFunPtr :: Addr# -> FunPtr au^Addr#FunPtraFunPtrdata FunPtr aA value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type, a function type with zero or more arguments where
  • the argument types are marshallable foreign types, i.e. Char, Int, Prelude.Double, Prelude.Float, Bool, Data.Int.Int8, Data.Int.Int16, Data.Int.Int32, Data.Int.Int64, Data.Word.Word8, Data.Word.Word16, Data.Word.Word32, Data.Word.Word64, Ptr a, FunPtr a, Foreign.StablePtr.StablePtr a or a renaming of any of these using newtype.
  • the return type is either a marshallable foreign type or has the form Prelude.IO t where t is a marshallable foreign type or ().
A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like 
foreign import ccall "stdlib.h &free"
  p_free :: FunPtr (Ptr a -> IO ())
or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example: 
type Compare = Int -> Int -> Bool
foreign import ccall "wrapper"
  mkCompare :: Compare -> IO (FunPtr Compare)
Calls to wrapper stubs like mkCompare allocate storage, which should be released with Foreign.Ptr.freeHaskellFunPtr when no longer required. To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g. 
type IntFunction = CInt -> IO ()
foreign import ccall "dynamic" 
  mkFun :: FunPtr IntFunction -> IntFunction
Functorclass Functor fĹCThe Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws: 
fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g
The instances of Functor for lists, Data.Maybe.Maybe and System.IO.IO defined in the Prelude satisfy these laws.  fromString fromString :: IsString a => String -> a~aIsStringaStringa fromRational fromRational :: Fractional a => Rational -> a FractionalaRationalafromRat'fromRat' :: RealFloat a => Rational -> azZ RealFloataRationalafromRatfromRat :: RealFloat a => Rational -> aѼ RealFloataRationalafromPfromP :: [:a:] -> [a]K4[::]a[]a fromIntegral fromIntegral :: (Integral a, Num b) => a -> bϽIntegralaNumbab%general coercion from integral types  fromInteger fromInteger ::  Num a => Integer -> aeLNumaIntegera fromEnumError fromEnumError ::  Show a => String -> a -> bξShowaStringab fromEnumfromEnum ::  Enum a => a -> IntO9EnumaaInt freezeSTArray freezeSTArray :: Ix i =>  STArray s i e -> ST s (Array i e)IxiSTArraysieSTsArrayie freeStablePtr freeStablePtr ::  StablePtr a -> IO ()oR StablePtraIO()Dissolve the association between the stable pointer and the Haskell value. Afterwards, if the stable pointer is passed to deRefStablePtr or freeStablePtr, the behaviour is undefined. However, the stable pointer may still be passed to castStablePtrToPtr, but the Foreign.Ptr.Ptr () value returned by castStablePtrToPtr, in this case, is undefined (in particular, it may be Foreign.Ptr.nullPtr). Nevertheless, the call to castStablePtrToPtr is guaranteed not to diverge.  Fractionalclass  Num a =>  Fractional aFractional numbers, supporting real division. Minimal complete definition: fromRational and (recip or (/)) formatRealFloat formatRealFloat :: RealFloat a => FFFormat ->  Maybe Int -> a -> String RealFloataFFFormatMaybeIntaStringforkOnIOforkOnIO :: Int -> IO () ->  IO ThreadIdbIntIO()IOThreadId{Like forkIO, but lets you specify on which CPU the thread is created. Unlike a forkIO thread, a thread created by forkOnIO will stay on the same CPU for its entire lifetime (forkIO threads can migrate between CPUs according to the scheduling policy). forkOnIO is useful for overriding the scheduling policy when you know in advance how best to distribute the threads. The Int argument specifies the CPU number; it is interpreted modulo numCapabilities (note that it actually specifies a capability number rather than a CPU number, but to a first approximation the two are equivalent). forkIOforkIO :: IO () ->  IO ThreadIdiLIO()IOThreadIdSparks off a new thread to run the IO computation passed as the first argument, and returns the ThreadId of the newly created thread. The new thread will be a lightweight thread; if you want to use a foreign library that uses thread-local storage, use Control.Concurrent.forkOS instead. GHC note: the new thread inherits the blocked state of the parent (see Control.Exception.block).  ForeignPtr ForeignPtr :: Addr# -> ForeignPtrContents ->  ForeignPtr atAddr#ForeignPtrContents ForeignPtra ForeignPtrdata  ForeignPtr a`The type ForeignPtr 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 ForeignPtrs 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 ForeignPtr. Typically, the finalizer will, then, invoke routines in the foreign language that free the resources bound by the foreign object. The ForeignPtr is parameterised in the same way as Ptr. The type argument of ForeignPtr should normally be an instance of class Storable. foldrP foldrP ::  (a -> b -> b) -> b -> [:a:] -> babbb[::]abfoldr1Pfoldr1P ::  (a -> a -> a) -> [:a:] -> a?#aaa[::]aa foldr1foldr1 ::  (a -> a -> a) -> [a] -> aaaa[]aa}foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty lists.  foldr foldr ::  (a -> b -> b) -> b -> [a] -> babbb[]abfoldr, 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)...)
foldr foldr ::  (a -> b -> b) -> b -> [a] -> b<abbb[]abfoldr, 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)...)
foldP foldP ::  (e -> e -> e) -> e -> [:e:] -> eeeee[::]eefoldlP foldlP ::  (a -> b -> a) -> a -> [:b:] -> aR3abaa[::]bafoldl1Pfoldl1P ::  (a -> a -> a) -> [:a:] -> aaaa[::]aa foldl foldl ::  (a -> b -> a) -> a -> [b] -> aN1abaa[]ba&foldl, 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: 
foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
The list must be finite. fold1Pfold1P ::  (e -> e -> e) -> [:e:] -> eeee[::]eefmapfmap ::  Functor f => (a -> b) -> f a -> f buLFunctorfabfafbflushWriteBufferOnlyflushWriteBufferOnly :: Handle__ -> IO ()Handle__IO()flushWriteBuffer flushWriteBuffer :: FD -> Bool -> Buffer ->  IO BufferpFDBoolBufferIOBufferflushReadBufferflushReadBuffer :: FD -> Buffer ->  IO BufferFDBufferIOBuffer flushConsole flushConsole :: Handle -> IO ()pHandleIO()floorfloor :: (RealFrac a, Integral b) => a -> bRealFracaIntegralbab floatToDigits floatToDigits :: RealFloat a => Integer -> a ->  ([Int], Int) RealFloataIntegera(,)[]IntIntifloatToDigits takes a base and a non-negative RealFloat number, and returns a list of digits and an exponent. In particular, if x>=0, and 
floatToDigits base x = ([d1,d2,...,dn], e)
then 
  1. n >= 1
  2. x = 0.d1d2...dn * (base**e)
  3. 0 <= di <= base-1
 floatRange floatRange :: RealFloat a => a ->  (Int, Int)} RealFloataa(,)IntInt floatRadix floatRadix :: RealFloat a => a -> Integer RealFloataaIntegerFloatingclass Fractional a => Floating afTrigonometric and hyperbolic functions and related functions. Minimal complete definition: pi, exp, log, sin, cos, sinh, cosh, asin, acos, atan, asinh, acosh and atanh  floatDigits floatDigits :: RealFloat a => a -> Int RealFloataaInt float2Int float2Int :: Float -> Int9*FloatInt float2Double float2Double :: Float -> DoubleFloatDoubleFloatdata FloatSingle-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type. Floatdata FloatSingle-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type. flip flip ::  (a -> b -> c) -> b -> a -> cabcbac[flip f takes its (first) two arguments in the reverse order of f. fixSTfixST ::  (a -> ST s a) -> ST s adDaSTsaSTsaAllow the result of a state transformer computation to be used (lazily) inside the computation. Note that if f is strict, fixST f = _|_.  FinalizerPtrtype  FinalizerPtr a = FunPtr (Ptr a -> IO ())`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. finalizeForeignPtrfinalizeForeignPtr ::  ForeignPtr a -> IO () ForeignPtraIO()OCauses the finalizers associated with a foreign pointer to be run immediately. finalizefinalize :: Weak v -> IO ()[CWeakvIO()MCauses a the finalizer associated with a weak pointer to be run immediately. filterPfilterP ::  (a -> Bool) -> [:a:] -> [:a:],aBool[::]a[::]a filterfilter ::  (a -> Bool) -> [a] -> [a]aBool[]a[]afilter, 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]
fillReadBufferWithoutBlocking fillReadBufferWithoutBlocking :: FD -> Bool -> Buffer ->  IO Buffer FDBoolBufferIOBufferfillReadBuffer fillReadBuffer :: FD -> Bool -> Bool -> Buffer ->  IO BufferFDBoolBoolBufferIOBufferfill fill :: MutableArray# s e -> (Int, e) ->  STRep s a ->  STRep s a: MutableArray#se(,)InteSTRepsaSTRepsaFilePathtype FilePath = StringFile and directory names are values of type String, 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.  FileHandle FileHandle :: FilePath ->  MVar Handle__ -> Handle*FilePathMVarHandle__Handle FFGeneric FFGeneric :: FFFormattiFFFormatFFFormatdata FFFormatFFFixedFFFixed :: FFFormatFFFormat FFExponent FFExponent :: FFFormat:/FFFormatfdToHandle_statfdToHandle_stat :: FD -> Maybe (FDType, CDev, CIno) -> Bool -> FilePath -> IOMode -> Bool ->  IO HandleXFDMaybe(,,)FDTypeCDevCInoBoolFilePathIOModeBoolIOHandle fdToHandle' fdToHandle' :: FD ->  Maybe FDType -> Bool -> FilePath -> IOMode -> Bool ->  IO HandleLFDMaybeFDTypeBoolFilePathIOModeBoolIOHandle'Old API kept to avoid breaking clients  fdToHandle fdToHandle :: FD ->  IO HandleFDIOHandleFDtype FD = CInt FalseFalse :: BoolC<BoolfailIOfailIO :: String -> IO aStringIOafailfail ::  Monad m => String -> m a MonadmStringmaF#F# :: Float# -> Float\JFloat#FloatF#F# :: Float# -> FloatFloat#Floatexptsexpts :: Array Int IntegerArrayIntIntegerexptexpt :: Integer -> Int -> Integerv\IntegerIntIntegerexponentexponent :: RealFloat a => a -> Int RealFloataaIntexpexp :: Floating a => a -> aD,Floatingaaa ExitSuccess ExitSuccess :: ExitCodeExitCode"indicates successful termination;  ExitFailure ExitFailure :: Int -> ExitCodeIntExitCodeindicates 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).  ExitException ExitException :: ExitCode ->  ExceptionP8ExitCode Exception/The ExitException exception is thrown by System.Exit.exitWith (and System.Exit.exitFailure). The ExitCode argument is the value passed to System.Exit.exitWith. An unhandled ExitException exception in the main thread will cause the program to be terminated with the given exit code.  ExitException ExitException :: ExitCode ->  ExceptionExitCode Exception/The ExitException exception is thrown by System.Exit.exitWith (and System.Exit.exitFailure). The ExitCode argument is the value passed to System.Exit.exitWith. An unhandled ExitException exception in the main thread will cause the program to be terminated with the given exit code. ExitCodedata ExitCodeV Exceptiondata  Exception)The type of exceptions. Every kind of system-generated exception has a constructor in the Exception type, and values of other types may be injected into Exception by coercing them to Dynamic (see the section on Dynamic Exceptions: Control.Exception#DynamicExceptions).  Exceptiondata  Exception)The type of exceptions. Every kind of system-generated exception has a constructor in the Exception type, and values of other types may be injected into Exception by coercing them to Dynamic (see the section on Dynamic Exceptions: Control.Exception#DynamicExceptions). evaluateevaluate :: a -> IO aiZaIOa)Forces its argument to be evaluated when the resultant IO action is executed. It can be used to order evaluation with respect to other IO operations; its semantics are given by 
evaluate x `seq` y    ==>  y
evaluate x `catch` f  ==>  (return $! x) `catch` f
evaluate x >>= f      ==>  (return $! x) >>= f
Note: the first equation implies that (evaluate x) is not the same as (return $! x). A correct definition is 
evaluate x = (return $! x) >>= return
 errorEmptyListerrorEmptyList :: String -> aStringa ErrorCall ErrorCall :: String ->  Exception\FString ExceptionThe ErrorCall exception is thrown by error. The String argument of ErrorCall is the string passed to error when it was called.  ErrorCall ErrorCall :: String ->  ExceptionfPString ExceptionThe ErrorCall exception is thrown by error. The String argument of ErrorCall is the string passed to error when it was called.  errorerror :: String -> aXJStringa<error stops execution and displays an error message. eqStringeqString :: String -> String -> Bool StringStringBooleqArrayeqArray :: (Ix i, Eq e) =>  Array i e ->  Array i e -> Bool{IxiEqeArrayieArrayieBoolEqclass Eq a?The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq. Minimal complete definition: either == or /=. EQEQ :: OrderingZOOrderingEOFEOF ::  IOErrorType IOErrorType enumFromToP enumFromToP ::  Enum a => a -> a -> [:a:]!Enumaaa[::]a enumFromTo enumFromTo ::  Enum a => a -> a -> [a]Enumaaa[]aenumFromThenToP enumFromThenToP ::  Enum a => a -> a -> a -> [:a:]9Enumaaaa[::]a enumFromThenTo enumFromThenTo ::  Enum a => a -> a -> a -> [a]Enumaaaa[]a enumFromThen enumFromThen ::  Enum a => a -> a -> [a]O2Enumaaa[]a enumFromenumFrom ::  Enum a => a -> [a]Enumaa[]a enumDeltaIntegerFB enumDeltaIntegerFB :: (Integer -> b -> b) -> Integer -> Integer -> bpGIntegerbbIntegerIntegerb enumDeltaIntegerenumDeltaInteger :: Integer -> Integer ->  [Integer]IntegerInteger[]Integer Enumclass Enum a7Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum 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 fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold: 
enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
  where
    bound | fromEnum y >= fromEnum x = maxBound
          | otherwise                = minBound
ensureIOManagerIsRunningensureIOManagerIsRunning :: IO ()X M IO() encodeFloat#  encodeFloat# :: Int# ->  ByteArray# -> Int -> Float  Int# ByteArray#IntFloat encodeFloat encodeFloat :: RealFloat a => Integer -> Int -> a ]  RealFloataIntegerInta encodeDouble#  encodeDouble# :: Int# ->  ByteArray# -> Int -> Double  Int# ByteArray#IntDoubleelemselems :: Ix i =>  Array i e -> [e] l IxiArrayie[]eelemPelemP :: Eq a => a -> [:a:] -> Bool  Eqaa[::]aBool elemelem :: Eq a => a -> [a] -> Bool|^Eqaa[]aBoolielem is the list membership predicate, usually written in infix form, e.g., x `elem` xs.  DynIOError DynIOError :: Dynamic ->  IOErrorTypeU<Dynamic IOErrorType DynException DynException :: Dynamic ->  ExceptionDynamic ExceptionnDynamically typed exceptions (see section on Dynamic Exceptions: Control.Exception#DynamicExceptions).  DynException DynException :: Dynamic ->  ExceptionDynamic ExceptionnDynamically typed exceptions (see section on Dynamic Exceptions: Control.Exception#DynamicExceptions).  DuplexHandle  DuplexHandle :: FilePath ->  MVar Handle__ ->  MVar Handle__ -> HandleFilePathMVarHandle__MVarHandle__Handle dropWhileP dropWhileP ::  (a -> Bool) -> [:a:] -> [:a:]]9aBool[::]a[::]a dropWhile dropWhile ::  (a -> Bool) -> [a] -> [a]aBool[]a[]adropWhile p xs returns the suffix remaining after takeWhile p xs: 
dropWhile (< 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]
dropPdropP :: Int -> [:a:] -> [:a:]<Int[::]a[::]a dropdrop :: Int -> [a] -> [a]Int[]a[]adrop n xs returns the suffix of xs after the first n elements, or [] if n > length 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 Data.List.genericDrop, in which n may be of any integral type.  dpermuteP  dpermuteP :: [:Int:] -> [:e:] -> [:e:] -> [:e:][::]Int[::]e[::]e[::]e double2Int double2Int :: Double -> IntF6DoubleInt double2Float double2Float :: Double -> FloatDoubleFloatDoubledata DoubleDouble-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type. Doubledata DoubleDouble-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type. done done :: Ix i => i -> i -> Int -> MutableArray# s e -> STRep s (Array i e) IxiiiInt MutableArray#seSTRepsArrayie divZeroError divZeroError :: aMIa divModInt divModInt :: Int -> Int ->  (Int, Int)IntInt(,)IntIntdivModdivMod :: Integral a => a -> a -> (a, a)N)Integralaaa(,)aadivInt#divInt# :: Int# -> Int# -> Int#Int#Int#Int# DivideByZero DivideByZero :: ArithExceptionArithException DivideByZero DivideByZero :: ArithExceptionraArithException divExactdivExact :: Integer -> Integer -> IntegerIntegerIntegerIntegerdivdiv :: Integral a => a -> a -> aaFIntegralaaaa deRefWeak deRefWeak :: Weak v ->  IO (Maybe v)WeakvIOMaybev8Dereferences a weak pointer. If the key is still alive, then Just v is returned (where v is the value in the weak pointer), otherwise Nothing is returned. The return value of deRefWeak depends on when the garbage collector runs, hence it is in the IO monad. deRefStablePtrdeRefStablePtr ::  StablePtr a -> IO aj StablePtraIOaObtain 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 deRefStablePtr has already been freed using freeStablePtr, the behaviour of deRefStablePtr is undefined. DenormalDenormal :: ArithException  ArithExceptionDenormalDenormal :: ArithExceptionI!8!ArithException denominator denominator :: Integral a => Ratio a -> a!!IntegralaRatioaaExtract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive. DefaultDefault :: Handler""Handler decodeFloat decodeFloat :: RealFloat a => a -> (Integer, Int)&#" RealFloataa(,)IntegerIntDeadlockDeadlock ::  Exceptionp#d# ExceptionThere are no runnable threads, so the program is deadlocked. The Deadlock exception is raised in the main thread only (see also: Control.Concurrent). DeadlockDeadlock ::  Exception^$R$ ExceptionThere are no runnable threads, so the program is deadlocked. The Deadlock exception is raised in the main thread only (see also: Control.Concurrent). D#D# :: Double# -> DoubleX%D%Double#DoubleD#D# :: Double# -> Double%%Double#Double cyclecycle :: [a] -> [a]&%[]a[]acycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists. crossPcrossP :: [:a:] -> [:b:] ->  [:(a, b):])'&[::]a[::]b[::](,)ab crossMapP crossMapP :: [:a:] ->  (a -> [:b:]) ->  [:(a, b):]''[::]aa[::]b[::](,)aboCompute a cross of an array and the arrays produced by the given function for the elements of the first array.  coshFloat coshFloat :: Float -> Float((FloatFloat coshDouble coshDouble :: Double -> Double((DoubleDoublecoshcosh :: Floating a => a -> aX)@)FloatingaaacosFloatcosFloat :: Float -> Float))FloatFloat cosDouble cosDouble :: Double -> Double**DoubleDoublecoscos :: Floating a => a -> au*]*FloatingaaaControlCControlC ::  ConsoleEvent** ConsoleEventControlCControlC ::  ConsoleEvent++ ConsoleEventconstconst :: a -> b -> ak+_+abaConstant function.  ConsoleEventdata  ConsoleEvent+ ConsoleEventdata  ConsoleEvent+concatPconcatP ::  [:[:a:]:] -> [:a:]d,C,[::][::]a[::]a concatMapP concatMapP ::  (a -> [:b:]) -> [:a:] -> [:b:],,a[::]b[::]a[::]b concatMap concatMap ::  (a -> [b]) -> [a] -> [b]v-S-a[]b[]a[]b8Map a function over a list and concatenate the results.  concatconcat :: [[a]] -> [a].-[][]a[]aConcatenate a list of lists.  compareInt# compareInt# :: Int# -> Int# -> Ordering..Int#Int#Ordering compareInt compareInt :: Int -> Int -> Ordering//IntIntOrderingcomparecompare ::  Ord a => a -> a -> Ordering/{/OrdaaaOrdering cmpIntArray cmpIntArray ::  Ord e =>  Array Int e ->  Array Int e -> OrderingK00OrdeArrayInteArrayInteOrderingcmpArraycmpArray :: (Ix i, Ord e) =>  Array i e ->  Array i e -> Ordering10IxiOrdeArrayieArrayieOrdering ClosedHandle ClosedHandle ::  HandleTypeU1H1 HandleTypeCloseClose ::  ConsoleEvent11 ConsoleEventCloseClose ::  ConsoleEvent11 ConsoleEventchrchr :: Int -> Char52'2IntCharAThe Prelude.toEnum method restricted to the type Data.Char.Char. choosechoose :: [(String, ReadPrec a)] ->  ReadPrec a 32[](,)StringReadPrecaReadPrecaParse the specified lexeme and continue as specified. Esp useful for nullary constructors; e.g. choose [("A", return A), ("B", return B)]  childHandler childHandler ::  Exception -> IO () 43 ExceptionIO() checkResult checkResult :: 6(State# RealWorld -> (# State# RealWorld, a, Addr# #)) -> IO a44State# RealWorld(#,,#)State# RealWorldaAddr#IOaChardata Char5dThe character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 charachers), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char. To convert a Char to or from the corresponding Int value defined by Unicode, use Prelude.toEnum and Prelude.fromEnum from the Prelude.Enum class respectively (or equivalently ord and chr). Chardata Char7dThe character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 charachers), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char. To convert a Char to or from the corresponding Int value defined by Unicode, use Prelude.toEnum and Prelude.fromEnum from the Prelude.Enum class respectively (or equivalently ord and chr). ceilingceiling :: (RealFrac a, Integral b) => a -> b|:U:RealFracaIntegralbabcatchSTMcatchSTM :: STM a -> (Exception -> STM a) -> STM a;:STMa ExceptionSTMaSTMa'Exception handling within STM actions. catchExceptioncatchException :: IO a -> (Exception -> IO a) -> IO a;;IOa ExceptionIOaIOacatchcatch :: IO a -> (IOError -> IO a) -> IO ad<;<IOaIOErrorIOaIOaThe catch function establishes a handler that receives any IOError raised in the action protected by catch. An IOError is caught by the most recent handler established by catch. These handlers are not selective: all IOErrors are caught. Exception propagation must be explicitly provided in a handler by re-raising any unwanted exceptions. For example, in 
f = catch g (\e -> if IO.isEOFError e then return [] else ioError e)
the function f returns [] when an end-of-file exception (cf. System.IO.Error.isEOFError) occurs in g; otherwise, the exception is propagated to the next outer handler. When an exception propagates outside the main program, the Haskell system prints the associated IOError value and exits the program. Non-I/O exceptions are not caught by this variant; to catch all exceptions, use Control.Exception.catch from Control.Exception. CatchCatch ::  ConsoleEvent -> IO () -> Handler@@ ConsoleEventIO()HandlercastStablePtrToPtrcastStablePtrToPtr ::  StablePtr a -> Ptr ()'A A StablePtraPtr()rCoerce a stable pointer to an address. No guarantees are made about the resulting value, except that the original stable pointer can be recovered by castPtrToStablePtr. 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 Foreign.Storable.Storable leads to undefined behaviour. castPtrToStablePtrcastPtrToStablePtr :: Ptr () ->  StablePtr aCBPtr() StablePtra[The inverse of castStablePtrToPtr, i.e., we have the identity 
sp == castPtrToStablePtr (castStablePtrToPtr sp)
for any stable pointer sp on which freeStablePtr has not been executed yet. Moreover, castPtrToStablePtr may only be applied to pointers that have been produced by castStablePtrToPtr. castPtrToFunPtrcastPtrToFunPtr :: Ptr a -> FunPtr bDDPtraFunPtrbCasts a Ptr to a FunPtr. 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. castPtrcastPtr :: Ptr a -> Ptr b\FEFPtraPtrbFThe castPtr function casts a pointer from one type to another. castFunPtrToPtrcastFunPtrToPtr :: FunPtr a -> Ptr bGFFunPtraPtrbCasts a FunPtr to a Ptr. 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.  castFunPtr castFunPtr :: FunPtr a -> FunPtr bH{HFunPtraFunPtrb>Casts a FunPtr to a FunPtr of a different type. castForeignPtrcastForeignPtr ::  ForeignPtr a ->  ForeignPtr b`I;I ForeignPtra ForeignPtrbUThis function casts a ForeignPtr parameterised by one type into another type. C#C# :: Char# -> CharJIChar#CharC#C# :: Char# -> CharQJAJChar#Charbuildbuild :: ((a -> b -> b) -> b -> b) -> [a]JJabbbb[]a9A list producer that can be fused with foldr. This function is merely 
build g = g (:) []
but GHC's simplifier will transform an expression of the form foldr k z (build g), which may arise after inlining, to g k z, which avoids producing an intermediate list. buildbuild :: ((a -> b -> b) -> b -> b) -> [a]vLWLabbbb[]a9A list producer that can be fused with foldr. This function is merely 
build g = g (:) []
but GHC's simplifier will transform an expression of the form foldr k z (build g), which may arise after inlining, to g k z, which avoids producing an intermediate list. bufWPtrbufWPtr :: Buffer -> IntNMBufferIntbufStatebufState :: Buffer ->  BufferStateqNYNBuffer BufferStatebufSizebufSize :: Buffer -> IntNNBufferIntbufRPtrbufRPtr :: Buffer -> Int!OOBufferInt BufferStatedata  BufferState[O BufferModedata  BufferModeO,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 flushed, from the internal buffer according to the buffer mode:
  • line-buffering: the entire output buffer is flushed whenever a newline is output, the buffer overflows, a System.IO.hFlush is issued, or the handle is closed.
  • block-buffering: the entire buffer is written out whenever it overflows, a System.IO.hFlush is issued, or the handle is closed.
  • no-buffering: 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. Similarly, 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-buffering: when the buffer for the handle becomes empty, the next block of data is read into the buffer.
  • no-buffering: the next input item is read and returned. The System.IO.hLookAhead 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.  BufferListNil BufferListNil ::  BufferListWW BufferListBufferListConsBufferListCons ::  RawBuffer ->  BufferList ->  BufferListWW RawBuffer BufferList BufferList BufferListdata  BufferListWbufferIsWritablebufferIsWritable :: Buffer -> BoolUXDXBufferBool bufferFull bufferFull :: Buffer -> BoolXXBufferBool bufferEmpty bufferEmpty :: Buffer -> BoolYYBufferBoolBufferBuffer ::  RawBuffer -> Int -> Int -> Int ->  BufferState -> BufferYY RawBufferIntIntInt BufferStateBufferBufferdata Buffer ZbufBufbufBuf :: Buffer ->  RawBufferkZUZBuffer RawBufferbreakpointCondbreakpointCond :: Bool -> a -> aZZBoolaabreakpointCondbreakpointCond :: Bool -> a -> aG[8[Boolaa breakpoint breakpoint :: a -> a[[aa breakpoint breakpoint :: a -> a[[aabreakPbreakP ::  (a -> Bool) -> [:a:] -> ([:a:], [:a:])\N\aBool[::]a(,)[::]a[::]a breakbreak ::  (a -> Bool) -> [a] ->  ([a], [a])]\aBool[]a(,)[]a[]abreak, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p 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],[])
break p is equivalent to span (not . p). BreakBreak ::  ConsoleEventE_6_ ConsoleEventBreakBreak ::  ConsoleEvent__ ConsoleEvent bpermuteP bpermuteP :: [:Int:] -> [:e:] -> [:e:]`_[::]Int[::]e[::]e boundsSTArray boundsSTArray ::  STArray s i e -> (i, i)`s`STArraysie(,)iiboundsbounds :: Ix i =>  Array i e -> (i, i)a`IxiArrayie(,)ii boundedEnumFromThenboundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]aaEnumaBoundedaaa[]a boundedEnumFromboundedEnumFrom :: (Enum a, Bounded a) => a -> [a]Ob'bEnumaBoundedaa[]a Boundedclass Bounded abThe Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds. The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded. Booldata BooldThe Bool type is an enumeration. It is defined with False first so that the corresponding Prelude.Enum instance will give Prelude.fromEnum False the value zero, and Prelude.fromEnum True the value 1. BlockedOnDeadMVarBlockedOnDeadMVar ::  Exceptionee ExceptionThe current thread was executing a call to Control.Concurrent.MVar.takeMVar that could never return, because there are no other references to this MVar. BlockedOnDeadMVarBlockedOnDeadMVar ::  Exceptionff ExceptionThe current thread was executing a call to Control.Concurrent.MVar.takeMVar that could never return, because there are no other references to this MVar. BlockedIndefinitelyBlockedIndefinitely ::  Exceptiongg ExceptionThe current thread was waiting to retry an atomic memory transaction that could never become possible to complete because there are no other threads referring to any of the TVars involved. BlockedIndefinitelyBlockedIndefinitely ::  Exceptionih ExceptionThe current thread was waiting to retry an atomic memory transaction that could never become possible to complete because there are no other threads referring to any of the TVars involved. BlockBufferingBlockBuffering ::  Maybe Int ->  BufferMode:jjMaybeInt BufferModeblock-buffering should be enabled if possible. The size of the buffer is n items if the argument is Just n and is otherwise implementation-dependent. blockblock :: IO a -> IO aAk,kIOaIOaApplying block to a computation will execute that computation with asynchronous exceptions blocked. That is, any thread which attempts to raise an exception in the current thread with Control.Exception.throwTo will be blocked until asynchronous exceptions are enabled again. There's no need to worry about re-enabling asynchronous exceptions; that is done automatically on exiting the scope of block. Threads created by Control.Concurrent.forkIO inherit the blocked state from the parent; that is, to start a thread in blocked mode, use block $ forkIO .... This is particularly useful if you need to establish an exception handler in the forked thread before any asynchronous exceptions are received. bindIObindIO :: IO a ->  (a -> IO b) -> IO bnynIOaaIObIObaugmentaugment :: ((a -> b -> b) -> b -> b) -> [a] -> [a].ooabbbb[]a[]aWA list producer that can be fused with foldr. This function is merely 
augment g xs = g (:) xs
but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list. augmentaugment :: ((a -> b -> b) -> b -> b) -> [a] -> [a]qpabbbb[]a[]aWA list producer that can be fused with foldr. This function is merely 
augment g xs = g (:) xs
but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.  atomically atomically :: STM a -> IO arrSTMaIOaPerform a series of STM actions atomically. You cannot use atomically inside an unsafePerformIO or unsafeInterleaveIO. 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 newTVarIO, which can be called inside unsafePerformIO, and which allows top-level TVars to be allocated. atanhatanh :: Floating a => a -> autFloatingaaaatan2atan2 :: RealFloat a => a -> a -> awu[u RealFloataaaaatanatan :: Floating a => a -> auuFloatingaaa asyncWriteBA asyncWriteBA :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld ->  IO (Int, Int)vvIntIntIntIntMutableByteArray# RealWorldIO(,)IntInt asyncWrite  asyncWrite :: Int -> Int -> Int -> Ptr a ->  IO (Int, Int)wWwIntIntIntPtraIO(,)IntInt asyncReadBA asyncReadBA :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld ->  IO (Int, Int)x5xIntIntIntIntMutableByteArray# RealWorldIO(,)IntInt asyncRead  asyncRead :: Int -> Int -> Int -> Ptr a ->  IO (Int, Int)8yyIntIntIntPtraIO(,)IntIntAsyncExceptiondata AsyncExceptionxyAsynchronous exceptions AsyncExceptionAsyncException :: AsyncException ->  ExceptionzyAsyncException ExceptionsAsynchronous exceptions (see section on Asynchronous Exceptions: Control.Exception#AsynchronousExceptions). AsyncExceptiondata AsyncExceptionzAsynchronous exceptions AsyncExceptionAsyncException :: AsyncException ->  Exception_{A{AsyncException ExceptionsAsynchronous exceptions (see section on Asynchronous Exceptions: Control.Exception#AsynchronousExceptions).  asyncDoProc asyncDoProc :: FunPtr (Ptr a -> IO Int) -> Ptr a -> IO Int|H|FunPtrPtraIOIntPtraIOIntasTypeOfasTypeOf :: a -> a -> a||aaaasTypeOf is a type-restricted version of const. 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. assocsassocs :: Ix i =>  Array i e -> [(i, e)]4~~IxiArrayie[](,)ieAssertionFailedAssertionFailed :: String ->  Exception~~String ExceptionThis exception is thrown by the assert operation when the condition fails. The String argument contains the location of the assertion in the source program. AssertionFailedAssertionFailed :: String ->  ExceptionString ExceptionThis exception is thrown by the assert operation when the condition fails. The String argument contains the location of the assertion in the source program.  assertError  assertError :: Addr# -> Bool -> a -> a܀Addr#Boolaaassertassert :: Bool -> a -> aPABoolaa7If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert. 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-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result. asinhasinh :: Floating a => a -> a҃Floatingaaaasinasin :: Floating a => a -> aK3Floatingaaa asciiTabasciiTab :: [String][]String arrEleBottom arrEleBottom :: aلՄaArrayExceptiondata ArrayException)Exceptions generated by array operations ArrayExceptionArrayException :: ArrayException ->  ExceptionąArrayException ExceptionlExceptions raised by array-related operations. (NOTE: GHC currently does not throw ArrayExceptions). ArrayExceptiondata ArrayExceptionp)Exceptions generated by array operations ArrayExceptionArrayException :: ArrayException ->  ExceptionArrayException ExceptionlExceptions raised by array-related operations. (NOTE: GHC currently does not throw ArrayExceptions). arrayarray :: Ix i => (i, i) -> [(i, e)] ->  Array i e(Ixi(,)ii[](,)ieArrayieArray Array :: i -> i -> Int -> Array# e ->  Array i eLjiiIntArray#eArrayieArraydata Ix i => Array i eThe type of immutable non-strict (boxed) arrays with indices in i and elements in e. The Int is the number of elements in the Array. ArithExceptiondata ArithException؉"The type of arithmetic exceptions ArithExceptionArithException :: ArithException ->  Exception|^ArithException ExceptionExceptions raised by arithmetic operations. (NOTE: GHC currently does not throw ArithExceptions except for DivideByZero). ArithExceptiondata ArithExceptionD"The type of arithmetic exceptions ArithExceptionArithException :: ArithException ->  ExceptionʋArithException ExceptionExceptions raised by arithmetic operations. (NOTE: GHC currently does not throw ArithExceptions except for DivideByZero).  appPrec1appPrec1 :: IntInt AppendMode AppendMode :: IOModeIOMode AppendMode AppendMode :: IOMode>5IOMode AppendHandle AppendHandle ::  HandleType HandleTypeanyPanyP ::  (a -> Bool) -> [:a:] -> Bool aBool[::]aBool anyany ::  (a -> Bool) -> [a] -> Bool|_aBool[]aBoolmApplied to a predicate and a list, any determines if any element of the list satisfies the predicate. andPandP :: [:Bool:] -> BoolE.[::]BoolBool andand :: [Bool] -> Bool[]BoolBooland returns the conjunction of a Boolean list. For the result to be True, the list must be finite; False, however, results from a False value at a finite index of a finite or infinite list. amapamap :: Ix i => (a -> b) ->  Array i a ->  Array i bܐIxiabArrayiaArrayibalwaysSucceedsalwaysSucceeds :: STM a -> STM ()~fSTMaSTM()5alwaysSucceeds 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. alwaysalways :: STM Bool -> STM ()STMBoolSTM()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.  AlreadyExists AlreadyExists ::  IOErrorType8* IOErrorTypeallPallP ::  (a -> Bool) -> [:a:] -> BoolaBool[::]aBoolallocateBufferallocateBuffer :: Int ->  BufferState ->  IO BufferC Int BufferStateIOBuffer allall ::  (a -> Bool) -> [a] -> BoolaBool[]aBoollApplied to a predicate and a list, all determines if all elements of the list satisfy the predicate. alignPtralignPtr :: Ptr a -> Int -> Ptr a{PtraIntPtraGiven an arbitrary address and an alignment constraint, alignPtr 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. adjust adjust ::  (e -> a -> e) -> MutableArray# s e -> (Int, a) ->  STRep s b ->  STRep s b5eae MutableArray#se(,)IntaSTRepsbSTRepsbaddMVarFinalizeraddMVarFinalizer :: MVar a -> IO () -> IO ()MVaraIO()IO()Add a finalizer to an MVar (GHC only). See Foreign.ForeignPtr and System.Mem.Weak for more about finalizers. addForeignPtrFinalizeraddForeignPtrFinalizer :: FinalizerPtr a ->  ForeignPtr a -> IO ()Q  FinalizerPtra ForeignPtraIO()This function adds a finalizer to the given foreign object. The finalizer will run before all other finalizers for the same object which have already been registered. addForeignPtrConcFinalizeraddForeignPtrConcFinalizer ::  ForeignPtr a -> IO () -> IO () ForeignPtraIO()IO()This function adds a finalizer to the given ForeignPtr. The finalizer will run before all other finalizers for the same object which have already been registered. This is a variant of addForeignPtrFinalizer, where the finalizer is an arbitrary IO 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, Handles are finalized objects, so a finalizer should not refer to a Handle (including stdout, stdin or stderr). acoshacosh :: Floating a => a -> aÞFloatingaaa acosFloat acosFloat :: Float -> Float!FloatFloat acosDouble acosDouble :: Double -> DoublerDoubleDoubleacosacos :: Floating a => a -> aΟFloatingaaa accumArray accumArray :: Ix i => e -> a -> e -> e -> (i, i) -> [(i, a)] ->  Array i eѠIxieaee(,)ii[](,)iaArrayieaccum accum :: Ix i =>  (e -> a -> e) ->  Array i e -> [(i, a)] ->  Array i eSIxieaeArrayie[](,)iaArrayie AbsoluteSeek AbsoluteSeek :: SeekModeSeekMode3the position of hdl is set to i.  absentErr absentErr :: aZVa absabs ::  Num a => a -> aNumaaa^^ (^^) :: (Fractional a, Integral b) => a -> b -> aC FractionalaIntegralbaba^ (^) :: (Num a, Integral b) => a -> b -> aǣNumaIntegralbaba[a]data [a][]([]) :: [a]-#[]a>>= (>>=) ::  Monad m => m a ->  (a -> m b) -> m bMonadmmaambmb>> (>>) ::  Monad m => m a -> m b -> m b?Monadmmambmb>= (>=) ::  Ord a => a -> a -> BoolOrdaaaBool> (>) ::  Ord a => a -> a -> BoolOrdaaaBool== (==) :: Eq a => a -> a -> BoolpEqaaaBool<= (<=) ::  Ord a => a -> a -> BoolަOrdaaaBool< (<) ::  Ord a => a -> a -> BooldKOrdaaaBool:+:data :+: a b:*: (:*:) :: a -> b -> :*: a bab:*:ab:*:data :*: a b(:% (:%) :: a -> a -> Ratio axaaRatioa: (:) :: a -> [a] -> [a]٨a[]a[]a/= (/=) :: Eq a => a -> a -> Bool^FEqaaaBool// (//) :: Ix i =>  Array i e -> [(i, e)] ->  Array i eǩIxiArrayie[](,)ieArrayie/ (/) :: Fractional a => a -> a -> ay\ Fractionalaaaa. (.) :: (b -> c) -> (a -> b) -> a -> cܪbcabac - (-) ::  Num a => a -> a -> a\FNumaaaa+:+ (+:+) :: [:a:] -> [:a:] -> [:a:]ث[::]a[::]a[::]a ++ (++) :: [a] -> [a] -> [a]F([]a[]a[]aAppend two lists, i.e., 
[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] -> [a] -> [a]n[]a[]a[]aAppend two lists, i.e., 
[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.  + (+) ::  Num a => a -> a -> aˮNumaaaa** (**) :: Floating a => a -> a -> a>#Floatingaaaa * (*) ::  Num a => a -> a -> aNumaaaa()(()) :: ()ۯ֯()()data ()aThe unit datatype () has one non-undefined member, the nullary constructor (). && (&&) :: Bool -> Bool -> Bool̰BoolBoolBoolBoolean "and" % (%) :: Integral a => a -> a -> Ratio aZ6IntegralaaaRatioa$ ($) :: (a -> b) -> a -> babab!: (!:) :: [:a:] -> Int -> a  [::]aInta !! (!!) :: [a] -> Int -> an[]aIntaList index (subscript) operator, starting from 0. It is an instance of the more general Data.List.genericIndex, which takes an index of any integral type. ! (!) :: Ix i =>  Array i e -> i -> euIxiArrayieieWordmodule GHC.WordijkSized unsigned integral types: Word, Word8, Word16, Word32, and Word64. Weakmodule GHC.Weak]Weak pointers. Unicodemodule GHC.UnicodeImplementations for the character predicates (isLower, isUpper, etc.) and the conversions (toUpper, toLower). The implementation uses libunicode on Unix systems if that is available.  TopHandlermodule GHC. TopHandlerSupport for catching exceptions raised during top-level computations (e.g. Main.main, Control.Concurrent.forkIO, and foreign exports) STRefmodule GHC.STRefP#References in the ST monad. Storablemodule GHC.Storable-Helper functions for Foreign.Storable Stablemodule GHC.StableStable pointers. STmodule GHC.STCThe ST Monad.  Showmodule GHC.Show/The Show class, and related operations. Realmodule GHC.RealThe types Ratio and Rational, and the classes Real, Fractional, Integral, and RealFrac. Readmodule GHC.Read:The Read class and instances for basic data types. Ptrmodule GHC.Ptr7The Ptr and FunPtr types and operations. PArrmodule GHC.PArr^Packmodule GHC.PackThis module provides a small set of low-level functions for packing and unpacking a chunk of bytes. Used by code emitted by the compiler plus the prelude libraries. The programmer level view of packed strings is provided by a GHC system library PackedString.  Nummodule GHC.Num2The Num class and the Integer type.  Listmodule GHC.List&The List data type and its operations IOBasemodule GHC.IOBaset5Definitions for the IO monad and its friends. IOmodule GHC.IOӻString I/O functions Intmodule GHC.IntYThe sized integral datatypes, Int8, Int16, Int32, and Int64. Handlemodule GHC.Handle;This module defines the basic operations on I/O "handles".  ForeignPtrmodule GHC. ForeignPtr9GHC's implementation of the ForeignPtr data type. Floatmodule GHC.Float}`The types Float and Double, and the classes Floating and RealFloat. Extsmodule GHC.Exts LGHC Extensions: this is the Approved Way to get at GHC-specific extensions.  Exceptionmodule GHC. Exception-Exceptions and exception-handling functions.  Errmodule GHC.ErrHThe GHC.Err module defines the code for the wired-in error functions, which have a special type in the compiler (with "open tyvars"). We cannot define these functions in a module where they might be used (e.g., GHC.Base), because the magical wired-in type will get confused with what the typechecker figures out.  Environmentmodule GHC. Environmentl Enummodule GHC.Enum,The Enum and Bounded classes. Dotnetmodule GHC.Dotnet6Primitive operations and types for doing .NET interop ConsoleHandlermodule GHC.ConsoleHandlerpcNB. the contents of this module are only available on Windows. Installing Win32 console handlers. Concmodule GHC.ConcBasic concurrency stuff. basepackage baseA.GHC modules that are part of the base library Basemodule GHC.BaseBasic data types and classes. Arrmodule GHC.ArrGHC's array implementation. xneUK<2'GHCWeakGHCStorableGHCUnicodeGHCPArrGHCFloatGHCIntGHCWordGHCExtsGHC EnvironmentGHCIOGHCDotnetGHCHandleGHCConsoleHandlerGHCSTRefGHCPackGHC ExceptionGHCReadGHC TopHandlerGHCErrGHCShowGHCListGHCNumGHCEnumGHCArrGHCConcGHCSTGHCStableGHC ForeignPtrGHCPtrGHCIOBaseGHCRealGHCBasebase3.0.1.07http://haskell.org/ghc/docs/latest/html/libraries/base/2http://haskell.org/ghc/docs/latest/html/libraries/