|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi j k l m n o p q r s t u v w x y z {  Safe||| NoneAT }Vector is a part of a buffer.~This simulates a 2 data StrictList a = Elem !a (StrictList a) | End # by an array and some unsafe hacks.Cf. StreamFusion Data.Stream!Wrapper of mallocForeignPtrArray. * unfoldrNTerm 20 (n -> Just (n, succ n)) a^This is expensive and should not be used to construct lists iteratively! A recursion-enabling  would be consNr that allocates a buffer of given size, initializes the leading cell and sets the buffer pointer to the next cell.evaluate next value in a buffer*evaluate all values up to a given positionO(n)" Converts a 'Vector a' to a '[a]'.kFor the sake of laziness it may allocate considerably more memory than needed, if it filters out very much.&}~}}~None0BTA space-efficient representation of a vector, supporting many efficient operations.0Instances of Eq, Ord, Read, Show, Data, Typeable A variety of  for non-empty Vectors.  omits the check for the empty case, so there is an obligation on the programmer to provide a proof that the Vector is non-empty. A variety of  for non-empty Vectors. . omits the check for the empty case. As with M, the programmer must provide a separate proof that the Vector is non-empty. A variety of  for non-empty Vectors.  omits the check for the empty case, so there is an obligation on the programmer to provide a proof that the Vector is non-empty. A variety of  for non-empty Vectors. . omits the check for the empty case. As with M, the programmer must provide a separate proof that the Vector is non-empty.Unsafe  index (subscript) operator, starting from 0, returning a single element. This omits the bounds check, which means there is an accompanying obligation on the programmer to ensure the bounds are checked in some other way. A variety of  which omits the checks on nF so there is an obligation on the programmer to provide a proof that  0 <= n <=  xs. A variety of  which omits the checks on nF so there is an obligation on the programmer to provide a proof that  0 <= n <=  xs. O(1)! Build a Vector from a ForeignPtr O(1)' Deconstruct a ForeignPtr from a Vector RRun an action that is initialized with a pointer to the first element to be used. 4A way of creating Vectors outside the IO monad. The Int7 argument gives the final size of the Vector. Unlike R the Vector is not reallocated if the final size is less than the estimated size.!Wrapper of mallocForeignPtrArray.hGiven the maximum size needed and a function to make the contents of a Vector, createAndTrim makes the . The generating function is required to return the actual final size (<= the maximum size), and the resulting byte array is realloced to this size.createAndTrim is the main mechanism for creating custom, efficient Vector functions, using Haskell or C functions to fill the space.wJust like Unsafe.performIO, but we inline it. Big performance gains as it exposes lots of things to further inlining.  Very unsafe@. In particular, you should do no memory allocation inside an  block. On Hugs this is just Unsafe.performIO.    None*We might have name the data type iterator.  BSD-stylehaskell@henning-thielemann.de experimentalportable, requires ffiNone!Wrapper of mallocForeignPtrArray.None_O(n) Equality on the  type.O(1) The empty O(1) Construct a  containing a single element O(n)# Convert a '[a]' into a 'Vector a'.!O(n) Convert first n' elements of a '[a]' into a 'Vector a'."O(n)" Converts a 'Vector a' to a '[a]'.#O(n) Convert a list into a  using a conversion function$O(n) Convert a ( into a list using a conversion function%O(1) Test whether a  is empty.&O(1) & returns the length of a  as an .'O(n) 'V is analogous to (:) for lists, but of different complexity, as it requires a memcpy.(O(n)# Append an element to the end of a )O(1) Extract the first element of a C, which must be non-empty. It is a checked error to pass an empty .*O(1)* Extract the elements after the head of a C, which must be non-empty. It is a checked error to pass an empty .+O(1) Extract the last element of a N, which must be finite and non-empty. It is a checked error to pass an empty .,O(1) Return all the elements of a > except the last one. It is a checked error to pass an empty .-O(n) Append two Vectors.O(n) . f xs is the  obtained by applying f to each element of xs./O(n) / xs% efficiently returns the elements of xs in reverse order.0O(n) The 0! function takes a element and a > and `intersperses' that element between the elements of the 9. It is analogous to the intersperse function on Lists.1The 12 function transposes the rows and columns of its  argument.22|, applied to a binary operator, a starting value (typically the left-identity of the operator), and a Vector, reduces the / using the binary operator, from left to right.3 'foldl\'' is like 2 , but strict in the accumulator.44h, applied to a binary operator, a starting value (typically the right-identity of the operator), and a , reduces the P using the binary operator, from right to left. However, it is not the same as 2+ applied to the reversed vector. Actually 4s starts processing with the first element, and thus can be used for efficiently building a singly linked list by foldr (:) [] vec. Unfortunately 4U is quite slow for low-level loops, since GHC (up to 6.12.1) cannot detect the loop.55 is a variant of 2M that has no starting value argument, and thus must be applied to non-empty +s. It is a checked error to pass an empty .6 'foldl1\'' is like 5I, but strict in the accumulator. It is a checked error to pass an empty .77 is a variant of 4M that has no starting value argument, and thus must be applied to non-empty *s It is a checked error to pass an empty .8O(n) Concatenate a list of s.9Map a function over a  and concatenate the results: This is like mconcat . map f#, but in many cases the result of f will not be storable.<O(n) Applied to a predicate and a , <# determines if any element of the  satisfies the predicate.=O(n) Applied to a predicate and a , =$ determines if all elements of the  satisfy the predicate.>O(n) >" returns the maximum value from a C This function will fuse. It is a checked error to pass an empty .?O(n) ?" returns the minimum value from a C This function will fuse. It is a checked error to pass an empty .DThe D( function behaves like a combination of . and 2-; it applies a function to each element of a , passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.EThe E( function behaves like a combination of . and 4-; it applies a function to each element of a , passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new .HO(n)8 map functions, provided with the index at each positionII is similar to 2Z, but returns a list of successive reduced values from the left. This function will fuse. @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.JJ is a variant of I? that has no starting value argument. This function will fuse. .scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]K)scanr is the right-to-left dual of scanl.LL is a variant of K% that has no starting value argument.MO(n) M n x is a  of length n with x the value of every element.NO(n) N n f x is a  of length n where the elements of x* are generated by repeated application of f.OO(n), where n# is the length of the result. The O0 function is analogous to the List 'unfoldr'. O builds a A from a seed value. The function takes the element and returns 1 if it is done producing the 'Vector or returns  (a,b), in which case, a is the next element in the , and b* is the seed value for further production. Examples: [ unfoldr (\x -> if x <= 5 then Just (x, x + 1) else Nothing) 0 == pack [0, 1, 2, 3, 4, 5]PO(n) Like O, P builds a ] from a seed value. However, the length of the result is limited by the first argument to P(. This function is more efficient than O1 when the maximum length of the result is known.The following equation relates P and O: ,fst (unfoldrN n f s) == take n (unfoldr f s)QO(n) Like P this function builds a  from a seed value with limited size. Additionally it returns a value, that depends on the state, but is not necessarily the state itself. If end of vector and end of the generator coincide, then the result is as if only the end of vector is reached.Example: UunfoldrResultN 30 Char.ord (\c -> if c>'z' then Left 1000 else Right (c, succ c)) 'a'The following equation relates P and Q: SunfoldrN n f s == unfoldrResultN n Just (maybe (Left Nothing) Right . f) sIt is not possible to express Q in terms of P.RO(n), where n is the length of the result. This function constructs a vector by evaluating a function that depends on the element index. It is a special case of P& and can in principle be parallelized. Examples: H sample 26 (\x -> chr(ord 'a'+x)) == pack "abcdefghijklmnopqrstuvwxyz"SO(1) S n, applied to a  xs, returns the prefix of xs of length n, or xs itself if n > & xs.TO(1) T n xs returns the suffix of xs after the first n elements, or  if n > & xs.UO(1) U n xs is equivalent to (S n xs, T n xs).VV n xs" divides vector in chunks of size n>. Requires time proportionally to length of result list, i.e. ceiling (length xs / n). WW, applied to a predicate p and a  xs2, returns the longest prefix (possibly empty) of xs of elements that satisfy p.XX p xs$ returns the suffix remaining after W p xs.YY p is equivalent to [ ( . p).ZZ behaves like Y but from the end of the breakEnd p == spanEnd (not.p)[[ p xs breaks the ) into two segments. It is equivalent to (W p xs, X p xs)\\ behaves like [ but from the end of the  . We have -spanEnd (not.isSpace) "x y z" == ("x y ","z")and fspanEnd (not . isSpace) ps == let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x)]O(n) Splits a  into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg. TsplitWith (=='a') "aabbaca" == ["","","bb","c",""] splitWith (=='a') [] == []^O(n) Break a F into pieces separated by the argument, consuming the delimiter. I.e. {split '\n' "a\nb\nd\ne" == ["a","b","d","e"] split 'a' "aXaXaXa" == ["","X","X","X"] split 'x' "x" == ["",""]and 2join [c] . split c == id split == splitWith . (==)tAs for all splitting functions in this library, this function does not copy the substrings, it just constructs new #s that are slices of the original._Like ]V, except that sequences of adjacent separators are treated as a single separator. eg. &tokens (=='a') "aabbaca" == ["bb","c"]`The ` function takes a  and returns a list of s such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example, :group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]It is a special case of a_, which allows the programmer to supply their own equality test. It is about 40% faster than  groupBy (==)aThe a+ function is the non-overloaded version of `.bO(n) The b function takes a  and a list of es and concatenates the list after interspersing the first argument between each element of the list.cO(1) - index (subscript) operator, starting from 0.dO(n) The d? function returns the index of the first element in the given * which is equal to the query element, or  if there is no such element.eO(n) The e> function returns the last index of the element in the given * which is equal to the query element, or 3 if there is no such element. The following holds: HelemIndexEnd c xs == (-) (length xs - 1) `fmap` elemIndex c (reverse xs)fO(n) The f function extends d[, by returning the indices of all elements equal to the query element, in ascending order.g>count returns the number of times its argument appears in the  count = length . elemIndices@But more efficiently than using length on the intermediate list.hThe h" function takes a predicate and a 4 and returns the index of the first element in the  satisfying the predicate.iThe i function extends hY, by returning the indices of all elements satisfying the predicate, in ascending order.jjo is a variant of findIndex, that returns the length of the string if no element is found, rather than Nothing.kO(n) k is the  membership predicate.lO(n) l is the inverse of kmO(n) m, applied to a predicate and a  , returns a 6 containing those elements that satisfy the predicate.nO(n) The n" function takes a predicate and a ?, and returns the first element in matching the predicate, or  if there is no such element. Ffind f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> NothingoO(n) The o function takes two  and returns * iff the first is a prefix of the second.pO(n) The p function takes two s and returns * iff the first is a suffix of the second.The following holds: 2isSuffixOf x y == reverse x `isPrefixOf` reverse yqO(n) q takes two Gs and returns a list of corresponding pairs of elements. If one input * is short, excess elements of the longer 1 are discarded. This is equivalent to a pair of " operations.rr generalises qj by zipping with the function given as the first argument, instead of a tupling function. For example, r (+) is applied to two -s to produce the list of corresponding sums.sLike r but for three input vectorstLike r but for four input vectors If you need even more input vectors, you might write a function yourselve using unfoldrN and viewL.uO(n) u8 transforms a list of pairs of elements into a pair of s. Note that this performs two   operations.vO(ln)/ v selects every n th element.wO(n)? Returns n sieved vectors with successive starting elements. deinterleave 3 (pack ['a'..'k'+]) = [pack "adgj", pack "behk", pack "cfi"] This is the same as .xO(n)e Almost the inverse of deinterleave. Restriction is that all input vector must have equal length. ;interleave [pack "adgj", pack "behk", pack "cfil"] = pack ['a'..'l']yO(n)* Return all initial segments of the given , shortest first.zO(n)( Return all final segments of the given , longest first.{O(n) Make a copy of the c with its own storage. This is mainly useful to allow the rest of the data pointed to by the  to be garbage collected, for example if a large string has been read in, and only a small part of it is needed in the rest of the program.|Write a ! to a contiguous piece of memory.}Read a # from a contiguous piece of memory.~ Outputs a  to the specified .Read a  directly from the specified W. This is far more efficient than reading the characters into a list and then using  .$Read an entire file strictly into a B. This is far more efficient than reading the characters into a  and then using  . It also may be more efficient than opening the file and reading it using hGet. Files are read using 'binary mode' on Windows.Write a  to a file. Append a  to a file.w !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~f !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~f "!#$'(-)+*,%&BC@A.H/0123564789:;<=>?IJKLDEGFMNOPQRSTUWX[\YZ`ayz^]_Vbopklnmcdfehigjqrstu{vwx|}~w !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneNone Example:  *Data.StorableVector.Lazy> unfoldrResult (ChunkSize 5) (\c -> if c>'z' then Left (Char.ord c) else Right (c, succ c)) 'a' (VectorLazy.fromChunks [Vector.pack "abcde",Vector.pack "fghij",Vector.pack "klmno",Vector.pack "pqrst",Vector.pack "uvwxy",Vector.pack "z"],123)extendL size x y prepends the chunk x' and merges it with the first chunk of y if the total size is at most size]. This way you can prepend small chunks while asserting a reasonable average size for chunks.CTake n values from the end of the vector in a memory friendly way.  takeEnd n xs should perform the same as drop (length xs - n) xs/, but the latter one would have to materialise xs! completely. In contrast to that takeEnd" should hold only chunks of about n elements at any time point.dropMarginRem n m xs drops at most the first m elements of xs and ensures that xs still contains nw elements. Additionally returns the number of elements that could not be dropped due to the margin constraint. That is dropMarginRem n m xs == (k,ys) implies length xs - m == length ys - k . Requires length xs >= n.QGenerates laziness breaks wherever one of the input signals has a chunk boundary.-Preserves chunk pattern of the last argument.-Preserves chunk pattern of the last argument.-Preserves chunk pattern of the last argument.}Interleave lazy vectors while maintaining the chunk pattern of the first vector. All input vectors must have the same length.}Interleave lazy vectors while maintaining the chunk pattern of the first vector. All input vectors must have the same length.<Ensure a minimal length of the list by appending pad values.oRead the rest of a file lazily and provide the reason of termination as IOError. If IOError is EOF (check with System.Error.isEOFError err?), then the file was read successfully. Only access the final IOError after you have consumed the file contents, since finding out the terminating reason forces to read the entire file. Make also sure you read the file completely, because it is only closed when the file end is reached (or an exception is encountered).TODO: In ByteString.Lazy the chunk size is reduced if data is not immediately available. Maybe we should adapt that behaviour but when working with realtime streams that may mean that the chunks are very small.The file can only closed after all values are consumed. That is you must always assert that you consume all elements of the stream, and that no values are missed due to lazy evaluation. This requirement makes this function useless in many applications.hYYe5NonedGenerates laziness breaks wherever either the lazy length number or the vector has a chunk boundary./Preserves the chunk pattern of the lazy vector.55NoneNoneNone A  Vector size aY represents a chunky storable vector with maximum chunk size expressed by type parameter size. VThis will maintain all laziness breaks, but if chunks are too big, they will be split. extendL x y prepends the chunk x' and merges it with the first chunk of y if the total size is at most size. This way you can prepend small chunks while asserting a reasonable average size for chunks. The prepended chunk must be smaller than the maximum chunk size in the Vector. This is not checked.<QGenerates laziness breaks wherever one of the input signals has a chunk boundary.@-Preserves chunk pattern of the last argument.A-Preserves chunk pattern of the last argument.B-Preserves chunk pattern of the last argument.H}Interleave lazy vectors while maintaining the chunk pattern of the first vector. All input vectors must have the same length.I<Ensure a minimal length of the list by appending pad values.RVThis generates chunks of maximum size. If you want to have chunks of varying size, use fromChunks <$> arbitraryinstead.l      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVS      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV5 BSD-stylehaskell@henning-thielemann.de experimentalportable, requires ffiNoneOT Y dControl.Monad.ST.runST (do arr <- new_ 10; Monad.zipWithM_ (write arr) [9,8..0] ['a'..]; read arr 3)Z eVS.unpack $ runSTVector (do arr <- new_ 10; Monad.zipWithM_ (write arr) [9,8..0] ['a'..]; return arr)[ qVS.unpack $ runSTVector (do arr <- new 10 'a'; Monad.mapM_ (\n -> modify arr (mod n 8) succ) [0..10]; return arr)\Returns Just e, when the element e could be read and l if the index was out of range. This way you can avoid duplicate index checks that may be needed when using Y. dControl.Monad.ST.runST (do arr <- new_ 10; Monad.zipWithM_ (write arr) [9,8..0] ['a'..]; read arr 3) In future \ will replace Y.]Returns % if the element could be written and  if the index was out of range. runSTVector (do arr <- new_ 10; foldr (\c go i -> maybeWrite arr i c >>= \cont -> if cont then go (succ i) else return arr) (error "unreachable") ['a'..] 0) In future ] will replace Z.^ Similar to ]. In future ^ will replace [.c This is like bp but it does not copy the vector. You must make sure that you never write again to the array. It is best to use c, only at the end of a block, that is run by .g :module + Data.STRef VS.unpack $ Control.Monad.ST.runST (do ref <- newSTRef 'a'; mapST (\ _n -> do c <- readSTRef ref; modifySTRef ref succ; return c) (VS.pack [1,2,3,4::Data.Int.Int16]))h *Data.StorableVector.ST.Strict Data.STRef> VL.unpack $ Control.Monad.ST.runST (do ref <- newSTRef 'a'; mapSTLazy (\ _n -> do c <- readSTRef ref; modifySTRef ref succ; return c) (VL.pack VL.defaultChunkSize [1,2,3,4::Data.Int.Int16])) "abcd"CThe following should not work on infinite streams, since we are in  with strict . But it works. Why? *Data.StorableVector.ST.Strict Data.STRef> VL.unpack $ Control.Monad.ST.runST (do ref <- newSTRef 'a'; mapSTLazy (\ _n -> do c <- readSTRef ref; modifySTRef ref succ; return c) (VL.pack VL.defaultChunkSize [0::Data.Int.Int16 ..])) "Interrupted.WXYZ[\]^_`abcdefghWXYZ[\]^_`abcdefghWXYZ[\]^_`abcdefghWXYZ[\]^_`abcdefgh NoneOTj ;toLazyStorableVector (ChunkSize 7) $ foldMap put ['a'..'z']lSet a laziness break. ijklmijklijklijklm  BSD-stylehaskell@henning-thielemann.de experimentalportable, requires ffiNoneOTp dControl.Monad.ST.runST (do arr <- new_ 10; Monad.zipWithM_ (write arr) [9,8..0] ['a'..]; read arr 3)q eVS.unpack $ runSTVector (do arr <- new_ 10; Monad.zipWithM_ (write arr) [9,8..0] ['a'..]; return arr)z :module + Data.STRef VS.unpack $ Control.Monad.ST.runST (do ref <- newSTRef 'a'; mapST (\ _n -> do c <- readSTRef ref; modifySTRef ref succ; return c) (VS.pack [1,2,3,4::Data.Int.Int16])){ *Data.StorableVector.ST.Strict Data.STRef> VL.unpack $ Control.Monad.ST.runST (do ref <- newSTRef 'a'; mapSTLazy (\ _n -> do c <- readSTRef ref; modifySTRef ref succ; return c) (VL.pack VL.defaultChunkSize [1,2,3,4::Data.Int.Int16])) "abcd"CThe following should not work on infinite streams, since we are in  with strict . But it works. Why? *Data.StorableVector.ST.Strict Data.STRef.Lazy> VL.unpack $ Control.Monad.ST.Lazy.runST (do ref <- newSTRef 'a'; mapSTLazy (\ _n -> do c <- readSTRef ref; modifySTRef ref succ; return c) (VL.pack VL.defaultChunkSize [0::Data.Int.Int16 ..])) "Interrupted.nopqrstuvwxyz{enopqrstuvwxyz{nopqrstuvwxeyz{nopqrstuvwxyz{ !"#$%&''()*+,- ./0123456+789:;<=>?@ABCDEFGHIJKLMN-O,PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~',-./0234\_Z56p+<Gc7=>ABCIJKLMN,P-OVQRT`abedhz%$03][Z6`ab+./02\_Z56p+<Gc7=>ABCIKLMN,P-OVQRT`abedhz%$6     + 2 z    ] 0  - , C 5 a ` $89:;`6a        ').+''p+,- !"#$%&'()*+,+-./01   2 3 45-6,storablevector-0.2.12-B12ZBpunGFxHa0tZBZpzxIData.StorableVector.BaseData.StorableVector.PointerData.StorableVector.ST.StrictData.StorableVector Data.StorableVector.Lazy.PointerData.StorableVector.Lazy Data.StorableVector.Lazy.PatternData.StorableVector.Lazy.Typed Data.StorableVector.Lazy.BuilderData.StorableVector.ST.LazyData.StorableVector.MemoryData.StorableVector.CursorData.StorableVector.ST.Private Data.List.HTsliceHorizontal'Data.StorableVector.Lazy.PointerPrivate,Data.StorableVector.Lazy.PointerPrivateIndexVectorSV unsafeHead unsafeTail unsafeLast unsafeInit unsafeIndex unsafeTake unsafeDropfromForeignPtr toForeignPtr withStartPtrincPtr unsafeCreatecreate createAndTrimcreateAndTrim'inlinePerformIO $fShowVector$fNFDataVector $fDataVectorPointerfptrptrleftconsviewLswitchLempty singletonpackpackNunpackpackWith unpackWithnulllengthsnocheadtaillastinitappendmapreverse intersperse transposefoldlfoldl'foldrfoldl1foldl1'foldr1concat concatMapfoldMapmonoidConcatMapanyallmaximumminimumswitchRviewR mapAccumL mapAccumRcrochetLResultcrochetL mapIndexedscanlscanl1scanrscanr1 replicateiterateNunfoldrunfoldrNunfoldrResultNsampletakedropsplitAt sliceVertical takeWhile dropWhilebreakbreakEndspanspanEnd splitWithsplittokensgroupgroupByjoinindex elemIndex elemIndexEnd elemIndicescount findIndex findIndicesfindIndexOrEndelemnotElemfilterfind isPrefixOf isSuffixOfzipzipWithzipWith3zipWith4unzipsieve deinterleave interleaveinitstailscopypokepeekhPuthGetreadFile writeFile appendFile$fArbitraryVector$fMonoidVector $fEqVector ChunkSizechunks chunkSizedefaultChunkSize fromChunks unfoldrResultsampleNiteraterepeatcycleequalextendLpointer crochetLChunktakeEnd dropMarginRem dropMargin zipWithAppendzipWithLastPatternzipWithLastPattern3zipWithLastPattern4 zipWithSize zipWithSize3 zipWithSize4interleaveFirstPatternpadpadAltcompactcancelNullVector fromChunkhGetContentsAsynchGetContentsSync readFileAsyncinteract moduleError $fCChunkSize$fMonoidChunkSize$fNumChunkSize$fArbitraryChunkSize $fEqChunkSize$fOrdChunkSize$fShowChunkSizeLazySizetakeVectorPatternsplitAtVectorPattern DefaultVectorSize1024DefaultChunkSizeSize lazyChunkSize toVectorLazyfromVectorLazy$fSizeSize1024newnew_readwritemodify maybeRead maybeWrite maybeModify unsafeRead unsafeWrite unsafeModifyfreeze unsafeFreezethaw runSTVectormapST mapSTLazyBuildertoLazyStorableVectorputflush$fMonoidBuildermallocForeignPtrArrayBuffer GeneratorcreateIO unfoldrNTerm advanceIO evaluateToIObufferstartmaxLenmemory_size_gencursorunfoldrNTermIO unfoldrNIOzipNWithwhileM_obviousNullIOviewLIOdropIObaseGHC.List Data.FoldableunsafeToVectorghc-prim GHC.TypesIntGHC.BaseNothingJust GHC.ClassesnotTrueGHC.IO.Handle.TypesHandleStringlaxTail foldrByLoop concatCoreunfoldlN_sliceVertical sieveCoresuccpredunsafeWithStartPtr foreignPeekwithNonEmptyVector errorEmptyfindFromEndUntil_interleaveFirstPattern_maximum_minimum_span zipWithCont compactGen chunkLengthdecrementLimitintFromChunkSizeintFromLazySizeplain _dummySize withChunkSizewithLazyChunkSize getChunkSizelift0lift1lift2lift3lift4fromChunksUnchecked_sample_sampleNwithIOErrorChunkSizewithIOChunkSize interactAuxFalseGHC.STrunSTST>>=access maybeAccess unsafeAccessrunnewChunk fixVectorControl.Monad.ST.Lazy.Imp