úÎÝR×2c      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abHA space-efficient representation of a vector, supporting many efficient  operations. 1Instances of Eq, Ord, Read, Show, Data, Typeable  A variety of c for non-empty Vectors.  omits the G check for the empty case, so there is an obligation on the programmer 2 to provide a proof that the Vector is non-empty.  A variety of d for non-empty Vectors.  omits the # check for the empty case. As with , the programmer must 8 provide a separate proof that the Vector is non-empty.  A variety of e for non-empty Vectors.  omits the G check for the empty case, so there is an obligation on the programmer 2 to provide a proof that the Vector is non-empty.  A variety of f for non-empty Vectors.  omits the # check for the empty case. As with , the programmer must 8 provide a separate proof that the Vector is non-empty. Unsafe : index (subscript) operator, starting from 0, returning a G single element. This omits the bounds check, which means there is an O accompanying obligation on the programmer to ensure the bounds are checked in  some other way.  A variety of g which omits the checks on n so there is an 6 obligation on the programmer to provide a proof that 0 <= n <= h xs.  A variety of i which omits the checks on n so there is an 6 obligation on the programmer to provide a proof that 0 <= n <= h xs. O(1)" Build a Vector from a ForeignPtr O(1)( Deconstruct a ForeignPtr from a Vector 4A way of creating Vectors outside the IO monad. The Int 5 argument gives the final size of the Vector. Unlike   1 the Vector is not reallocated if the final size " is less than the estimated size. "Wrapper of mallocForeignPtrArray. BGiven the maximum size needed and a function to make the contents & of a Vector, createAndTrim makes the . The generating 7 function is required to return the actual final size (<= the maximum @ size), and the resulting byte array is realloced to this size. CcreateAndTrim is the main mechanism for creating custom, efficient C Vector functions, using Haskell or C functions to fill the space. FJust like unsafePerformIO, but we inline it. Big performance gains as 0 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 unsafePerformIO.     ZjO(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) 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 k. O(n) 1 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 , which must be non-empty. 5 An exception will be thrown in the case of an empty . O(1)* Extract the elements after the head of a , which must be non-empty. 5 An exception will be thrown in the case of an empty . O(1) Extract the last element of a &, which must be finite and non-empty. 5 An exception will be thrown in the case of an empty . O(1) Return all the elements of a  except the last one. 5 An exception will be thrown in the case of 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. !O(n) The ! function takes a element and a   and ` intersperses'& that element between the elements of  the 2. It is analogous to the intersperse function on  Lists. "The "1 function transposes the rows and columns of its   argument. ##<, applied to a binary operator, a starting value (typically ? the left-identity of the operator), and a Vector, reduces the  0 using the binary operator, from left to right. + This function is subject to array fusion. $ 'foldl\'' is like #!, but strict in the accumulator. : Though actually foldl is also strict in the accumulator. %%1, applied to a binary operator, a starting value 7 (typically the right-identity of the operator), and a ,  reduces the 0 using the binary operator, from right to left. && is a variant of # that has no starting value 1 argument, and thus must be applied to non-empty s. , This function is subject to array fusion. 5 An exception will be thrown in the case of an empty . ' 'foldl1\'' is like &!, but strict in the accumulator. 5 An exception will be thrown in the case of an empty . (( is a variant of %& that has no starting value argument, ' and thus must be applied to non-empty s 5 An exception will be thrown in the case of an empty . )O(n) Concatenate a list of s. *Map a function over a  and concatenate the results +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   This function will fuse. 5 An exception will be thrown in the case of an empty . .O(n) ." returns the minimum value from a   This function will fuse. 5 An exception will be thrown in the case of an empty . lm/01The 1( function behaves like a combination of  and  #-; it applies a function to each element of a , G passing an accumulating parameter from left to right, and returning a = final value of this accumulator together with the new list. 2The 2( function behaves like a combination of  and  %-; it applies a function to each element of a , G passing an accumulating parameter from right to left, and returning a 7 final value of this accumulator together with the new . 3O(n)9 map functions, provided with the index at each position 44 is similar to ##, but returns a list of successive 8 reduced values from the left. This function will fuse.  B 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. 55 is a variant of 4& that has no starting value argument.  This function will fuse. 0 scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...] 6*scanr is the right-to-left dual of scanl. 77 is a variant of 6& that has no starting value argument. 8O(n) 8 n x is a  of length n with x  the value of every element. 9O(n), where n# is the length of the result. The 9 # function is analogous to the List 'unfoldr'. 9 builds a  9 from a seed value. The function takes the element and  returns n if it is done producing the 'Vector or returns  o (a,b), in which case, a is the next element in the ,  and b+ is the seed value for further production.  Examples: B unfoldr (\x -> if x <= 5 then Just (x, x + 1) else Nothing) 0  == pack [0, 1, 2, 3, 4, 5] :O(n) Like 9, : builds a  from a seed C value. However, the length of the result is limited by the first  argument to :(. This function is more efficient than 9 1 when the maximum length of the result is known. The following equation relates : and 9: . fst (unfoldrN n f s) == take n (unfoldr f s) p;O(1) ; n, applied to a  xs, returns the prefix  of xs of length n, or xs itself if n >  xs. <O(1) < n xs returns the suffix of xs after the first n  elements, or [] if n >  xs. =O(1) = n xs is equivalent to (; n xs, < n xs). >>, applied to a predicate p and a  xs, 0 returns the longest prefix (possibly empty) of xs of elements that  satisfy p. ?? p xs$ returns the suffix remaining after > p xs. @@ p is equivalent to B (q . p). AA behaves like @ but from the end of the  breakEnd p == spanEnd (not.p) BB p xs breaks the  into two segments. It is  equivalent to (> p xs, ? p xs) CC behaves like B but from the end of the .  We have  / spanEnd (not.isSpace) "x y z" == ("x y ","z") and  spanEnd (not . isSpace) ps  == H let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x) DO(n) Splits a  into components delimited by G separators, where the predicate returns True for a separator element. G The resulting components do not contain the separators. Two adjacent = separators result in an empty component in the output. eg. 4 splitWith (=='a') "aabbaca" == ["","","bb","c",""] # splitWith (=='a') [] == [] EO(n) Break a  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   join [c] . split c == id  split == splitWith . (==) CAs for all splitting functions in this library, this function does 1 not copy the substrings, it just constructs new s that  are slices of the original. FLike D3, except that sequences of adjacent separators are $ treated as a single separator. eg. ( tokens (=='a') "aabbaca" == ["bb","c"] GThe G function takes a  and returns a list of  <s such that the concatenation of the result is equal to the E 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 H!, which allows the programmer to > supply their own equality test. It is about 40% faster than   groupBy (==) HThe H+ function is the non-overloaded version of G. IO(n) The I function takes a  and a list of  :s and concatenates the list after interspersing the first , argument between each element of the list. JO(1) . index (subscript) operator, starting from 0. KO(n) The K) function returns the index of the first  element in the given  which is equal to the query  element, or n if there is no such element. % This implementation uses memchr(3). LO(n) The L( function returns the last index of the  element in the given  which is equal to the query  element, or n, if there is no such element. The following  holds:  elemIndexEnd c xs == 5 (-) (length xs - 1) `fmap` elemIndex c (reverse xs) MO(n) The M function extends K, by returning M the indices of all elements equal to the query element, in ascending order. % This implementation uses memchr(3). N>count returns the number of times its argument appears in the    count = length . elemIndices ABut more efficiently than using length on the intermediate list. OThe O" function takes a predicate and a  and / returns the index of the first element in the   satisfying the predicate. PThe P function extends O, by returning the G indices of all elements satisfying the predicate, in ascending order. QQ4 is a variant of findIndex, that returns the length < of the string if no element is found, rather than Nothing. RO(n) R is the  membership predicate. SO(n) S is the inverse of R TO(n) T, applied to a predicate and a ,  returns a , containing those elements that satisfy the 6 predicate. This function is subject to array fusion. UO(n) The U" function takes a predicate and a , = and returns the first element in matching the predicate, or n  if there is no such element. H find f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> Nothing VO(n) The V function takes two  and returns r * iff the first is a prefix of the second. WO(n) The W function takes two s and returns r * iff the first is a suffix of the second. The following holds: 4 isSuffixOf x y == reverse x `isPrefixOf` reverse y XO(n) X takes two s and returns a list of / corresponding pairs of elements. If one input  is short,  excess elements of the longer  are discarded. This is  equivalent to a pair of  operations. YY generalises X' by zipping with the function given as B the first argument, instead of a tupling function. For example,  Y (+) is applied to two s to produce the list of  corresponding sums. ZO(n) Z7 transforms a list of pairs of elements into a pair of  s. Note that this performs two  operations. [O(n)* Return all initial segments of the given , shortest first. \O(n)( Return all final segments of the given , longest first. ]O(n) Make a copy of the  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 D if a large string has been read in, and only a small part of it ) is needed in the rest of the program. ^ Outputs a  to the specified s. _Read a  directly from the specified s. This ? is far more efficient than reading the characters into a list  and then using . `$Read an entire file strictly into a . This is far more . efficient than reading the characters into a t 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. aWrite a  to a file. b Append a  to a file. uvwT !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abT/0 !"#$&'%()*+,-.456712389:;<=>?BC@AGH[\EDFIVWRSUTJKMLOPNQXYZ]_^`abS !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abx      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgfgfgfg fg>fgfg?hijklmfnofnpqfrsitufvwfxyz{|}storablevector-0.1.2Data.StorableVector.BaseData.StorableVectorVectorSV unsafeHead unsafeTail unsafeLast unsafeInit unsafeIndex unsafeTake unsafeDropfromForeignPtr toForeignPtr unsafeCreatecreate createAndTrimcreateAndTrim'inlinePerformIOempty singletonpackunpackpackWith unpackWithnulllengthconssnocheadtaillastinitappendmapreverse intersperse transposefoldlfoldl'foldrfoldl1foldl1'foldr1concat concatMapanyallmaximumminimumviewLviewR mapAccumL mapAccumR mapIndexedscanlscanl1scanrscanr1 replicateunfoldrunfoldrNtakedropsplitAt takeWhile dropWhilebreakbreakEndspanspanEnd splitWithsplittokensgroupgroupByjoinindex elemIndex elemIndexEnd elemIndicescount findIndex findIndicesfindIndexOrEndelemnotElemfilterfind isPrefixOf isSuffixOfzipzipWithunzipinitstailscopyhPuthGetreadFile writeFile appendFilebaseGHC.Listeqghc-prim GHC.TypesIntswitchLswitchR Data.MaybeNothingJustunfoldlN GHC.ClassesnotGHC.BoolTrueGHC.IO.Handle.TypesHandleGHC.BaseStringerrorEmptyList moduleErrorfindFromEndUntil