HOOG{et!/_ a  ').05b)*--/044c %%--d  !!#%//e %)*--/5f !!$%03g00h,-24i !"$%0035l ""%%)*--0044m n"&'/3o)*--/034p%%00r ')+-.0135s  ""&+--04t  ""&-0025u  &'++-3w",,25x//y  '*+-.0035z11njgIKOf()->AllAny BlockReasonBooldCCharCClockCDevCDouble_CFloatCInoCIntvCIntMax.CIntPtrCLDoubleCLLongECLongCModeCOffmCPid%CPtrdiffCSCharCShortM CSigAtomicCSizeCSsizeuCTimeCCUCharCUIntCUIntMaxkCUIntPtr#CULLongCULongCUShortKCWcharChanCharComplex ConsoleEventConstr ConstrRepDataRepDataTypemDoubleFDynamic-E12E6EitherErrno ExceptionFdFixityFloatlGeneralCategoryJHandleDHashData;IOIOUArrayIdInsertsIntTInt16-Int32Int64 Int8 IntPtrp IntegerX LexemeO Maybe NestedAtomically NoMethodError NonTermination Ordering P PatternMatchFail{ QSemq QSemNg ReadPN ReadPrec5 RecConError RecSelError RecUpdError STM StableName TVar ThreadId ThreadStatus Timeoutw TyConq TypeRepk Uniquec VersionH Word! Word16 Word32 Word64 Word8 WordPtr= ZipList( [::] []  TraversableFoldable Applicative AlternativeMonadFix MonadPlusFunctorMonadFunctor Applicative ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableEqOrdShowReadTypeableOrdEqDataDataTypeableShow ExceptionEqShowOrdEqShowEqOrdTypeableData Typeable1 Typeable1 Typeable1FunctorMonadTypeableShow ExceptionTypeableShow ExceptionTypeableShow ExceptionFunctorMonad MonadPlusFunctorMonad MonadPlusTypeableTypeableTypeableShow ExceptionMonad MonadPlusMonoidDataIxTypeableShow ExceptionTypeableShow ExceptionTypeableShow Exception TraversableFoldable Applicative AlternativeMonadFix MonadPlusFunctorMonadShowEq PrintfArgDataBitsIx ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableIArrayMArray PrintfArgDataStorableBitsIxEqFunctor Applicative Typeable2MArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArrayMArray ApplicativeMonadFixShowEqDataIxBoundedShowReadEnumOrdEqIArrayMArray PrintfArgDataStorableShowEq ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqTypeable ExceptionShowEqEq Typeable2 HasResolution HasResolution ExceptionTypeableShowIArrayMArray PrintfArgDataStorableShowTypeableDataShowEqShowEqShowEqReadShowEnumOrdEqTypeable Typeable1IArrayMArray PrintfArgIsCharDataStorableIx 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 ReadShowTypeableBitsIntegralBoundedRealStorableEnumNumOrdEqIArrayMArrayDataStorableIxShowOrdEqMonoidBoundedShowReadOrdEqMonoidBoundedShowReadOrdEqArrow ArrowChoice ArrowApply ArrowLoopCategoryMonoidDataEqOrdIx$ ByteCountACString2 CStringLenCWString CWStringLen ClockTickConIndexDeviceID DiffArray DiffUArray EpochTimeFileIDFileMode FileOffsetFilePathsFinalizerEnvPtr@ FinalizerPtrGeneric GenericB GenericMGenericQGenericRGenericTIOErrorIPrLimitMicroPicoPrecProcessGroupID ProcessIDRationalnReadSA SampleVarShowSString[]Char[]Char[]CharaMVar(,)IntMVaraa[]Char[](,)a[]CharRatioIntegerCPidCPidIntFixedE12FixedE6CLong(,)IntInt IOExceptionaammararmamaacacaaFunPtrPtraIO()envaFunPtrPtrenvPtraIO()[]CharCOffCModeCInoCTime IOToDiffArrayIOUArray IOToDiffArrayIOArrayCDevIntCClock(,)PtrCWcharIntPtrCWchar(,)PtrCCharIntPtrCCharCSize(mg[9gaabr]cSdOeLfHgFh,Ei?j?k?l<m9n7o^4p1q0r,sT'tW#uo!v4!wziplistZipList#*!e!oR ra`i*t1e8m?oFdMeTIOModepga$ mpxedamonad WrappedMonadrrow WrappedArrowon a d  WrappedMonadr+ r2 o9 w@  WrappedArrowrY d` Word# 1 3 6 8 p t r WordPtrWord84 Word642 Word326 Word16Word#a!k!WeakWorde;!rB!sI!iP!oW!n^!Versiona+#nV"p!s!e!r!i!n!t!e!r!r!u!p!t!AsyncExceptionp!e!r!c"a "s"e"l"e%"t,"t3"e:"rA"GeneralCategoryd"ib"qi"up"ew"Uniquee"f"r"f"l"o"w"ArithExceptioni"n"e"d"e"l"e"m#e #n#t#ArrayExceptionr2#r9#a@#yG#UArrayh%i %r$v$yr#c$p~#e#a#r#e#p#TypeRepb#l#e#Typeable1l$2Y$3F$43$5 $6 $7# Typeable7 Typeable6 Typeable5 Typeable4 Typeable3 Typeable2 Typeable1o$n$TyCona$r$TVar#$TVar#a$v$e$r$s$a$b$l%e % Traversablet'%l.%e5%c<%aC%sJ%eQ%lX%e_%tf%tm%et%r{%GeneralCategoryr%e%a%d%b'd&f&i}&kF&r &s%t%a%t%u%s% ThreadStatusu&n&n&i&&n-&g4& ThreadStatusiM&lT&l[&eb&di&AsyncExceptiond&ThreadId#& ThreadId#i&n&i&s&h&e&d& ThreadStatusi&e&d' ThreadStatusl'o&'c-'k4'e;'dB' ThreadStatusa,e ,h+o;+p*t'u'y~'m'b'o'l'Lexemem'r'r'o'g'a't'e'GeneralCategorySumSTa})mp)o)rX(u#(a*(r1(r8(a?(yF(STUArraye(id(nk(gr(Stringc(r(e(p(DataRepo(n(s(t(r( ConstrRepf(p(STRepSTRefr )a)b)l)e&)Storablea=)rD)rK)aR)yY) StorableArraySTMb**c)r)t)e)#)State#r)a)y)STArrayk)o)v)e)r)f*l*o*w*AsyncExceptionl1*e8*ne*pD*tK*rR* StablePtral*ms*ez* StableNamea*c*e&+i*n*g*c*o*m*b*i*n*i*n*g*m*a+r +k+GeneralCategoryGeneralCategorymB+eI+eP+xW+c^+ee+pl+ts+iz+o+n+ SomeExceptiono+u+t+d+o+w+n+ ConsoleEventw+Shows+ShowSe,k,fJ,m#,o*,d1,e8,SeekModerQ,oX,m_,ef,nm,dt,SeekModem,p,l,e,v,a,r, SampleVarav0e,i,g,h,t,Eithera/c".l-qg-t-u-r!-n(-i/-n6-o=-rD-dK-eR-rY-ArgOrdera-us-iz-r-e-o-r-d-e-r-ArgOrderr-g-ArgDescra-t-i-v-e-s-e.e .k.SeekModec.sy.u3.p:.dA.eH.rO.rV.o].rd. RecUpdErrore.l.e.r.r.o.r. RecSelErroro.n.e.r.r.o.r. RecConErrord/l/RealfX/w)/o0/r7/l>/dE/ RealWorldl/rd/ak/cr/RealFraco/a/t/ RealFloatReadmU0p!0s0w/r/i/t/e/m/o/d/e0IOModeReadSReadPr50e<0cC0ReadPreco\0dc0ej0IOModet}0Lexemei0o0Ration0a0l0Rationals0e0m0QSemn0QSemNa_3e.3i3o2rS1t?1u%1n,1c31LexemerF1Ptre2i2od1c1dp1uw1c~1t1Producte1s1s1g1i1d1 ProcessIDr1o1u1p1i1d1ProcessGroupIDn^2v2a&2t-2e42u;2sB2eI2GeneralCategoryte2fl2a2tx2y2p2e2 PrintfTyper2g2 PrintfArgc2f2i2x2FixityPreco2l3Poolc3o 3Picor53m<3uC3tJ3eQ3ArgOrderr3tk3tr3ey3r3n3m3a3t3c3h3f3a3i3l3PatternMatchFaila3g3r3a3p4h 4s4e4p4a&4r-4a44t;4oB4rI4GeneralCategoryp'6r5t4vt4e{4r4f4l4o4w4ArithExceptionh4e4r4l5np5p5s4y4m4b4o4l5GeneralCategoryu5n#5c*5t15u85a?5tF5iM5oT5n[5GeneralCategoryuw5m~5b5e5r5GeneralCategorye5t5t5e5r5GeneralCategoryd5Orde5r6i6n6g6Orderinge6t36a6d`6iD6oK6nR6OptDescreg6sn6cu6r|6OptDescrr6g6ArgDescrn6p6u6n6c6t6u6a6t6i6o6n6GeneralCategoryek9o87u$7m+7NumaO9b9m8n7r7tX7a7hd7ik7nr7gy7Maybes7s7i7g7n7e7d7GeneralCategorye7p7DataRepsO8t7e7r7m8i 8n8a8t"8i)8o08n78NonTerminationpV8a]8cd8ik8nr8gy8m8a8r8k8GeneralCategorye8t8h8o8d8e8r8r8o8r8 NoMethodErroru9f9f9e#9r*9i19n89g?9 BufferModerV9g]9ArgDescrsr9ty9e9d9a9t9o9m9i9c9a9l9l9y9NestedAtomicallyaV<i2<o:u2:v:a :r:MVar##:MVar#t9:a@:bG:lN:eU:a:ba:yh:to:ev:a}:r:r:a:y:#:MutableByteArray#r:r:a:y:#: MutableArray#d;n;a+;o ;i;d;Monoidd2;Monadfs;pK;lR;uY;s`; MonadPlusiz;x;MonadFixi;f;i;e;r;l;s;y;m;b;o;l;GeneralCategorye<t<t<e<r<GeneralCategoryc9<r@<oG<Micror<t<yg<bn<eu<Maybeh<s<y<m<b<o<l<GeneralCategoryr<a<y<MArraya|?e>i>o=g=s=w=e=r$=c+=a2=s9=e@=lG=eN=tU=t\=ec=rj=GeneralCategorys=o=f=p=r=e=c=i=s=i=o=n=ArithExceptiono=f=f= ConsoleEventm>n>e!>bz>s->e4>p;>aB>rI>aP>tW>o^>re>GeneralCategoryu>f>f>e>r>i>n>g> BufferModei>t>Limitfi?t?x>e>m>e?Lexemet?e#?r*?n1?u8?m??bF?eM?rT?GeneralCategorytp?Eithers?t?Lastl?e?i?s?l?i?Kleisliu?s?t?MaybeaEdDgDnuBo@p@s)@x@Ixcj@s5@t<@rC@iJ@nQ@gX@IsStringhq@ax@r@IsCharr@IPrIOaHBeAm|Ar_AtAu@a@r@r@a@y@IOUArrayo AdAiAfAf%Aa,Ar3Ar:AaAAyHA IOToDiffArrayefAfmAIORefoAdAeAIOModerAxAcAeApAtAiAoAnA IOExceptionrAoBrBIOErrortBy%Bp,Be3B IOErrorTyperOBrVBa]BydBIOArraydGDf-DiCtBInt #C1C3C6C8{CcICeBpBrBeBpBDataReptBrBIntPtrgCe1CrCaClCIntegralr8CIntegeroPCnWCs^CteCrlC ConstrRepInt84CInt642CInt326CInt16Int#tCiCaClCqCuDo DtDeDGeneralCategoryi4Dx;DFixityeNDxUDo\DucDtjDoqDfxDbDoDuDnDdDsDArrayExceptionnDoDrDeDHandlereDnDtDLexemerErEaEyEIArrayaEeEp=ErDEiKEnREtYEf`EtgEynEpuEe|E HPrintfTypeaEpEoEvEeErEfElEoEwEAsyncExceptionnFsEhYFrFe FsFoFlFu&Ft-Fi4Fo;FnBF HasResolutiont`FagFbnFluFe|F HashTabledFlFeFHandlepFrFHandleroFsFnF HandlePosne;Gm,GqGtG GenericT' GenericQ' GenericM'nBGeIGrPGaFHi\GccGGeneric'4Hb"HmGqGrGtGGenericT'G GenericT'GenericRGenericQ'G GenericQ'GenericM'H GenericM'GenericBGeneric'lMHcTHa[HtbHeiHgpHowHr~HyHGeneralCategorydLiJlJoaIrIuHnHcHpHtHrHFunPtrtHoHrIFunctoraIc#It*Ii1Io8In?IaFIlMI FractionallIrmIeImyIaItIGeneralCategoryiIgInIpItIrI ForeignPtrdIaIbIlIeIFoldableoJaJt$JcpJiPJr5JeSpESDataReph]SpdSukSnrScyStSuSaStSiSoSnSGeneralCategorya]c\d\f\h[ik[j7[lYmYoWpWsDVt VuTw TcuTsTtTr&Ti-Tn4Tg;TCWStringlRTeYTn`T CWStringLenh|TaTrTCWcharcUiUlDUrTsThToTrTtTCUShortrTeTnTcTyUs UyUmUb!Uo(Ul/UGeneralCategorylnUoPUnWUg^UCULongouUn|UgUCULLongnUtUCUIntmUpUtUrUCUIntPtraUxUCUIntMaxhVa VrVCUChari'Vm.Ve5VCTimec]Wh8WiVsVt_VrfVimVntVg{VCStringlVeVnV CStringLeniVzVeVCSsizegVzVeVCSizeaWtWoWmWiWc$W CSigAtomico?WrFWtMWCShorthdWakWrrWCSChariWtWrWdWiWfWfWCPtrdiffdWCPidfYmYnWibYnXs@XtWrXo XlXGeneralCategoryc.X ConsoleEventoXtLXConstr`XConstrruXe|XpX ConstrReplXeXeXvXeXnXtX ConsoleEventeXcXtXoXrYpYuYnYcYt#Yu*Ya1Yt8Yi?YoFYnMYGeneralCategoryniYdpYewYx~YConIndexpYlYeYxYComplexfYCOffoYdYeYCModed[lZoZcZnZsZeZ ConsoleEventp6Zu=ZnDZcKZtRZuYZa`ZtgZinZouZn|ZGeneralCategorygZCLongkZtZiZcZkZ ClockTickoZnZgZCLLongo [u[b[l[e%[CLDoublem>[pE[bL[uS[fZ[CJmpBufnr[o[t~[CIntm[p[t[r[CIntPtra[x[CIntMaxCInoa[n\r[CharChanid\l?\p"\o)\s0\CFposoF\aM\tT\CFloatlk\er\CFilee\o\u\b\l\e\CDoublev\CDevh]l\o\c\k\CClocka]r]CChart$]c^]e0]g7]o>]rE]yL]Categoryhe]Handlerial^oI^r"^u]y]t]e]c]o]u]n]t] ByteCountf]f]e]r]m]o^d^e^ BufferModee)^a0^k7^ ConsoleEvento^uU^n\^dc^ej^dq^Boundedl^Boolo^c^k^bEae^r^e^a^s^o^n^ BlockReasond^i`o_n_b`dF`e_f_m_oS_s4_t;_mB_ BlockReasontZ_ha_eh_ro_ BlockReasonv_a_r_ BlockReasono_r_e_i_g_n_c_a_l_l_ BlockReasonx`c `e`p`t `i'`o.`n5` BlockReasoneM`aT`d[`mb`vi`ap`rw`BlockedOnDeadMVarl`a`c`k`h`o`l`e` BlockReasonn`d`e`f`i`nai ataeal!ay(aBlockedIndefinitelyuLafSafZaeaarhaioanvag}a BufferModetasaBitsbfdflenepZerbsas?byanacaeaxacaebp btbibo bn'bAsyncExceptioneFbrMbtTbi[bobbnibfpbawbi~blbebdbAssertionFailedgdidrba dobwbArrowacccl}cmMcp%czbecr coc ArrowZerol,cu3cs:c ArrowPlusoTcn[cabcdic ArrowMonadococpc ArrowLoophcocicccec ArrowChoicepcpclcyc ArrowApplyydArray#}de-dx4dc;deBdpIdtPdiWdo^dnedArrayExceptionArray#tdhdedxdcdedpdtdidodndArithExceptiond,eodred eeereArgOrdere3es:ecAerHeArgDescrpaeeelmeitec{eaeteieveee ApplicativenedemeoedeeeIOModeyeAnyghfl[ftfefrfn#fa*ft1fi8fv?feFf AlternativeAllcfrtfe{fpfDataRepofnfsftfrf ConstrRepdfrf#fAddr#sfoflfugtgegsgege$gk+gSeekMode:Qg]Eg[]:Xg]_g[::])tg()gj{jieihh hgeeiArray eiIOUArrayeiUArray eia$#"ii(,)bixsSTUArraysST()IO ()mIntIO!aIOeIO e[]emi[]eia IOToDiffArrayIO bixIOUArrayIO ei(,)[]ei StorableArrayIOeiam%eibmeixIOUArrayIOii(,)me[]mei(,)[]mj nQn nvllkzkHk+kee'e#"ee'%$jiaIOePtrHandle! Int!  e#iaixsSTUArrayei RealWorldSTUArrayeia IOToDiffArray Word8IntIOUArray! aixIOUArray ei StorableArrayeia"eixUArrayejae'ia%$ii(,) #eisSTArraysST eisSTUArraysST e ForeignPtre[]eInt(,)[] ei(,)[]e'i(,)[]#"%Ct!tsss~sWs'ssrrrrrrrrxrgrEr#rrqqqgqzfreezeelemsUzelems diffuarraypz DiffUArray diffarrayz DiffArraydiffzDiff caststuarrayz castSTUArray castiouarrayz castIOUArray9bounds {boundsassocs"{assocsarray9{Arrayarrayamap]{amap accumarrayw{ accumArray accum{accum //{// !{! <,tonAջm!ƷMwQ[߰#a4cQY2`FY6Ӏ}f}|unsafeThawIOUArrayunsafeThawIOUArray ::  Ix ix =>  UArray ix e -> IO (IOUArray ix e)b}+}IxixUArrayixeIOIOUArrayixeIOUArrayIOUArray :: STUArray RealWorld i e ->  IOUArray i e}}STUArray RealWorldieIOUArrayieIOUArraynewtype IOUArray i e2~QMutable, unboxed, strict arrays in the IO monad. The type arguments are as follows:  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...).  writeArray  writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m ()OMArrayaemIxiaieiem()$Write an element in a mutable array withStorableArraywithStorableArray :: StorableArray i e -> (Ptr e -> IO a) -> IO ag/ 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.  unsafeThaw unsafeThaw :: $(Ix i, IArray a e, MArray b e m) => a i e ->  m (b i e)EIxiIArrayaeMArraybemaiembieConverts an immutable array into a mutable array. The implementation may either simply cast the array from one type to the other without copying the array, or it may take a full copy of the array. Note that because the array is possibly not copied, any subsequent modifications made to the mutable version of the array may be shared with the immutable version. It is only safe to use, therefore, if the immutable array is never referenced again in this thread, and there is no possibility that it can be also referenced in another thread. If you use an unsafeThawwriteunsafeFreeze sequence in a multi-threaded setting, then you must ensure that this sequence is atomic with respect to other threads, or a garbage collector crash may result (because the write may be writing to a frozen array). The non-copying implementation is supported between certain pairs of array types only; one constraint is that the array types must have identical representations. In GHC, The following pairs of array types have a non-copying O(1) implementation of unsafeThaw. Because the optimised versions are enabled by specialisations, you will need to compile with optimisation (-O) to get them.  unsafeFreeze unsafeFreeze :: $(Ix i, MArray a e m, IArray b e) => a i e ->  m (b i e)bIxiMArrayaemIArraybeaiembiePConverts an mutable array into an immutable array. The implementation may either simply cast the array from one type to the other without copying the array, or it may take a full copy of the array. Note that because the array is possibly not copied, any subsequent modifications made to the mutable version of the array may be shared with the immutable version. It is safe to use, therefore, if the mutable version is never modified after the freeze operation. The non-copying implementation is supported between certain pairs of array types only; one constraint is that the array types must have identical representations. In GHC, The following pairs of array types have a non-copying O(1) implementation of unsafeFreeze. Because the optimised versions are enabled by specialisations, you will need to compile with optimisation (-O) to get them. unsafeForeignPtrToStorableArrayunsafeForeignPtrToStorableArray :: Ix i =>  ForeignPtr e -> (i, i) -> IO (StorableArray i e)Ixi 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. UArraydata 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 () 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. thawthaw :: $(Ix i, IArray a e, MArray b e m) => a i e ->  m (b i e) IxiIArrayaeMArraybemaiembieConverts 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 e֖A mutable array with unboxed elements, that can be manipulated in the ST monad. The type arguments are as follows: 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 eԙThe array type  runSTUArray runSTUArray :: Ix i => ST s (STUArray s i e) ->  UArray i eQIxiSTsSTUArraysieUArrayieA 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 e<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)\MArrayaeIOIxi IOToDiffArrayaie[](,)InteIO IOToDiffArrayaie readDiffArray readDiffArray :: (MArray a e IO, Ix i) => IOToDiffArray a i e -> Int -> IO e.MArrayaeIOIxi IOToDiffArrayaieIntIOe readArray readArray :: (MArray a e m, Ix i) => a i e -> i -> m eӟMArrayaemIxiaieime%Read an element from a mutable array  newListArray newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] ->  m (a i e)wMArrayaemIxi(,)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)MMArrayaeIOIxi(,)ii[](,)InteIO IOToDiffArrayaie 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)hMArrayaemIxi(,)iiemaieMArrayclass  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)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)CMArrayae'mMArrayaemIxie'eaie'maiegConstructs a new array derived from the original array by applying a function to each of the elements.  listArray listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i eZIArrayaeIxi(,)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 eͪ}IArrayaeIxiIxj(,)iiijajeaiecReturns a new array derived from the original array by applying a function to each of the indices. IOUArraydata IOUArray i ehQMutable, unboxed, strict arrays in the IO monad. The type arguments are as follows:  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. IArrayclass IArray a eTClass 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 ()iHandleIOUArrayIntWord8IntIO()@Writes an array of Word8 to the specified Handle.  hGetArray  hGetArray :: Handle -> IOUArray Int Word8 -> Int -> IO IntWHandleIOUArrayIntWord8IntIOIntYReads a number of Word8s from the specified Handle directly into an array. getElemsgetElems :: (MArray a e m, Ix i) => a i e -> m [e]~FMArrayaemIxiaiem[]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)WMArrayaemIxiaiem(,)ii getAssocs getAssocs :: (MArray a e m, Ix i) => a i e ->  m [(i, e)]MArrayaemIxiaiem[](,)ieJReturn a list of all the associations of a mutable array, in index order. freezefreeze :: $(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. elemselems :: (IArray a e, Ix i) => a i e -> [e]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.  castSTUArray castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)h0STUArraysixaSTsSTUArraysixbCasts 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(,)iiassocsassocs :: (IArray a e, Ix i) => a i e -> [(i, e)][IArrayaeIxiaie[](,)ie<Returns the contents of an array as a list of associations. arrayarray :: (IArray a e, Ix i) => (i, i) -> [(i, e)] -> a i eAIArrayaeIxi(,)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 eIArrayae'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 ec 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 eiIArrayaeIxiee'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 e<IArrayaeIxiaie[](,)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)IArrayaeIxiaieieBReturns the element of an immutable array at the specified index. Unboxedmodule Data.Array.UnboxedUnboxed immutable arrays. Storablemodule Data.Array.StorablesA 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.ST9Mutable boxed and unboxed arrays in the ST monad. MArraymodule Data.Array.MArrayAn 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.IO2Mutable boxed and unboxed arrays in the IO monad.  Internalsmodule Data.Array.IO. Internalsj2Mutable boxed and unboxed arrays in the IO monad. IArraymodule Data.Array.IArrayImmutable 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. 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 a 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. rYF7&DataArrayUnboxedDataArrayStorableDataArraySTDataArrayDiffDataArrayIODataArrayMArrayDataArrayIO InternalsDataArrayIArrayDataArrayarray0.2.0.0Chttp://hackage.haskell.org/packages/archive/array/0.2.0.0/doc/html/@http://hackage.haskell.org/cgi-bin/hackage-scripts/package/array