HOOGDTCd!/_ +,..OPa  !*,029;ACYb ;<@@BBLLXXc  ))+,44@@CHRTd !!))//2477BBQQe  ))+478;<@@BYf!!++//3478CWg88LLh,,99>@UVXXi '))/03479LLWYl  $'0144;<@@LLRTXXm ##(,11CHn ))-158BWo   "99;<@@BBLLXXp ##()+,44LLRTqr !"$(*+-02689;=?ADFHJLTVYs  $'))015=?@CXt !!$',,0156:@EEGGKLNNPPSSUYu ""&'1156==?Ww ,099>?OPUYx ##77BBy !"$(*02699<=?ADFHJLLNPTTVVXYz++88MN}%l()->AllAnybArithExceptionUArrayMArrayException@AsyncException3Bool BufferMode BufferStateCCharCClockeCDev3CDoubleCFloatCIno9CIntCIntMaxCIntPtraCLDoubleCLLongCLongxCMode0COffCPidCPtrdiffXCSCharCShort CSigAtomicCSize8CSsizeCTimeCUCharvCUInt.CUIntMaxCUIntPtrCULLongVCULongCUShortCWchar~ChansChar$Complex ConsoleEventConstr ConstrRepDataRepDataTypeDouble]DynamicNE12?E60Errno, Exception#ExitCodeFDType FdFixityFloatOGeneralCategory-Handle HandlePosn HandleTypeHashDataIO IOErrorType IOExceptionIOModeIdInsertsInt?Int16Int32Int64"Int8IntPtr{Integer;Lexeme-MaybeOrderingPQSemQSemNReadPrReadPrecYSTM@STUArray5SeekMode StableNameTVarThreadIdTimeoutTyConTypeRepUArrayOUniqueGVersion,Weak!WordWord16cWord32Word64 Word8F WordPtr ZipList [::] []  TraversableFoldableMonadFix Applicative Alternative MonadPlusFunctorMonadFunctorMonadFunctor Applicative ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqIArrayMArray PrintfArgStorableDataShowNumRealEnumIntegralBoundedIxReadBitsOrdEqIArrayMArray PrintfArgStorableDataEqOrdNumEnumIntegralBitsShowRealBoundedIxReadIArrayMArray PrintfArgStorableDataNumEnumIntegralBitsShowRealBoundedIxReadOrdEqIArrayMArray PrintfArgStorableDataShowNumRealEnumIntegralBoundedIxReadBitsOrdEqIArrayMArray PrintfArgStorableDataShowNumRealEnumIntegralBoundedIxReadBitsOrdEq Typeable1EqOrdShowReadTypeableOrdEq Typeable2IArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayIArrayDataDataEqTypeableDataShowEqOrdTypeable Typeable1 Typeable1ShowReadEnumIxOrdEq Typeable3 Typeable1FunctorMonadFunctorMonad MonadPlusFunctorMonad MonadPlusTypeableTypeableMonad MonadPlus MonoidDataReadShowBoundedEnumIxOrdEq TraversableFoldableMonadFix Applicative AlternativeFunctorMonad MonadPlusShowEqRead PrintfArgBitsDataReadEqOrdNumEnumShowIxRealIntegral ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqIArrayMArray PrintfArgStorableDataShowNumRealEnumIntegralBoundedIxReadBitsOrdEqIArrayMArray PrintfArgStorableDataEqOrdShowNumEnumIntegralReadBitsRealBoundedIxIArrayMArray PrintfArgStorableDataShowNumEnumIntegralReadBitsRealBoundedIxOrdEqIArrayMArray PrintfArgStorableDataShowNumRealEnumIntegralBoundedIxReadBitsOrdEqIArrayMArray PrintfArgBitsStorableDataReadShowNumBoundedEnumIxRealIntegralEqOrdEqFunctor ApplicativeShowReadEnumIxOrdEqEqShowEqShowMonadFix ApplicativeFunctorMonadShowEqShowEqShowDataEqShowIxBoundedShowReadEnumOrdEqIArrayMArray PrintfArgStorableDataEqOrdNumReal FractionalRealFracFloating RealFloatShowEnumReadShowEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqEqShowReadOrdEqShowEqEq HasResolution HasResolutionTypeableShowIArrayMArray PrintfArgStorableDataEqOrdNumReal FractionalFloatingRealFrac RealFloatShowEnumReadTypeableDataShowShowEqShowEqShowEqReadShowEnumOrdEqTypeable Typeable1 IArrayMArray PrintfArgIsCharStorableDataReadShowBoundedEnumIxEqOrd Typeable1 ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeable RealFloatRealFracFloating FractionalRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEq ReadShowTypeable RealFloatRealFracFloating FractionalRealStorableEnumNumOrdEq ReadShowTypeable RealFloatRealFracFloating FractionalRealStorableEnumNumOrdEq ReadShowTypeableRealStorableEnumNumOrdEq ReadShowTypeableRealStorableEnumNumOrdEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqEqShowReadOrdEq IArrayMArrayStorableDataReadShowBoundedEnumIxOrdEqShowOrdEqShowOrdEqIArrayShowOrdEqMonoidBoundedShowReadOrdEqMonoidBoundedShowReadOrdEqArrow ArrowChoice ArrowApply ArrowLoop MonoidDataReadShowBoundedEnumIxEqOrd7 ByteCount%CDir%CDirent%CFLock%CGroup%CLconv%CPasswd% CSigaction%CSigset%CStat%CString% CStringLeny%CTermiost%CTmo%CTmsj%CUtimbufe%CUtsname`%CWStringP% CWStringLen4% ClockTick+%ConIndex%%DeviceID% DiffArray% DiffUArray$ EpochTime$FD$FileID$FileMode$ FileOffset$FilePath$FinalizerEnvPtr$ FinalizerPtr_$GenericO$GenericBK$GenericM;$GenericQ0$GenericR%$GenericT$HandlePosition$IOError$IPr#Limit# ListUArray#Micro#Pico#Prec#ProcessGroupID# ProcessID#Rational{# RawBufferZ#ReadS-#STRep# SampleVar"ShowS"String"[]Char[]Char[]CharaMVar(,)IntMVarasaState#s(#,#)State#saa[]Char[](,)a[]CharMutableByteArray# RealWorldRatioIntegerCPidCPidIntFixedE12FixedE6e(,)ii[]eUArrayieCLong(,)IntInt IOExceptionIntegeraammararmamaacacaaFunPtrPtraIO()envaFunPtrPtrenvPtraIO()[]CharCOffCModeCInoCIntCTime IOToDiffArrayIOUArray IOToDiffArrayIOArrayCDevIntCClock(,)PtrCWcharIntPtrCWchar()()()()()(,)PtrCCharIntPtrCChar()()()()()()()()()CSize(q}:=}[ }avbscgdbe_fYgWhEUiMjMkVMlPJmGnDo@p<q<rF6s(0t-u*v)w&za&ih&po&lv&i}&s&t&ZipList#)1)3)6)8m)e=)ok(r&ay'i&t&e&bE'h'm&o&d&e'IOModea'n 'd''l.'e5' HandleTypeuL'fS'fZ'ea'rh' BufferStatep'a=(m(p'e'd'a'm'o'n'a'd' WrappedMonadr'r'o'w' WrappedArrowo(n(a$(d+( WrappedMonadrD(rK(oR(wY( WrappedArrowrr(dy(Word#.)1)3)6(8(p(t(r(WordPtrWord84(Word64#(Word64#2)Word326)Word16Word#aD)kK)Weak#^)Weak##t)Word84)#)Word642)#)Word326)#)Word16Worde)r)s)i)o)n*Versiona,n*pj*s(*e/*r6*e=*rD*rK*oR*rY* IOErrorTypepq*ex*r*c*a*s*e*l*e*t*t*e*r*GeneralCategoryd?,i,s*ax+u*p*p+o +r+t+e!+d(+o/+p6+e=+rD+aK+tR+iY+o`+ng+ IOErrorTypet+i+s+f+i+e+d+c+o+n+s+t+r+a+i+n+t+s+ IOErrorTypeq!,t,Unitu(,e/,UniqueeF,f,rR,fY,l`,og,wn,ArithExceptioni,n,e,d,e,l,e,m,e,n,t,ArrayExceptionr,r,a,y,UArrayh/i.rp.vT.y*-c7.p6-e=-ah-rI-eP-pW-TypeRepbo-lv-e}-Typeable1$.2.3-4-5-6-7- Typeable7 Typeable6 Typeable5 Typeable4 Typeable3 Typeable2 Typeable1o>.nE.TyCona[.rb.TVara.u|.e.Boolv.e.r.s.a.b.l.e. TraversablemO/t.l.e.c.a/s /e/l/e/t%/t,/e3/r:/GeneralCategoryeV/e]/xd/pk/ir/ry/e/d/ IOErrorTyper/e/a/d/i/k/i/l/l/e/d/AsyncExceptiond/ThreadId#0 ThreadId##96a5e 5h4p3t 1u0yR0m0s^0te0el0ms0ez0r0r0o0r0 IOErrorTypeb0o0l0Lexemem1r0r0o0g0a0t0e0GeneralCategorySumSTa2m2oQ2rz1uE1aL1rS1rZ1aa1yh1STUArraye1i1n1g1Stringc1r1e1p1DataRepo1n1s1t1r1 ConstrRepa>2f/2p 2t2STretSTRepSTRefmE2FDTyperX2a_2bf2lm2et2Storablea2r2r2a2y2 StorableArraySTMbx3c%3r2t2e2#2State#r3a 3y3STArrayk,3o33v:3eA3rH3fO3lV3o]3wd3AsyncExceptionl3e3n3p3t3r3 StablePtr#3 StablePtr#a3m3e3 StableNamea3c4e4i4n4g4c$4o+4m24b94i@4nG4iN4nU4g\4mc4aj4rq4kx4GeneralCategoryGeneralCategoryo4u4t4d4o4w4n4 ConsoleEventw4Shows4ShowSe5m5i5c&5l-5o45s;5eB5dI5hP5aW5n^5de5ll5es5 HandleTypek5f5m5o5d5e5SeekModer5o5m5e5n5d5SeekModem5p6l 6e6v6a6r&6 SampleVarIntegera;ex6iW6g^6he6tl6Eithera9c8g8lD8q7s6t6u6r6n6i6n6o6r6d6e6r6ArgOrdero6u6r7c 7e7b7eg7v%7a,7n37i:7sA7hH7eO7dV7 IOErrorTypexn7hu7a|7u7s7t7e7d7 IOErrorTypeu7s7y7 IOErrorTypea(8u7i7r7e7o7r8d 8e8r8ArgOrderr/8g68ArgDescraK8tR8iY8v`8eg8sn8eu8e|8k8SeekModeu8l8a8r8f8i8l8e8FDTypecf9s&9u8p8d8e8r9r 9o9r9 Exceptione-9l49e;9rB9rI9oP9rW9 Exceptionom9nt9e{9r9r9o9r9 ExceptiondM:l9Realf9w9o9r9l9d9 RealWorldl%:r:a :c:RealFraco,:a3:t:: RealFloatReadb;hY;m8;p;s:wy:r:i:t:e:h:m:o:d:e:IOModea:n:d:l:e: HandleTypeReadSReadPr;e;c&;ReadPreco?;dF;eM;IOModea`;ng;dn;lu;e|; HandleTypeu;f;f;e;r; BufferStatet=<w;b<d;e;v;i;c;e;FDTypeu<f<f<e#<r*< RawBufferLexemeiN<oU<Rationi<ap<lw<Rationals<e<m<QSemn<QSemNa?eC?i'?o ?r=t<u<n<c<Lexemer=Ptre>i(>o$=c=d=t5=o<=cC=oJ=lQ=eX=r_=rf=om=rt= IOErrorTypeu=c=t=Producte=s=s=g=i=d= ProcessIDr=o=u=p>i >d>ProcessGroupIDns>v4>a;>tB>eI>uP>sW>e^>GeneralCategorytz>f>a>t>y>p>e> PrintfTyper>g> PrintfArgc>f>i>x>FixityPreco?l?Poolc.?o5?PicorJ?mQ?iy?u]?td?ek?ArgOrders?s?i?o?n?d?e?n?i?e?d? IOErrorTyperM@t?t?e?r?n?m@a @t@c@h"@f)@a0@i7@l>@ ExceptionaT@g[@rb@ai@pp@hw@s~@e@p@a@r@a@t@o@r@GeneralCategoryOpaquebCpBrBt.Av@e@r@fAl AoAwAArithExceptionh5AeBeEBrLBGeneralCategoryrhBroBovBr}B IOErrorTypedBOrdeBrBiBnBgBOrderingaCe]CtBaACdCiBoBnCOptDescreCs!Cc(Cr/COptDescrrHCgOCArgDescrndCpkCurCnyCcCtCuCaCtCiCoCnCGeneralCategoryqCuCeCOpaquejCeCcDtDObjecteFo^Handlee^f^g[^eb^ni^ep^rw^i~^c^FFFormati^o^r^m^a^t^FFFormatx^e^d^FFFormatx^p^o_n _e_n_t!_FFFormatFDFdtG_yN_pU_e\_FDTypels_sz_e_BoolFloat 1b6bifbnaoapyaqdar ax_c`i_t_c`e^`f&`s_u_c_c`e `s`s`ExitCodea-`i4`l;`uB`rI`eP`ExitCodexe`cl`es`pz`t`i`o`n` Exceptiono`d`e`ExitCodee`p`t`i`o`n` ExceptionranNaoar#ac*aa1al8al?a ExceptionoUaErrnoOrderingEqoacahataiamaea EpochTimefaLexemec bdauamaEnumoaEndolbobs bi'bn.bg5bmeyEe DiffArrayacfcffenevseizeceeeiedeDeviceIDoeremeaeleArithExceptionaeueleteHandlerifmfafl$fn+fu2fm9fb@feGfrNfGeneralCategorydjflqfoxfcfkf ExceptionsgtfafDataDatarftfyfpfefDataTypeefpfDataRephgpgu$gn+gc2gt9gu@gaGgtNgiUgo\gncgGeneralCategoryDouble#saascsdrfqgqhqiqjpl7omoomplsjt\juihwgcDhsgtgrgignhg hCWStringl!he(hn/h CWStringLenhKhaRhrYhCWcharc7jiilirishthihshnhahmhehCUtsnamemhbhuhfhCUtimbufhhohrit iCUShortr%ie,in3ic:iyAisHiyOimVib]iodilkiGeneralCategorylioinigiCULongoinigiCULLongnitiCUIntmjpitirjCUIntPtrajx%jCUIntMaxh>jaEjrLjCUCharejijmmjCTmsjCTmsmjejCTimerjmjijojsjCTermioscllhGliksiktjaSkrki knkgkCStringl1ke8kn?k CStringLentZkCStatipkzwke~kCSsizegkzkekCSizeakskektkCSigsetcltkokmkikcl CSigAtomictli%lo,ln3l CSigactionoNlrUlt\lCShorthslazlrlCSCharaliltlrldlilflflCPtrdiffdlCPidslslwmdmCPasswdfnmnn*minnnsmt@mrGmoNmlUmGeneralCategorycom ConsoleEventomtmConstrmConstrrmempm ConstrReplmememvmemnntn ConsoleEvente%nc,nt3no:nrAnpHnuOnnVnc]ntdnuknarntyninonnnGeneralCategorynndnenxnConIndexpnlnenxnComplexfoCOffood!oe(oCModecpdplbpoMoc,pnps^oeeo ConsoleEventdopouonocotouoaotoiooonoGeneralCategoryhoaonodoloep HandleTypegpCLongk3pt:piApcHpkOp ClockTickoipnppgwpCLLongopupbplpepCLDoubleopnpvpCLconvmpppbpupfqCJmpBufnqo~qt(qCIntm_qp@qtGqrNqCIntPtrafqxmqCIntMaxCInoaqnqrqChar#qChar#ChanrqoquqpqCGroupijrl)rp rorsrCFposo0raSrc! ()IO6()m52IntIO7Intm.aIOeIOe[]'em30i[](eia IOToDiffArrayIObixIOUArrayIOei(,)[]%ei StorableArrayIOeiamF  eibm-,ii(,)m)aPtrIOe[]m+ei(,)[]m* ʈOJee'eDCBA@?>Int#Int# ee'FEjiaIOePtr ByteArray#=CSizeHandle76Int =<876210 Int#:9e DCB;;;52 e';i==<<543 aixsSTUArrayeia IOToDiffArrayeisSTUArray Word8IntIOUArray76aixIOUArrayeIntUArrayei StorableArrayeiUArray>!  eiaA@?8543210/.-,+*)('&%$#"ejae'iaFEii(,)DCB; eisSTArraysSTeisSTUArraysSTe ForeignPtre[]sMutableByteArray#<eInt(,)[]$#!ei(,)[]&e'Int(,)[]DCB@?>e'i(,)[]A;FfD"ʒu>.ۑ|lJ(ܐ̐y[<Ώ`::ƍyW,׌\MB‹zjH&CDIxiMArrayaMArrayeMArraye'MArraymIArrayaIArrayeIArraye'IxijIArrayaIArrayeIxilIxiMArrayeMArrayskIxiIArrayaIArrayeIxiiIArrayaIArrayeIximIArrayaIArrayeIxinIxiMArrayeMArraysg`IArrayaIArrayeIxi]IArrayaIArrayeIxiShoweShowiShowS45IxiMArrayaMArrayeMArraym IArrayaIArrayeIxiUVIxiMArrayaMArrayeMArraymIxiMArrayaMArrayeMArraymqIArrayaIArrayeIxixIxiMArrayaMArrayeMArraymTIArrayaIArrayeIxi3IxiMArrayaMArrayeMArraym)*stIArraybIArrayeIxiMArrayaMArrayeMArraymbc|}IArrayaIArrayeIxiMArraybMArrayeMArraym12IxiMArrayaMArrayeMArraym,-IxiMArrayaMArrayeMArraym./0IxiMArrayaMArrayeMArraym89IArrayaIArrayeIxi&'IArrayaIArrayeIxi IArrayaIArrayeIxiIArrayaIArrayeIxiyIArrayaIArrayeIxizIArrayaIArrayeIxiIArrayaIArrayeIxi{IxiMArrayeMArrays#IArrayeIxiOrde(EqeIArrayeIxid~Ixi"IArrayeOrdee !+IxiuZIxiYIxiJIWIxiMArrayaMArrayeXIxiMArrayaMArrayerIxiEFIxiIxjMArrayaMArrayeMArraym<=IArrayaIArrayeIxiIxjwIxiKLMIxiMArrayaMArrayeMArraym[Ixi\IxiNOPvIxiMArrayaMArrayeMArraymRSIxiMArrayaMArrayeMArraym>?IArrayaIArrayeIxiBIxiMArrayeMArrays@IxiIArrayaIArrayeIxipIxiMArrayeMArraysoIArrayaIArrayeIxiQIxiMArrayaMArrayeYR>$kK'ݟmO;Ǟa;՝yiC' ɜeA!ٛkC!ٚkM'ٙwS#ǘk3 ߗs)͖iI#ǕsQ# writearray writeArraywithstorablearray9withStorableArray unsafewritea unsafeWriteunsafethawstuarrayunsafeThawSTUArray~ unsafethaw unsafeThaw|}unsafereplaceuarrayߕunsafeReplaceUArray{unsafereplacest unsafeReplaceSTz unsafereplace5 unsafeReplacey unsafereadX unsafeReadxunsafenewarraystuarray_unsafeNewArraySTUArray_wunsafenewarray_unsafeNewArray_vunsafefreezestuarrayunsafeFreezeSTUArrayu unsafefreeze unsafeFreezestunsafeforeignptrtostorablearrayMunsafeForeignPtrToStorableArrayrunsafeatunsafeAtqunsafearrayuarrayunsafeArrayUArrayp unsafearray͗ unsafeArrayounsafeaccumuarrayunsafeAccumUArrayn unsafeaccumst unsafeAccumSTmunsafeaccumarrayuarrayNunsafeAccumArrayUArraylunsafeaccumarraystunsafeAccumArraySTkunsafeaccumarrayunsafeAccumArrayj unsafeaccumט unsafeAccumiunboxedUnboxed uarrayUArrayfghtouchstorablearray:touchStorableArraye thawstuarrayd thawSTUArraydthawthawbcstuarraySTUArray_`a storablearrayř StorableArray^storableStorablestST showsiarray showsIArray] saferangesize9 safeRangeSize\ safeindex[ safeIndex[ runstuarray{ runSTUArrayZ runstarray runSTArrayYreplacediffarrayšreplaceDiffArrayX readdiffarray readDiffArrayW readarray  readArrayUV numelements1 numElementsT newlistarrayT newListArrayRS newdiffarray| newDiffArrayQ newarray_ newArray_NOPnewarray›newArrayKLM memcpy_thaw memcpy_thawJ memcpy_freeze  memcpy_freezeImarray,MArrayGH mapindicesP mapIndicesEFmaparrayrmapArrayCD listuarrayst listUArraySTB listuarray ListUArrayA listarraystٜ listArrayST@ listarray listArray>?ixmapixmap<=iouarray4IOUArray; iotodiffarrayU IOToDiffArray:iopIOindicesindices89iarrayIArray67 hputarrayŝ hPutArray5 hgetarray hGetArray4getnumelementsgetNumElements3getelems(getElems12 getboundsI getBounds./0 getassocso getAssocs,-freezestuarrayfreezeSTUArray+freezefreeze)*equarrayԞeqUArray(elemselems&' diffuarray  DiffUArray% diffarray+ DiffArray$diffDDiff cmpuarray] cmpUArray# cmpintuarray~ cmpIntUArray" caststuarray castSTUArray ! castiouarrayʟ castIOUArrayboundsboundsbool_word_scalebOOL_WORD_SCALE bool_not_bit8 bOOL_NOT_BIT bool_indexZ bOOL_INDEXbasetBaseassocsassocs arrelebottom arrEleBottomarrayɠArrayarrayamapamap accumarray accumArrayaccum.accum//E// !X! A@@?>6>K=<1;: ::9(51/ -)&%h$NxF~ZR    `  h*"w*h;{/x3{6ma&.tO}cn%"Q7KB2ܷ˶B}]|Ѭ <{ŧ.Qt writeArray  writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m ())MArrayaemIxiaieiem()$Write an element in a mutable array  writeArray  writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m ()ͤMArrayaemIxiaieiem()$Write an element in a mutable array withStorableArraywithStorableArray :: StorableArray i e -> (Ptr e -> IO a) -> IO a StorableArrayiePtreIOaIOaThe pointer to the array contents is obtained by withStorableArray. The idea is similar to ForeignPtr (used internally here). The pointer should be used only during execution of the IO action retured by the function passed as argument to withStorableArray.  unsafeWrite  unsafeWrite :: (MArray a e m, Ix i) => a i e -> Int -> e -> m ()MArrayaemIxiaieIntem()unsafeThawSTUArrayunsafeThawSTUArray :: Ix i =>  UArray i e -> ST s (STUArray s i e)w=IxiUArrayieSTsSTUArraysie unsafeThaw unsafeThaw :: $(Ix i, IArray a e, MArray b e m) => a i e ->  m (b i e)8IxiIArrayaeMArraybemaiembie unsafeThaw unsafeThaw :: $(Ix i, IArray a e, MArray b e m) => a i e ->  m (b i e)IxiIArrayaeMArraybemaiembieunsafeReplaceUArrayunsafeReplaceUArray :: ((MArray (STUArray s) e (ST s), Ix i) =>  UArray i e ->  [(Int, e)] -> ST s (UArray i e)MArraySTUArrayseSTsIxiUArrayie[](,)InteSTsUArrayieunsafeReplaceSTunsafeReplaceST :: (IArray a e, Ix i) => a i e ->  [(Int, e)] -> ST s (STArray s i e)IArrayaeIxiaie[](,)InteSTsSTArraysie unsafeReplace unsafeReplace :: (IArray a e, Ix i) => a i e ->  [(Int, e)] -> a i eͬIArrayaeIxiaie[](,)Inteaie unsafeRead unsafeRead :: (MArray a e m, Ix i) => a i e -> Int -> m exAMArrayaemIxiaieIntmeunsafeNewArraySTUArray_unsafeNewArraySTUArray_ :: Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)YIxi(,)iiInt#Int#STsSTUArraysieunsafeNewArray_unsafeNewArray_ :: (MArray a e m, Ix i) => (i, i) ->  m (a i e) ϮMArrayaemIxi(,)iimaieunsafeFreezeSTUArrayunsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e)STUArraysieSTsUArrayie unsafeFreeze unsafeFreeze :: $(Ix i, MArray a e m, IArray b e) => a i e ->  m (b i e)y/IxiMArrayaemIArraybeaiembie unsafeFreeze unsafeFreeze :: $(Ix i, MArray a e m, IArray b e) => a i e ->  m (b i e)>IxiMArrayaemIArraybeaiembieunsafeForeignPtrToStorableArrayunsafeForeignPtrToStorableArray :: Ix i =>  ForeignPtr e -> (i, i) -> IO (StorableArray i e)0Ixi ForeignPtre(,)iiIO StorableArrayieConstruct a StorableArray from an arbitrary ForeignPtr. It is the caller's responsibility to ensure that the ForeignPtr points to an area of memory sufficient for the specified bounds. unsafeAtunsafeAt :: (IArray a e, Ix i) => a i e -> Int -> ejIArrayaeIxiaieInteunsafeArrayUArray unsafeArrayUArray :: ((MArray (STUArray s) e (ST s), Ix i) => (i, i) ->  [(Int, e)] -> e -> ST s (UArray i e)NMArraySTUArrayseSTsIxi(,)ii[](,)InteeSTsUArrayie unsafeArray unsafeArray :: (IArray a e, Ix i) => (i, i) ->  [(Int, e)] -> a i e;IArrayaeIxi(,)ii[](,)InteaieunsafeAccumUArray unsafeAccumUArray :: ((MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) ->  UArray i e ->  [(Int, e')] -> ST s (UArray i e)ǶKMArraySTUArrayseSTsIxiee'eUArrayie[](,)Inte'STsUArrayie unsafeAccumST  unsafeAccumST :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e ->  [(Int, e')] -> ST s (STArray s i e)طrIArrayaeIxiee'eaie[](,)Inte'STsSTArraysieunsafeAccumArrayUArray unsafeAccumArrayUArray :: ((MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> e -> (i, i) ->  [(Int, e')] -> ST s (UArray i e).MArraySTUArrayseSTsIxiee'ee(,)ii[](,)Inte'STsUArrayieunsafeAccumArrayST unsafeAccumArrayST :: Ix i => (e -> e' -> e) -> e -> (i, i) ->  [(Int, e')] -> ST s (STArray s i e)>Ixiee'ee(,)ii[](,)Inte'STsSTArraysieunsafeAccumArray unsafeAccumArray :: (IArray a e, Ix i) => (e -> e' -> e) -> e -> (i, i) ->  [(Int, e')] -> a i eGIArrayaeIxiee'ee(,)ii[](,)Inte'aie unsafeAccum  unsafeAccum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e ->  [(Int, e')] -> a i e3߻IArrayaeIxiee'eaie[](,)Inte'aieUArraydata UArray i egBArrays with unboxed elements. Instances of IArray are provided for UArray with certain element types (Int, Float, Char, etc.; see the UArray class for a full list). A UArray will generally be more efficient (in terms of both time and space) than the equivalent Data.Array.Array with the same element type. However, UArray is strict in its elements - so don't use UArray if you require the non-strictness that Data.Array.Array provides. Because the IArray interface provides operations overloaded on the type of the array, it should be possible to just change the array type being used by a program from say Array to UArray to get the benefits of unboxed arrays (don't forget to import Data.Array.Unboxed instead of Data.Array). UArray UArray :: i -> i -> Int ->  ByteArray# ->  UArray i eM#iiInt ByteArray#UArrayieUArraydata UArray i eBArrays with unboxed elements. Instances of IArray are provided for UArray with certain element types (Int, Float, Char, etc.; see the UArray class for a full list). A UArray will generally be more efficient (in terms of both time and space) than the equivalent Data.Array.Array with the same element type. However, UArray is strict in its elements - so don't use UArray if you require the non-strictness that Data.Array.Array provides. Because the IArray interface provides operations overloaded on the type of the array, it should be possible to just change the array type being used by a program from say Array to UArray to get the benefits of unboxed arrays (don't forget to import Data.Array.Unboxed instead of Data.Array). touchStorableArraytouchStorableArray :: StorableArray i e -> IO ()R. StorableArrayieIO()If you want to use it afterwards, ensure that you touchStorableArray after the last use of the pointer, so the array is not freed too early.  thawSTUArray thawSTUArray :: Ix i =>  UArray i e -> ST s (STUArray s i e)VIxiUArrayieSTsSTUArraysiethawthaw :: $(Ix i, IArray a e, MArray b e m) => a i e ->  m (b i e)EIxiIArrayaeMArraybemaiembieConverts an immutable array (any instance of IArray) into a mutable array (any instance of MArray) by taking a complete copy of it. thawthaw :: $(Ix i, IArray a e, MArray b e m) => a i e ->  m (b i e)BIxiIArrayaeMArraybemaiembieConverts an immutable array (any instance of IArray) into a mutable array (any instance of MArray) by taking a complete copy of it. STUArraydata STUArray s i aXA mutable array with unboxed elements, that can be manipulated 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. Only certain element types are supported.
An STUArray will generally be more efficient (in terms of both time and space) than the equivalent boxed version (STArray) with the same element type. However, STUArray is strict in its elements - so don't use STUArray if you require the non-strictness that STArray provides. STUArray STUArray :: i -> i -> Int -> MutableByteArray# s -> STUArray s i aiiIntMutableByteArray#sSTUArraysiaSTUArraydata STUArray s i aA mutable array with unboxed elements, that can be manipulated 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. Only certain element types are supported.
An STUArray will generally be more efficient (in terms of both time and space) than the equivalent boxed version (STArray) with the same element type. However, STUArray is strict in its elements - so don't use STUArray if you require the non-strictness that STArray provides.  StorableArraydata  StorableArray i eThe array type  showsIArray showsIArray :: &(IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowSIArrayaeIxiShowiShoweIntaieShowS safeRangeSize safeRangeSize :: Ix i => (i, i) -> IntjLIxi(,)iiInt safeIndex  safeIndex :: Ix i => (i, i) -> Int -> i -> IntIxi(,)iiIntiInt runSTUArray runSTUArray :: Ix i => ST s (STUArray s i e) ->  UArray i enIxiSTsSTUArraysieUArrayieA safe way to create and work with an unboxed mutable array before returning an immutable array for later perusal. This function avoids copying the array before returning it - it uses unsafeFreeze internally, but this wrapper is a safe interface to that function.  runSTArray runSTArray :: Ix i => ST s (STArray s i e) ->  Array i eY!IxiSTsSTArraysieArrayieA safe way to create and work with a mutable array before returning an immutable array for later perusal. This function avoids copying the array before returning it - it uses unsafeFreeze internally, but this wrapper is a safe interface to that function. replaceDiffArrayreplaceDiffArray :: (MArray a e IO, Ix i) => IOToDiffArray a i e ->  [(Int, e)] -> IO (IOToDiffArray a i e)y MArrayaeIOIxi IOToDiffArrayaie[](,)InteIO IOToDiffArrayaie readDiffArray readDiffArray :: (MArray a e IO, Ix i) => IOToDiffArray a i e -> Int -> IO eKMArrayaeIOIxi IOToDiffArrayaieIntIOe readArray readArray :: (MArray a e m, Ix i) => a i e -> i -> m eMArrayaemIxiaieime%Read an element from a mutable array  readArray readArray :: (MArray a e m, Ix i) => a i e -> i -> m eMArrayaemIxiaieime%Read an element from a mutable array  numElements numElements :: (IArray a e, Ix i) => a i e -> IntpDIArrayaeIxiaieInt newListArray newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] ->  m (a i e)4MArrayaemIxi(,)ii[]emaieConstructs a mutable array from a list of initial elements. The list gives the elements of the array in ascending order beginning with the lowest index.  newListArray newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] ->  m (a i e)LMArrayaemIxi(,)ii[]emaieConstructs a mutable array from a list of initial elements. The list gives the elements of the array in ascending order beginning with the lowest index.  newDiffArray newDiffArray :: (MArray a e IO, Ix i) => (i, i) ->  [(Int, e)] -> IO (IOToDiffArray a i e)"MArrayaeIOIxi(,)ii[](,)InteIO IOToDiffArrayaie newArray_ newArray_ :: (MArray a e m, Ix i) => (i, i) ->  m (a i e)MArrayaemIxi(,)iimaieBuilds a new array, with every element initialised to an undefined value. In a monadic context in which operations must be deterministic (e.g. the ST monad), the array elements are initialised to a fixed but undefined value, such as zero.  newArray_ newArray_ :: (MArray a e m, Ix i) => (i, i) ->  m (a i e)]!MArrayaemIxi(,)iimaie newArray_ newArray_ :: (MArray a e m, Ix i) => (i, i) ->  m (a i e)MArrayaemIxi(,)iimaienewArraynewArray :: (MArray a e m, Ix i) => (i, i) -> e ->  m (a i e)xMArrayaemIxi(,)iiemaieJBuilds a new array, with every element initialised to the supplied value. newArraynewArray :: (MArray a e m, Ix i) => (i, i) -> e ->  m (a i e)vMArrayaemIxi(,)iiemaienewArraynewArray :: (MArray a e m, Ix i) => (i, i) -> e ->  m (a i e)i*MArrayaemIxi(,)iiemaie memcpy_thaw  memcpy_thaw :: MutableByteArray# s ->  ByteArray# -> CSize ->  IO (Ptr a)2MutableByteArray#s ByteArray#CSizeIOPtra memcpy_freeze  memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize ->  IO (Ptr a)MutableByteArray#sMutableByteArray#sCSizeIOPtraMArrayclass  Monad m => MArray a e mV!Class of mutable array types. An array type has the form (a i e) where a is the array type constructor (kind * -> * -> *), i is the index type (a member of the class Ix), and e is the element type. The MArray class is parameterised over both a and e (so that instances specialised to certain element types can be defined, in the same way as for IArray), and also over the type of the monad, m, in which the mutable array will be manipulated. MArrayclass  Monad m => MArray a e m!Class of mutable array types. An array type has the form (a i e) where a is the array type constructor (kind * -> * -> *), i is the index type (a member of the class Ix), and e is the element type. The MArray class is parameterised over both a and e (so that instances specialised to certain element types can be defined, in the same way as for IArray), and also over the type of the monad, m, in which the mutable array will be manipulated.  mapIndices  mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e ->  m (a i e)qMArrayaemIxiIxj(,)iiijajemaiefConstructs a new array derived from the original array by applying a function to each of the indices.  mapIndices  mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e ->  m (a i e)MArrayaemIxiIxj(,)iiijajemaiefConstructs a new array derived from the original array by applying a function to each of the indices. mapArraymapArray :: '(MArray a e' m, MArray a e m, Ix i) =>  (e' -> e) -> a i e' ->  m (a i e)hMArrayae'mMArrayaemIxie'eaie'maiegConstructs a new array derived from the original array by applying a function to each of the elements. mapArraymapArray :: '(MArray a e' m, MArray a e m, Ix i) =>  (e' -> e) -> a i e' ->  m (a i e)[MArrayae'mMArrayaemIxie'eaie'maiegConstructs a new array derived from the original array by applying a function to each of the elements.  listUArrayST listUArrayST :: ((MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [e] -> ST s (STUArray s i e)MArraySTUArrayseSTsIxi(,)ii[]eSTsSTUArraysie ListUArraytype  ListUArray e = (i, i) -> [e] -> UArray i et listArrayST listArrayST :: Ix i => (i, i) -> [e] -> ST s (STArray s i e)+Ixi(,)ii[]eSTsSTArraysie listArray listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i eIArrayaeIxi(,)ii[]eaieConstructs an immutable array from a list of initial elements. The list gives the elements of the array in ascending order beginning with the lowest index.  listArray listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i e'IArrayaeIxi(,)ii[]eaieConstructs an immutable array from a list of initial elements. The list gives the elements of the array in ascending order beginning with the lowest index. ixmap ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i eJIArrayaeIxiIxj(,)iiijajeaiecReturns a new array derived from the original array by applying a function to each of the indices. ixmap ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i eIArrayaeIxiIxj(,)iiijajeaiecReturns a new array derived from the original array by applying a function to each of the indices. IOUArraydata IOUArray i eoQMutable, unboxed, strict arrays 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. Only certain element types are supported: see Data.Array.MArray for a list of instances.
 IOToDiffArraydata  IOToDiffArray a i e`An arbitrary MArray type living in the IO monad can be converted to a diff array. indicesindices :: (IArray a e, Ix i) => a i e -> [i]IArrayaeIxiaie[]i5Returns a list of all the valid indices in an array. indicesindices :: (IArray a e, Ix i) => a i e -> [i]IArrayaeIxiaie[]i5Returns a list of all the valid indices in an array. IArrayclass IArray a eClass of immutable array types. An array type has the form (a i e) where a is the array type constructor (kind * -> * -> *), i is the index type (a member of the class Ix), and e is the element type. The IArray class is parameterised over both a and e, so that instances specialised to certain element types can be defined. IArrayclass IArray a eClass of immutable array types. An array type has the form (a i e) where a is the array type constructor (kind * -> * -> *), i is the index type (a member of the class Ix), and e is the element type. The IArray class is parameterised over both a and e, so that instances specialised to certain element types can be defined.  hPutArray  hPutArray :: Handle -> IOUArray Int Word8 -> Int -> IO ()3HandleIOUArrayIntWord8IntIO()@Writes an array of Word8 to the specified Handle.  hGetArray  hGetArray :: Handle -> IOUArray Int Word8 -> Int -> IO Int"HandleIOUArrayIntWord8IntIOIntYReads a number of Word8s from the specified Handle directly into an array. getNumElementsgetNumElements :: (MArray a e m, Ix i) => a i e -> m IntMArrayaemIxiaiemIntgetElemsgetElems :: (MArray a e m, Ix i) => a i e -> m [e]MArrayaemIxiaiem[]e5Return a list of all the elements of a mutable array getElemsgetElems :: (MArray a e m, Ix i) => a i e -> m [e]QMArrayaemIxiaiem[]e5Return a list of all the elements of a mutable array  getBounds getBounds :: (MArray a e m, Ix i) => a i e -> m (i, i)b&MArrayaemIxiaiem(,)ii Returns the bounds of the array  getBounds getBounds :: (MArray a e m, Ix i) => a i e -> m (i, i)&MArrayaemIxiaiem(,)ii getBounds getBounds :: (MArray a e m, Ix i) => a i e -> m (i, i)MArrayaemIxiaiem(,)ii getAssocs getAssocs :: (MArray a e m, Ix i) => a i e ->  m [(i, e)]v4MArrayaemIxiaiem[](,)ieJReturn a list of all the associations of a mutable array, in index order.  getAssocs getAssocs :: (MArray a e m, Ix i) => a i e ->  m [(i, e)]l*MArrayaemIxiaiem[](,)ieJReturn a list of all the associations of a mutable array, in index order. freezeSTUArrayfreezeSTUArray :: Ix i => STUArray s i e -> ST s (UArray i e)d*IxiSTUArraysieSTsUArrayiefreezefreeze :: $(Ix i, MArray a e m, IArray b e) => a i e ->  m (b i e)IxiMArrayaemIArraybeaiembieConverts a mutable array (any instance of MArray) to an immutable array (any instance of IArray) by taking a complete copy of it. freezefreeze :: $(Ix i, MArray a e m, IArray b e) => a i e ->  m (b i e)fIxiMArrayaemIArraybeaiembieConverts a mutable array (any instance of MArray) to an immutable array (any instance of IArray) by taking a complete copy of it. eqUArrayeqUArray :: !(IArray UArray e, Ix i, Eq e) =>  UArray i e ->  UArray i e -> Bool|IArrayUArrayeIxiEqeUArrayieUArrayieBoolelemselems :: (IArray a e, Ix i) => a i e -> [e]U%IArrayaeIxiaie[]eTReturns a list of all the elements of an array, in the same order as their indices. elemselems :: (IArray a e, Ix i) => a i e -> [e]2  IArrayaeIxiaie[]eTReturns a list of all the elements of an array, in the same order as their indices.  DiffUArraytype  DiffUArray = IOToDiffArray IOUArray Strict unboxed diff array, working only for elements of primitive types but more compact and usually faster than DiffArray.  DiffArraytype  DiffArray = IOToDiffArray IOArray )Fully polymorphic lazy boxed diff array.  cmpUArray cmpUArray :: "(IArray UArray e, Ix i, Ord e) =>  UArray i e ->  UArray i e -> Ordering b IArrayUArrayeIxiOrdeUArrayieUArrayieOrdering cmpIntUArray cmpIntUArray :: (IArray UArray e, Ord e) =>  UArray Int e ->  UArray Int e -> Ordering H IArrayUArrayeOrdeUArrayInteUArrayInteOrdering castSTUArray castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)>  STUArraysixaSTsSTUArraysixbCasts an STUArray with one element type into one with a different element type. All the elements of the resulting array are undefined (unless you know what you're doing...).  castSTUArray castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)aSTUArraysixaSTsSTUArraysixbCasts an STUArray with one element type into one with a different element type. All the elements of the resulting array are undefined (unless you know what you're doing...).  castIOUArray castIOUArray ::  IOUArray ix a -> IO (IOUArray ix b)IOUArrayixaIOIOUArrayixbCasts an IOUArray with one element type into one with a different element type. All the elements of the resulting array are undefined (unless you know what you're doing...). boundsbounds :: (IArray a e, Ix i) => a i e -> (i, i),IArrayaeIxiaie(,)ii*Extracts the bounds of an immutable array boundsbounds :: (IArray a e, Ix i) => a i e -> (i, i)IArrayaeIxiaie(,)iiboundsbounds :: (IArray a e, Ix i) => a i e -> (i, i)zFIArrayaeIxiaie(,)iibOOL_WORD_SCALEbOOL_WORD_SCALE :: Int# -> Int#Int#Int# bOOL_NOT_BIT bOOL_NOT_BIT :: Int# -> Word#B2Int#Word# bOOL_INDEX bOOL_INDEX :: Int# -> Int#Int#Int#assocsassocs :: (IArray a e, Ix i) => a i e -> [(i, e)]8IArrayaeIxiaie[](,)ie<Returns the contents of an array as a list of associations. assocsassocs :: (IArray a e, Ix i) => a i e -> [(i, e)]IArrayaeIxiaie[](,)ie<Returns the contents of an array as a list of associations.  arrEleBottom arrEleBottom :: aaarrayarray :: (IArray a e, Ix i) => (i, i) -> [(i, e)] -> a i eCIArrayaeIxi(,)ii[](,)ieaieConstructs an immutable array from a pair of bounds and a list of initial associations. The bounds are specified as a pair of the lowest and highest bounds in the array respectively. For example, a one-origin vector of length 10 has bounds (1,10), and a one-origin 10 by 10 matrix has bounds ((1,1),(10,10)). An association is a pair of the form (i,x), which defines the value of the array at index i to be x. The array is undefined if any index in the list is out of bounds. If any two associations in the list have the same index, the value at that index is implementation-dependent. (In GHC, the last value specified for that index is used. Other implementations will also do this for unboxed arrays, but Haskell 98 requires that for Array the value at such indices is bottom.) Because the indices must be checked for these errors, array is strict in the bounds argument and in the indices of the association list. Whether array is strict or non-strict in the elements depends on the array type: Data.Array.Array is a non-strict array type, but all of the Data.Array.Unboxed.UArray arrays are strict. Thus in a non-strict array, recurrences such as the following are possible: 
a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i \<- [2..100]])
Not every index within the bounds of the array need appear in the association list, but the values associated with indices that do not appear will be undefined. If, in any dimension, the lower bound is greater than the upper bound, then the array is legal, but empty. Indexing an empty array always gives an array-bounds error, but bounds still yields the bounds with which the array was constructed. arrayarray :: (IArray a e, Ix i) => (i, i) -> [(i, e)] -> a i ehIArrayaeIxi(,)ii[](,)ieaieConstructs an immutable array from a pair of bounds and a list of initial associations. The bounds are specified as a pair of the lowest and highest bounds in the array respectively. For example, a one-origin vector of length 10 has bounds (1,10), and a one-origin 10 by 10 matrix has bounds ((1,1),(10,10)). An association is a pair of the form (i,x), which defines the value of the array at index i to be x. The array is undefined if any index in the list is out of bounds. If any two associations in the list have the same index, the value at that index is implementation-dependent. (In GHC, the last value specified for that index is used. Other implementations will also do this for unboxed arrays, but Haskell 98 requires that for Array the value at such indices is bottom.) Because the indices must be checked for these errors, array is strict in the bounds argument and in the indices of the association list. Whether array is strict or non-strict in the elements depends on the array type: Data.Array.Array is a non-strict array type, but all of the Data.Array.Unboxed.UArray arrays are strict. Thus in a non-strict array, recurrences such as the following are possible: 
a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i \<- [2..100]])
Not every index within the bounds of the array need appear in the association list, but the values associated with indices that do not appear will be undefined. If, in any dimension, the lower bound is greater than the upper bound, then the array is legal, but empty. Indexing an empty array always gives an array-bounds error, but bounds still yields the bounds with which the array was constructed. amapamap :: #(IArray a e', IArray a e, Ix i) =>  (e' -> e) -> a i e' -> a i e-%$IArrayae'IArrayaeIxie'eaie'aiedReturns a new array derived from the original array by applying a function to each of the elements. amapamap :: #(IArray a e', IArray a e, Ix i) =>  (e' -> e) -> a i e' -> a i eZ& &IArrayae'IArrayaeIxie'eaie'aiedReturns a new array derived from the original array by applying a function to each of the elements.  accumArray accumArray :: (IArray a e, Ix i) => e -> e' -> e -> e -> (i, i) ->  [(i, e')] -> a i e'n'IArrayaeIxiee'ee(,)ii[](,)ie'aie*Constructs an immutable array from a list of associations. Unlike array, the same index is allowed to occur multiple times in the list of associations; an accumulating function is used to combine the values of elements with the same index. For example, given a list of values of some index type, hist produces a histogram of the number of occurrences of each index within a specified range: 
hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b
hist bnds is = accumArray (+) 0 bnds [(i, 1) | i\<-is, inRange bnds i]
 accumArray accumArray :: (IArray a e, Ix i) => e -> e' -> e -> e -> (i, i) ->  [(i, e')] -> a i e**IArrayaeIxiee'ee(,)ii[](,)ie'aie*Constructs an immutable array from a list of associations. Unlike array, the same index is allowed to occur multiple times in the list of associations; an accumulating function is used to combine the values of elements with the same index. For example, given a list of values of some index type, hist produces a histogram of the number of occurrences of each index within a specified range: 
hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b
hist bnds is = accumArray (+) 0 bnds [(i, 1) | i\<-is, inRange bnds i]
accum accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e ->  [(i, e')] -> a i e--IArrayaeIxiee'eaie[](,)ie'aieaccum f takes an array and an association list and accumulates pairs from the list into the array with the accumulating function f. Thus accumArray can be defined using accum: 
accumArray f z b = accum f (array b [(i, z) | i \<- range b])
accum accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e ->  [(i, e')] -> a i e//IArrayaeIxiee'eaie[](,)ie'aieaccum f takes an array and an association list and accumulates pairs from the list into the array with the accumulating function f. Thus accumArray can be defined using accum: 
accumArray f z b = accum f (array b [(i, z) | i \<- range b])
// (//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e11IArrayaeIxiaie[](,)ieaie^Takes an array and a list of pairs and returns an array identical to the left argument except that it has been updated by the associations in the right argument. For example, if m is a 1-origin, n by n matrix, then m//[((i,i), 0) | i <- [1..n]] is the same matrix, except with the diagonal zeroed. As with the array function, if any two associations in the list have the same index, the value at that index is implementation-dependent. (In GHC, the last value specified for that index is used. Other implementations will also do this for unboxed arrays, but Haskell 98 requires that for Array the value at such indices is bottom.) For most array types, this operation is O(n) where n is the size of the array. However, the Data.Array.Diff.DiffArray type provides this operation with complexity linear in the number of updates. // (//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e55IArrayaeIxiaie[](,)ieaie^Takes an array and a list of pairs and returns an array identical to the left argument except that it has been updated by the associations in the right argument. For example, if m is a 1-origin, n by n matrix, then m//[((i,i), 0) | i <- [1..n]] is the same matrix, except with the diagonal zeroed. As with the array function, if any two associations in the list have the same index, the value at that index is implementation-dependent. (In GHC, the last value specified for that index is used. Other implementations will also do this for unboxed arrays, but Haskell 98 requires that for Array the value at such indices is bottom.) For most array types, this operation is O(n) where n is the size of the array. However, the Data.Array.Diff.DiffArray type provides this operation with complexity linear in the number of updates. ! (!) :: (IArray a e, Ix i) => a i e -> i -> e99IArrayaeIxiaieieBReturns the element of an immutable array at the specified index. ! (!) :: (IArray a e, Ix i) => a i e -> i -> e:i:IArrayaeIxiaieieBReturns the element of an immutable array at the specified index. Unboxedmodule Data.Array.Unboxed;Unboxed immutable arrays. Storablemodule Data.Array.Storablej;sA storable array is an IO-mutable array which stores its contents in a contiguous memory block living in the C heap. Elements are stored according to the class Storable. You can obtain the pointer to the array contents to manipulate elements from languages like C. It is similar to Data.Array.IO.IOUArray but slower. Its advantage is that it's compatible with C. STmodule Data.Array.ST=9Mutable boxed and unboxed arrays in the ST monad. MArraymodule Data.Array.MArray=An overloaded interface to mutable arrays. For array types which can be used with this interface, see Data.Array.IO, Data.Array.ST, and Data.Array.Storable. IOmodule Data.Array.IOc>2Mutable boxed and unboxed arrays in the IO monad. IArraymodule Data.Array.IArray>Immutable arrays, with an overloaded interface. For array types which can be used with this interface, see the Array type exported by this module, and the Data.Array.Unboxed and Data.Array.Diff modules. Diffmodule Data.Array.Diff?-Functional arrays with constant-time update. Basemodule Data.Array.BaseE@bBasis for IArray and MArray. Not intended for external consumption; use IArray or MArray instead. arraypackage array@Mutable and immutable arrays This package defines the classes IArray of immutable arrays and MArray of arrays mutable within appropriate monads, as well as some instances of these classes. Arraymodule Data.ArrayABasic non-strict arrays. Note: The Data.Array.IArray module provides more general interface to immutable arrays: it defines operations with the same names as those defined below, but with more general types, and also defines Array instances of the relevant classes. To use that more general interface, import Data.Array.IArray but not Data.Array.  DCCCCCCC|CDataArrayUnboxedDataArrayStorableDataArraySTDataArrayMArrayDataArrayIODataArrayIArrayDataArrayDiffDataArrayBaseDataArrayDarray0.1.0.0Chttp://hackage.haskell.org/packages/archive/array/0.1.0.0/doc/html/@http://hackage.haskell.org/cgi-bin/hackage-scripts/package/array