D      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q rstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au> Box monad Identity monad  GDelay inlining a function until late in the game (simplifier phase 0).      portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>  Size hint  Unknown size Upper bound on the size  Exact size Minimum of two size hints Maximum of two size hints &Convert a size hint to an upper bound *Compute the minimum size from a size hint 6Compute the maximum size from a size hint if possible       non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>    non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>{Monadic streams !+Result of taking a single step in a stream "end of stream #just a new seed $a new element and a new seed %  hint of a   & Attach a   hint to a   ' Length of a   ( Check if a   is empty )Empty   * Singleton   +$Replicate a value to a given length ,Yield a  9 of values obtained by performing the monadic action the  given number of times -.#Generate a stream from its indices /Prepend an element 0Append an element 1Concatenate two  s 2First element of the   or error if empty 3Last element of the   or error if empty 4Element at the given position 5HExtract a substream of the given length starting at the given position. starting index length 6All but the last element 7All but the first element 8 The first n elements 9All but the first n elements :Map a function over a   ;Map a monadic function over a   <1Execute a monadic action for each element of the   = Transform a   to use a different monad >?Pair each element in a   with its index @Pair each element in a  ) with its index, starting from the right  and counting down AZip two  "s with the given monadic function BCDEFGHIJKLMNOPQ1Drop elements which do not satisfy the predicate R9Drop elements which do not satisfy the monadic predicate S6Longest prefix of elements that satisfy the predicate T>Longest prefix of elements that satisfy the monadic predicate U?Drop the longest prefix of elements that satisfy the predicate VGDrop the longest prefix of elements that satisfy the monadic predicate WCheck whether the   contains an element X Inverse of W YYield 3 the first element that satisfies the predicate or   if no such element exists. ZYield ; the first element that satisfies the monadic predicate or   if no such element exists. [Yield = the index of the first element that satisfies the predicate  or  if no such element exists. \Yield ; the index of the first element that satisfies the monadic  predicate or  if no such element exists. ] Left fold ^"Left fold with a monadic operator _Same as ^ `Left fold over a non-empty   aLeft fold over a non-empty   with a monadic operator bSame as a c$Left fold with a strict accumulator d;Left fold with a strict accumulator and a monadic operator eSame as d fLeft fold over a non-empty   with a strict accumulator gLeft fold over a non-empty  ! with a strict accumulator and a  monadic operator hSame as g i Right fold j#Right fold with a monadic operator k#Right fold over a non-empty stream l;Right fold over a non-empty stream with a monadic operator mnopqUnfold rUnfold with a monadic function sUnfold at most n elements tUnfold at most n# elements with a monadic functions u Prefix scan v$Prefix scan with a monadic operator w$Prefix scan with strict accumulator x;Prefix scan with strict accumulator and a monadic operator y Suffix scan z$Suffix scan with a monadic operator {$Suffix scan with strict accumulator |<Suffix scan with strict acccumulator and a monadic operator }Haskell-style scan ~+Haskell-style scan with a monadic operator +Haskell-style scan with strict accumulator BHaskell-style scan with strict accumulator and a monadic operator Scan over a non-empty   Scan over a non-empty   with a monadic operator Scan over a non-empty   with a strict accumulator Scan over a non-empty  ) with a strict accumulator and a monadic  operator Yield a  + of the given length containing the values x, x+y,  x+y+y etc. Enumerate values WARNING:A This operation can be very inefficient. If at all possible, use   instead. $Enumerate values with a given step. WARNING:= This operation is very inefficient. If at all possible, use   instead.  Convert a   to a list Convert a list to a   Convert the first n elements of a list to a   Convert a list to a   with the given   hint. m !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~m !$#"%&'()*/0+,-.123456789:;<=>o?@BACDEFGHIJKLMNOPQRSTUVWXYZ[\]^`a_bcdfgehijklmnpqrstuvwxyz{|}~m !$#""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>R%Alternative name for monadic streams The type of pure streams *Convert a pure stream to a monadic stream   hint of a   Attach a   hint to a   Length of a   Check if a  is empty Empty   Singleton  $Replicate a value to a given length #Generate a stream from its indices Prepend an element Append an element Concatenate two s First element of the  or error if empty Last element of the  or error if empty Element at the given position HExtract a substream of the given length starting at the given position. starting index length All but the last element All but the first element  The first n elements All but the first n elements Map a function over a  Pair each element in a  with its index Pair each element in a ) with its index, starting from the right  and counting down Zip two s with the given function  Zip three s with the given function 1Drop elements which do not satisfy the predicate 6Longest prefix of elements that satisfy the predicate ?Drop the longest prefix of elements that satisfy the predicate Check whether the  contains an element  Inverse of  Yield - the first element matching the predicate or  if no  such element exists. Yield : the index of the first element matching the predicate or   if no such element exists.  Left fold Left fold on non-empty s "Left fold with strict accumulator Left fold on non-empty s with strict accumulator  Right fold Right fold on non-empty s Unfold Unfold at most n elements  Prefix scan $Prefix scan with strict accumulator  Suffix scan $Suffix scan with strict accumulator Haskell-style scan +Haskell-style scan with strict accumulator Scan over a non-empty  Scan over a non-empty  with a strict accumulator  Check if two  s are equal Lexicographically compare two s JApply a monadic action to each element of the stream, producing a monadic  stream of results 5Apply a monadic action to each element of the stream FYield a monadic stream of elements that satisfy the monadic predicate  Monadic fold #Monadic fold over non-empty stream %Monadic fold with strict accumulator 9Monad fold over non-empty stream with strict accumulator Yield a + of the given length containing the values x, x+y,  x+y+y etc. Enumerate values WARNING:B This operations can be very inefficient. If at all possible, use   instead. $Enumerate values with a given step. WARNING:> This operations is very inefficient. If at all possible, use   instead.  Convert a  to a list  Create a  from a list  Create a  from the first n elements of a list ' fromListN n xs = fromList (take n xs) U!"#$U!$#"Q  non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>JDClass of mutable vectors parametrised with a primitive state token. 8Length of the mutable vector. This method should not be  called directly, use  instead. CYield a part of the mutable vector without copying it. This method $ should not be called directly, use  instead. starting index length of the slice GCreate a mutable vector of the given length. This method should not be  called directly, use  instead. @Create a mutable vector of the given length and fill it with an ? initial value. This method should not be called directly, use   instead. CYield the element at the given position. This method should not be  called directly, use  instead. EReplace the element at the given position. This method should not be  called directly, use  instead. GReset all elements of the vector to some undefined value, clearing all D references to external objects. This is usually a noop for unboxed 9 vectors. This method should not be called directly, use  instead. FSet all elements of the vector to the given value. This method should  not be called directly, use  instead. GCopy a vector. The two vectors may not overlap. This method should not  be called directly, use  instead. target source IGrow a vector by the given number of elements. This method should not be  called directly, use  instead. ?Create a new mutable vector and fill it with elements from the . ? The vector will grow exponentially if the maximum size of the  is  unknown. GCreate a new mutable vector and fill it with elements from the monadic N stream. The vector will grow exponentially if the maximum size of the stream  is unknown. ?Create a new mutable vector and fill it with elements from the  L from right to left. The vector will grow exponentially if the maximum size  of the  is unknown. GCreate a new mutable vector and fill it with elements from the monadic N stream from right to left. The vector will grow exponentially if the maximum  size of the stream is unknown. Length of the mutable vector. "Check whether the vector is empty -Create a mutable vector of the given length. @Create a mutable vector of the given length and fill it with an  initial value. HCreate a mutable vector of the given length. The length is not checked. @Create a mutable vector of the given length and fill it with an + initial value. The length is not checked. BGrow a vector by the given number of elements. The number must be  positive. Grow a vector logarithmically BGrow a vector by the given number of elements. The number must be # positive but this is not checked. )Yield the element at the given position. +Replace the element at the given position. *Swap the elements at the given positions. EReplace the element at the give position and return the old element. IYield the element at the given position. No bounds checks are performed. KReplace the element at the given position. No bounds checks are performed. JSwap the elements at the given positions. No bounds checks are performed. HReplace the element at the give position and return the old element. No  bounds checks are performed. GReset all elements of the vector to some undefined value, clearing all N references to external objects. This is usually a noop for unboxed vectors. 3Set all elements of the vector to the given value. ECopy a vector. The two vectors must have the same length and may not  overlap. ECopy a vector. The two vectors must have the same length and may not  overlap. This is not checked. target source 7Yield a part of the mutable vector without copying it. HYield a part of the mutable vector without copying it. No bounds checks  are performed. starting index length of the slice      6     6     6        non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>Class of immutable vectors. ;Unsafely convert a mutable vector to its immutable version ; without copying. The mutable vector may not be used after  this operation. $Length of the vector (not fusible!) @Yield a part of the vector without copying it. No range checks! HYield the element at the given position in a monad. The monad allows us 7 to be strict in the vector if we want. Suppose we had   unsafeIndex :: v a -> Int -> a /instead. Now, if we wanted to copy a vector, we'd do something like  < copy mv v ... = ... unsafeWrite mv i (unsafeIndex v i) ... JFor lazy vectors, the indexing would not be evaluated which means that we K would retain a reference to the original vector in each element we write.  This is not what we want! With  , we can do  3 copy mv v ... = ... case basicUnsafeIndexM v i of 7 Box x -> unsafeWrite mv i x ... Hwhich does not have this problem because indexing (but not the returned % element!) is evaluated immediately. -Copy an immutable vector into a mutable one.  Mutable v s a0 is the mutable version of the pure vector type v a with  the state token s   non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au> !"#$%&'()*+,- !"#$%&'()*+,- !"#$%&'()*+,- !"#$%&'()*+,-  non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>.4Construct a pure vector from a monadic initialiser /0Convert a vector to a  1Create a vector from a  2Convert a vector to a  3Create a vector from a  456 Empty vector 7 Vector with exaclty one element 8AVector of the given length with the given value in each position 9GGenerate a vector of the given length by applying the function to each  index :Prepend an element ;Append an element <Concatenate two vectors =<Create a copy of a vector. Useful when dealing with slices. > Indexing ?First element @ Last element A(Unsafe indexing without bounds checking BFYield the first element of a vector without checking if the vector is  empty CEYield the last element of a vector without checking if the vector is  empty DKMonadic indexing which can be strict in the vector while remaining lazy in  the element. EFG.Unsafe monadic indexing without bounds checks HIJ/Yield a part of the vector without copying it. starting index length K0Yield all but the last element without copying. L-All but the first element (without copying). MYield the first n elements without copying. NYield all but the first n elements without copying. OCUnsafely yield a part of the vector without copying it and without  performing bounds checks. starting index length PQRSTUVWXYZ[\]^_`abcMap a function over a vector dApply a function to every index/ value pair ef)Zip two vectors with the given function. g+Zip three vectors with the given function. hijk;Zip two vectors and their indices with the given function. l=Zip three vectors and their indices with the given function. mnopqrstuvwxyz{|0Drop elements that do not satisfy the predicate }GDrop elements that do not satisfy the predicate (applied to values and  their indices) ~?Yield the longest prefix of elements satisfying the predicate. @Drop the longest prefix of elements that satisfy the predicate. GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don't. The J relative order of the elements is preserved at the cost of a (sometimes) ! reduced performance compared to . GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don' t. The order I of the elements is not preserved but the operation is often faster than  . FSplit the vector into the longest prefix of elements that satisfy the  predicate and the rest. ISplit the vector into the longest prefix of elements that do not satisfy  the predicate and the rest. -Check whether the vector contains an element  Inverse of  Yield - the first element matching the predicate or  if no  such element exists. Yield : the index of the first element matching the predicate or   if no such element exists. 7Yield the indices of elements satisfying the predicate Yield : the index of the first occurence of the given element or  , if the vector does not contain the element 9Yield the indices of all occurences of the given element  Left fold Left fold on non-empty vectors "Left fold with strict accumulator 7Left fold on non-empty vectors with strict accumulator  Right fold  Right fold on non-empty vectors %Right fold with a strict accumulator 8Right fold on non-empty vectors with strict accumulator ;Left fold (function applied to each element and its index) HLeft fold with strict accumulator (function applied to each element and  its index) <Right fold (function applied to each element and its index) IRight fold with strict accumulator (function applied to each element and  its index) Unfold Unfoldr at most n elements.  Prefix scan $Prefix scan with strict accumulator  Suffix scan $Suffix scan with strict accumulator Haskell-style scan +Haskell-style scan with strict accumulator Scan over a non-empty vector 7Scan over a non-empty vector with a strict accumulator Prefix right-to-left scan 2Prefix right-to-left scan with strict accumulator Suffix right-to-left scan 2Suffix right-to-left scan with strict accumulator !Haskell-style right-to-left scan 9Haskell-style right-to-left scan with strict accumulator +Right-to-left scan over a non-empty vector ERight-to-left scan over a non-empty vector with a strict accumulator 9Yield a vector of the given length containing the values x, x+1 etc. / This operation is usually more efficient than . 9Yield a vector of the given length containing the values x, x+y,  x+y+y5 etc. This operations is usually more efficient than  . Enumerate values from x to y. WARNING:A This operation can be very inefficient. If at all possible, use   instead. Enumerate values from x to y with a specific step z. WARNING:A This operation can be very inefficient. If at all possible, use   instead. Convert a vector to a list Convert a list to a vector Convert the first n elements of a list to a vector ' fromListN n xs = fromList (take n xs) CPerform the monadic action the given number of times and store the  results in a vector. JApply the monadic action to all elements of the vector, yielding a vector  of results DApply the monadic action to all elements of a vector and ignore the  results JApply the monadic action to all elements of the vector, yielding a vector  of results DApply the monadic action to all elements of a vector and ignore the  results JZip the two vectors with the monadic action and yield a vector of results CZip the two vectors with the monadic action and ignore the results 8Drop elements that do not satisfy the monadic predicate  Monadic fold $Monadic fold over non-empty vectors %Monadic fold with strict accumulator :Monad fold over non-empty vectors with strict accumulator #Destructively initialise a vector. DApply a destructive operation to a vector. The operation modifies a @ copy of the vector unless it can be safely performed in place. GCopy an immutable vector into a mutable one. The two vectors must have ' the same length. This is not checked. KCopy an immutable vector into a mutable one. The two vectors must have the  same length. Generic definion of Data.Data.gfoldl that views a  as a  list. ./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Ы4567:;89<=>?@DEFABCGHIJKLMNOPQRSWXY]^_`bTUVZ[\acdefghijklmnopqrstuvwxyz{|}~0123././0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>$Mutable vectors of primitive types. HYield a part of the mutable vector without copying it. No bounds checks  are performed. starting index length of the slice HCreate a mutable vector of the given length. The length is not checked. @Create a mutable vector of the given length and fill it with an + initial value. The length is not checked. IYield the element at the given position. No bounds checks are performed. KReplace the element at the given position. No bounds checks are performed. JSwap the elements at the given positions. No bounds checks are performed. ECopy a vector. The two vectors must have the same length and may not  overlap. This is not checked. target source BGrow a vector by the given number of elements. The number must be # positive but this is not checked. Length of the mutable vector. 7Yield a part of the mutable vector without copying it. -Create a mutable vector of the given length. @Create a mutable vector of the given length and fill it with an  initial value. )Yield the element at the given position. +Replace the element at the given position. *Swap the elements at the given positions. GReset all elements of the vector to some undefined value, clearing all N references to external objects. This is usually a noop for unboxed vectors. 3Set all elements of the vector to the given value. ECopy a vector. The two vectors must have the same length and may not  overlap. BGrow a vector by the given number of elements. The number must be  positive.   non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>#Unboxed vectors of primitive types  Empty vector  Vector with exaclty one element AVector of the given length with the given value in each position GGenerate a vector of the given length by applying the function to each  index Prepend an element Append an element Concatenate two vectors <Create a copy of a vector. Useful when dealing with slices.  Indexing First element  Last element (Unsafe indexing without bounds checking FYield the first element of a vector without checking if the vector is  empty EYield the last element of a vector without checking if the vector is  empty KMonadic indexing which can be strict in the vector while remaining lazy in  the element .Unsafe monadic indexing without bounds checks @Yield a part of the vector without copying it. Safer version of  basicUnsafeSlice. starting index length 0Yield all but the last element without copying. -All but the first element (without copying). Yield the first n elements without copying. Yield all but the first n elements without copying. CUnsafely yield a part of the vector without copying it and without  performing bounds checks. starting index length      Map a function over a vector Apply a function to every index/ value pair )Zip two vectors with the given function. +Zip three vectors with the given function. ;Zip two vectors and their indices with the given function. =Zip three vectors and their indices with the given function.  !"1Drop elements which do not satisfy the predicate #GDrop elements that do not satisfy the predicate (applied to values and  their indices) $?Yield the longest prefix of elements satisfying the predicate. %@Drop the longest prefix of elements that satisfy the predicate. &GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don't. The J relative order of the elements is preserved at the cost of a (sometimes) ! reduced performance compared to '. 'GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don' t. The order # of the elements is not preserved. (FSplit the vector into the longest prefix of elements that satisfy the  predicate and the rest. )ISplit the vector into the longest prefix of elements that do not satisfy  the predicate and the rest. *-Check whether the vector contains an element + Inverse of * ,Yield - the first element matching the predicate or  if no  such element exists. -Yield : the index of the first element matching the predicate or   if no such element exists. .7Yield the indices of elements satisfying the predicate /Yield : the index of the first occurence of the given element or  , if the vector does not contain the element 09Yield the indices of all occurences of the given element 1 Left fold 2 Lefgt fold on non-empty vectors 3"Left fold with strict accumulator 47Left fold on non-empty vectors with strict accumulator 5 Right fold 6 Right fold on non-empty vectors 7%Right fold with a strict accumulator 88Right fold on non-empty vectors with strict accumulator 9;Left fold (function applied to each element and its index) :HLeft fold with strict accumulator (function applied to each element and  its index) ;<Right fold (function applied to each element and its index) <IRight fold with strict accumulator (function applied to each element and  its index) =>?@ABCDEFGHIThe I function is a `dual' to 5: while 5 & reduces a vector to a summary value, I builds a list from ; a seed value. The function takes the element and returns  0 if it is done generating the vector or returns  (a,b) , in which  case, a" is a prepended to the vector and b is used as the next  element in a recursive call. A simple use of unfoldr: > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10  [10,9,8,7,6,5,4,3,2,1] JUnfold at most n elements K Prefix scan L$Prefix scan with strict accumulator M Suffix scan N$Suffix scan with strict accumulator OHaskell-style scan P+Haskell-style scan with strict accumulator QScan over a non-empty  RScan over a non-empty  with a strict accumulator SPrefix right-to-left scan T2Prefix right-to-left scan with strict accumulator USuffix right-to-left scan V2Suffix right-to-left scan with strict accumulator W!Haskell-style right-to-left scan X9Haskell-style right-to-left scan with strict accumulator Y+Right-to-left scan over a non-empty vector ZERight-to-left scan over a non-empty vector with a strict accumulator [9Yield a vector of the given length containing the values x, x+1 etc. / This operation is usually more efficient than ]. \9Yield a vector of the given length containing the values x, x+y,  x+y+y5 etc. This operations is usually more efficient than  ^. ]Enumerate values from x to y. WARNING:A This operation can be very inefficient. If at all possible, use  [ instead. ^Enumerate values from x to y with a specific step z. WARNING:A This operation can be very inefficient. If at all possible, use  \ instead. _Convert a vector to a list `Convert a list to a vector aConvert the first n elements of a list to a vector ' fromListN n xs = fromList (take n xs) bCPerform the monadic action the given number of times and store the  results in a vector. cJApply the monadic action to all elements of the vector, yielding a vector  of results dDApply the monadic action to all elements of a vector and ignore the  results eJApply the monadic action to all elements of the vector, yielding a vector  of results fDApply the monadic action to all elements of a vector and ignore the  results gJZip the two vectors with the monadic action and yield a vector of results hCZip the two vectors with the monadic action and ignore the results i8Drop elements that do not satisfy the monadic predicate j Monadic fold k$Monadic fold over non-empty vectors l%Monadic fold with strict accumulator m:Monad fold over non-empty vectors with strict accumulator n#Destructively initialise a vector. oIApply a destructive operation to a vector. The operation is applied to a @ copy of the vector unless it can be safely performed in place. pGCopy an immutable vector into a mutable one. The two vectors must have ' the same length. This is not checked. qKCopy an immutable vector into a mutable one. The two vectors must have the  same length.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq      !"#$%&'()*+,-./0123456789:;<=>?@ABCDGHEFIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijlkmnoqp      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>rstMutable -based vectors uvCreate a mutable vector from a  with an offset and a length.  Modifying data through the $ afterwards is unsafe if the vector 1 could have been frozen before the modification. pointer offset length wYield the underlying & together with the offset to the data 0 and its length. Modifying the data through the  is A unsafe if the vector could have frozen before the modification. xPass a pointer to the vector'(s data to the IO action. Modifying data K through the pointer is unsafe if the vector could have been frozen before  the modification. yHYield a part of the mutable vector without copying it. No bounds checks  are performed. starting index length of the slice zHCreate a mutable vector of the given length. The length is not checked. {@Create a mutable vector of the given length and fill it with an + initial value. The length is not checked. |IYield the element at the given position. No bounds checks are performed. }KReplace the element at the given position. No bounds checks are performed. ~JSwap the elements at the given positions. No bounds checks are performed. ECopy a vector. The two vectors must have the same length and may not  overlap. This is not checked. target source BGrow a vector by the given number of elements. The number must be # positive but this is not checked. Length of the mutable vector. 7Yield a part of the mutable vector without copying it. -Create a mutable vector of the given length. @Create a mutable vector of the given length and fill it with an  initial value. )Yield the element at the given position. +Replace the element at the given position. *Swap the elements at the given positions. GReset all elements of the vector to some undefined value, clearing all N references to external objects. This is usually a noop for unboxed vectors. 3Set all elements of the vector to the given value. ECopy a vector. The two vectors must have the same length and may not  overlap. BGrow a vector by the given number of elements. The number must be  positive. rstuvwxyz{|}~tusryz{|}~vwxrstuuvwxyz{|}~ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>-based vectors  Empty vector  Vector with exaclty one element AVector of the given length with the given value in each position GGenerate a vector of the given length by applying the function to each  index Prepend an element Append an element Concatenate two vectors <Create a copy of a vector. Useful when dealing with slices.  Indexing First element  Last element (Unsafe indexing without bounds checking FYield the first element of a vector without checking if the vector is  empty EYield the last element of a vector without checking if the vector is  empty KMonadic indexing which can be strict in the vector while remaining lazy in  the element .Unsafe monadic indexing without bounds checks @Yield a part of the vector without copying it. Safer version of  basicUnsafeSlice. starting index length 0Yield all but the last element without copying. -All but the first element (without copying). Yield the first n elements without copying. Yield all but the first n elements without copying. CUnsafely yield a part of the vector without copying it and without  performing bounds checks. starting index length Map a function over a vector Apply a function to every index/ value pair )Zip two vectors with the given function. +Zip three vectors with the given function. ;Zip two vectors and their indices with the given function. =Zip three vectors and their indices with the given function. 1Drop elements which do not satisfy the predicate GDrop elements that do not satisfy the predicate (applied to values and  their indices) ?Yield the longest prefix of elements satisfying the predicate. @Drop the longest prefix of elements that satisfy the predicate. GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don't. The J relative order of the elements is preserved at the cost of a (sometimes) ! reduced performance compared to . GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don' t. The order # of the elements is not preserved. FSplit the vector into the longest prefix of elements that satisfy the  predicate and the rest. ISplit the vector into the longest prefix of elements that do not satisfy  the predicate and the rest. -Check whether the vector contains an element  Inverse of  Yield - the first element matching the predicate or  if no  such element exists. Yield : the index of the first element matching the predicate or   if no such element exists. 7Yield the indices of elements satisfying the predicate Yield : the index of the first occurence of the given element or  , if the vector does not contain the element 9Yield the indices of all occurences of the given element  Left fold  Lefgt fold on non-empty vectors "Left fold with strict accumulator 7Left fold on non-empty vectors with strict accumulator  Right fold  Right fold on non-empty vectors %Right fold with a strict accumulator 8Right fold on non-empty vectors with strict accumulator ;Left fold (function applied to each element and its index) HLeft fold with strict accumulator (function applied to each element and  its index) <Right fold (function applied to each element and its index) IRight fold with strict accumulator (function applied to each element and  its index) The  function is a `dual' to : while  & reduces a vector to a summary value,  builds a list from ; a seed value. The function takes the element and returns  0 if it is done generating the vector or returns  (a,b) , in which  case, a" is a prepended to the vector and b is used as the next  element in a recursive call. A simple use of unfoldr: > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10  [10,9,8,7,6,5,4,3,2,1] Unfold at most n elements  Prefix scan $Prefix scan with strict accumulator  Suffix scan $Suffix scan with strict accumulator Haskell-style scan +Haskell-style scan with strict accumulator Scan over a non-empty  Scan over a non-empty  with a strict accumulator Prefix right-to-left scan 2Prefix right-to-left scan with strict accumulator Suffix right-to-left scan 2Suffix right-to-left scan with strict accumulator !Haskell-style right-to-left scan 9Haskell-style right-to-left scan with strict accumulator +Right-to-left scan over a non-empty vector ERight-to-left scan over a non-empty vector with a strict accumulator 9Yield a vector of the given length containing the values x, x+1 etc. / This operation is usually more efficient than . 9Yield a vector of the given length containing the values x, x+y,  x+y+y5 etc. This operations is usually more efficient than  . Enumerate values from x to y. WARNING:A This operation can be very inefficient. If at all possible, use   instead. Enumerate values from x to y with a specific step z. WARNING:A This operation can be very inefficient. If at all possible, use   instead. Convert a vector to a list Convert a list to a vector Convert the first n elements of a list to a vector ' fromListN n xs = fromList (take n xs) CPerform the monadic action the given number of times and store the  results in a vector.  JApply the monadic action to all elements of the vector, yielding a vector  of results  DApply the monadic action to all elements of a vector and ignore the  results  JApply the monadic action to all elements of the vector, yielding a vector  of results  DApply the monadic action to all elements of a vector and ignore the  results  JZip the two vectors with the monadic action and yield a vector of results CZip the two vectors with the monadic action and ignore the results 8Drop elements that do not satisfy the monadic predicate  Monadic fold $Monadic fold over non-empty vectors %Monadic fold with strict accumulator :Monad fold over non-empty vectors with strict accumulator #Destructively initialise a vector. IApply a destructive operation to a vector. The operation is applied to a @ copy of the vector unless it can be safely performed in place. GCopy an immutable vector into a mutable one. The two vectors must have ' the same length. This is not checked. KCopy an immutable vector into a mutable one. The two vectors must have the  same length. Create a vector from a ' with an offset and a length. The data ! may not be modified through the  afterwards. pointer offset length Yield the underlying & together with the offset to the data : and its length. The data may not be modified through the . Pass a pointer to the vector'-s data to the IO action. The data may not be  modified through the 'Ptr. tu     tu           non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>/ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au> !" Empty vector # Vector with exaclty one element $AVector of the given length with the given value in each position %GGenerate a vector of the given length by applying the function to each  index &Prepend an element 'Append an element (Concatenate two vectors )<Create a copy of a vector. Useful when dealing with slices. * Indexing +First element , Last element -(Unsafe indexing without bounds checking .FYield the first element of a vector without checking if the vector is  empty /EYield the last element of a vector without checking if the vector is  empty 0KMonadic indexing which can be strict in the vector while remaining lazy in  the element 123.Unsafe monadic indexing without bounds checks 456@Yield a part of the vector without copying it. Safer version of  basicUnsafeSlice. starting index length 70Yield all but the last element without copying. 8-All but the first element (without copying). 9Yield the first n elements without copying. :Yield all but the first n elements without copying. ;CUnsafely yield a part of the vector without copying it and without  performing bounds checks. starting index length <=>?@ABCDEFGHIJKLMNOMap a function over a vector PApply a function to every index/ value pair QR)Zip two vectors with the given function. S+Zip three vectors with the given function. TUVW;Zip two vectors and their indices with the given function. X=Zip three vectors and their indices with the given function. YZ[\1Drop elements which do not satisfy the predicate ]GDrop elements that do not satisfy the predicate (applied to values and  their indices) ^?Yield the longest prefix of elements satisfying the predicate. _@Drop the longest prefix of elements that satisfy the predicate. `GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don't. The J relative order of the elements is preserved at the cost of a (sometimes) ! reduced performance compared to a. aGSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don' t. The order # of the elements is not preserved. bFSplit the vector into the longest prefix of elements that satisfy the  predicate and the rest. cISplit the vector into the longest prefix of elements that do not satisfy  the predicate and the rest. d-Check whether the vector contains an element e Inverse of d fYield - the first element matching the predicate or  if no  such element exists. gYield : the index of the first element matching the predicate or   if no such element exists. h7Yield the indices of elements satisfying the predicate iYield : the index of the first occurence of the given element or  , if the vector does not contain the element j9Yield the indices of all occurences of the given element k Left fold l Lefgt fold on non-empty vectors m"Left fold with strict accumulator n7Left fold on non-empty vectors with strict accumulator o Right fold p Right fold on non-empty vectors q%Right fold with a strict accumulator r8Right fold on non-empty vectors with strict accumulator s;Left fold (function applied to each element and its index) tHLeft fold with strict accumulator (function applied to each element and  its index) u<Right fold (function applied to each element and its index) vIRight fold with strict accumulator (function applied to each element and  its index) wxyz{|}~The  function is a `dual' to o: while o & reduces a vector to a summary value,  builds a list from ; a seed value. The function takes the element and returns  0 if it is done generating the vector or returns  (a,b) , in which  case, a" is a prepended to the vector and b is used as the next  element in a recursive call. A simple use of unfoldr: > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10  [10,9,8,7,6,5,4,3,2,1] Unfold at most n elements  Prefix scan $Prefix scan with strict accumulator  Suffix scan $Suffix scan with strict accumulator Haskell-style scan +Haskell-style scan with strict accumulator Scan over a non-empty  Scan over a non-empty  with a strict accumulator Prefix right-to-left scan 2Prefix right-to-left scan with strict accumulator Suffix right-to-left scan 2Suffix right-to-left scan with strict accumulator !Haskell-style right-to-left scan 9Haskell-style right-to-left scan with strict accumulator +Right-to-left scan over a non-empty vector ERight-to-left scan over a non-empty vector with a strict accumulator 9Yield a vector of the given length containing the values x, x+1 etc. / This operation is usually more efficient than . 9Yield a vector of the given length containing the values x, x+y,  x+y+y5 etc. This operations is usually more efficient than  . Enumerate values from x to y. WARNING:A This operation can be very inefficient. If at all possible, use   instead. Enumerate values from x to y with a specific step z. WARNING:A This operation can be very inefficient. If at all possible, use   instead. Convert a vector to a list Convert a list to a vector Convert the first n elements of a list to a vector ' fromListN n xs = fromList (take n xs) CPerform the monadic action the given number of times and store the  results in a vector. JApply the monadic action to all elements of the vector, yielding a vector  of results DApply the monadic action to all elements of a vector and ignore the  results JApply the monadic action to all elements of the vector, yielding a vector  of results DApply the monadic action to all elements of a vector and ignore the  results JZip the two vectors with the monadic action and yield a vector of results CZip the two vectors with the monadic action and ignore the results 8Drop elements that do not satisfy the monadic predicate  Monadic fold $Monadic fold over non-empty vectors %Monadic fold with strict accumulator :Monad fold over non-empty vectors with strict accumulator #Destructively initialise a vector. IApply a destructive operation to a vector. The operation is applied to a @ copy of the vector unless it can be safely performed in place. GCopy an immutable vector into a mutable one. The two vectors must have ' the same length. This is not checked. KCopy an immutable vector into a mutable one. The two vectors must have the  same length.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#&'$%()*+,012-./3456789:;<=>?CDEIJKLN@ABFGHMOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>HYield a part of the mutable vector without copying it. No bounds checks  are performed. starting index length of the slice HCreate a mutable vector of the given length. The length is not checked. @Create a mutable vector of the given length and fill it with an + initial value. The length is not checked. IYield the element at the given position. No bounds checks are performed. KReplace the element at the given position. No bounds checks are performed. JSwap the elements at the given positions. No bounds checks are performed. ECopy a vector. The two vectors must have the same length and may not  overlap. This is not checked. target source BGrow a vector by the given number of elements. The number must be # positive but this is not checked. Length of the mutable vector. 7Yield a part of the mutable vector without copying it. -Create a mutable vector of the given length. @Create a mutable vector of the given length and fill it with an  initial value. )Yield the element at the given position. +Replace the element at the given position. *Swap the elements at the given positions. GReset all elements of the vector to some undefined value, clearing all N references to external objects. This is usually a noop for unboxed vectors. 3Set all elements of the vector to the given value. ECopy a vector. The two vectors must have the same length and may not  overlap. BGrow a vector by the given number of elements. The number must be  positive. 7" non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>7Mutable boxed vectors keyed on the monad they live in ( or ST s). HYield a part of the mutable vector without copying it. No bounds checks  are performed. starting index length of the slice HCreate a mutable vector of the given length. The length is not checked. @Create a mutable vector of the given length and fill it with an + initial value. The length is not checked. IYield the element at the given position. No bounds checks are performed. KReplace the element at the given position. No bounds checks are performed. JSwap the elements at the given positions. No bounds checks are performed. ECopy a vector. The two vectors must have the same length and may not  overlap. This is not checked. target source BGrow a vector by the given number of elements. The number must be # positive but this is not checked. Length of the mutable vector. 7Yield a part of the mutable vector without copying it. -Create a mutable vector of the given length. @Create a mutable vector of the given length and fill it with an  initial value. )Yield the element at the given position. +Replace the element at the given position. *Swap the elements at the given positions. GReset all elements of the vector to some undefined value, clearing all N references to external objects. This is usually a noop for unboxed vectors. 3Set all elements of the vector to the given value. ECopy a vector. The two vectors must have the same length and may not  overlap. BGrow a vector by the given number of elements. The number must be  positive.  non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>-Boxed vectors, supporting efficient slicing. O(1)%. Yield the length of a vector as an  O(1). ) tests whether the given array is empty. O(1).  builds a vector of size zero. O(1)", Vector with exactly one element O(n).  n e yields a vector of length n storing e at each position O(n)=, Generate a vector of the given length by applying a (pure) " generator function to each index O(n)", Prepend an element to an array. O(n)!, Append an element to an array. O(n), Concatenate two vectors O(n), Create a copy of a vector.  force> is useful when dealing with slices, as the garbage collector L may be able to free the original vector if no further references are held. O(1)5. Read the element in the vector at the given index. O(1). ) returns the first element of the vector O(n). & yields the last element of an array. O(1)*, Unsafe indexing without bounds checking BBy not performing bounds checks, this function may be faster when ) this function is used in an inner loop) O(1)N, Yield the first element of a vector without checking if the vector is empty BBy not performing bounds checks, this function may be faster when ) this function is used in an inner loop) KYield the last element of a vector without checking if the vector is empty BBy not performing bounds checks, this function may be faster when ) this function is used in an inner loop) WMonadic indexing which can be strict in the vector while remaining lazy in the element SMonadic head which can be strict in the vector while remaining lazy in the element SMonadic last which can be strict in the vector while remaining lazy in the element .Unsafe monadic indexing without bounds checks EUnsafe monadic head (access the first element) without bounds checks DUnsafe monadic last (access the last element) without bounds checks O(1)1, Yield a part of the vector without copying it. starting index length O(1)2, Yield all but the last element without copying. /9O(1), Yield all but the first element (without copying). O(1), Yield the first n elements without copying. O(1), Yield all but the first n elements without copying.  O(1)E, Unsafely yield a part of the vector without copying it and without  performing bounds checks. starting index length  O(1), Zero-copying  without bounds checks.  O(1), Zero-copying  without bounds checks.  O(1), Zero-copying  without bounds checks.  O(1), Zero-copying  without bounds checks. TODO unsafeAccum. TODO unsafeAccumulate TODO unsafeAccumulate_  TODO accum TODO accumulate TODO accumulate_ TODO unsafeUpd TODO unsafeUpdate TODO unsafeUpdate_ TODO ()  TODO update  TODO update_ <backpermute, courtesy Blelloch. The back-permute is a gather/get operation. TODO unsafeBackpermute O(n),, reverse the elements of the given vector. O(n), Map a function over a vector O(n)!, Apply a function to every index/!value pair yielding a new vector O(n)R, generate a vector from each element of the input vector, then join the results.  O(n)+, Zip two vectors with the given function. !O(n)-, Zip three vectors with the given function. "O(n),, Zip four vectors with the given function. #O(n),, Zip five vectors with the given function. $O(n)+, Zip six vectors with the given function. %O(n)=, Zip two vectors and their indices with the given function. &O(n)?, Zip three vectors and their indices with the given function. 'O(n)>, Zip four vectors and their indices with the given function. (O(n)>, Zip five vectors and their indices with the given function. )O(n)=, Zip six vectors and their indices with the given function. *(Elementwise pairing of array elements. +4zip together three vectors into a vector of triples ,-./)Elementwise unpairing of array elements. 01234O(n)E, Remove elements from the vector which do not satisfy the predicate 5O(n)I, Drop elements that do not satisfy the predicate (applied to values and  their indices) 6O(n)A, Yield the longest prefix of elements satisfying the predicate. 7O(n)B, Drop the longest prefix of elements that satisfy the predicate. 8GSplit the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don't. The J relative order of the elements is preserved at the cost of a (sometimes) ! reduced performance compared to 9. 9O(n)I, Split the vector in two parts, the first one containing those elements = that satisfy the predicate and the second one those that don' t. The order # of the elements is not preserved. :O(n)H, Split the vector into the longest prefix of elements that satisfy the  predicate and the rest. ;ISplit the vector into the longest prefix of elements that do not satisfy  the predicate and the rest. <-Check whether the vector contains an element = Inverse of < >Yield - the first element matching the predicate or  if no  such element exists. ?Yield : the index of the first element matching the predicate or   if no such element exists. @7Yield the indices of elements satisfying the predicate AYield : the index of the first occurence of the given element or  , if the vector does not contain the element B9Yield the indices of all occurences of the given element C Left fold DLeft fold on non-empty vectors E"Left fold with strict accumulator F7Left fold on non-empty vectors with strict accumulator G Right fold H Right fold on non-empty vectors I%Right fold with a strict accumulator J8Right fold on non-empty vectors with strict accumulator K;Left fold (function applied to each element and its index) LHLeft fold with strict accumulator (function applied to each element and  its index) M<Right fold (function applied to each element and its index) NIRight fold with strict accumulator (function applied to each element and  its index) OO(n). O p u* determines whether all elements in array u satisfy  predicate p. PO(n). P p u) determines whether any element in array u satisfies  predicate p. QO(n). Q, yields the conjunction of a boolean array. RO(n). R, yields the disjunction of a boolean array. SO(n). S computes the sum (with (+)) of an array of elements. TO(n). S computes the product (with (*)) of an array of elements. UO(n). U> finds the maximum element in an array of orderable elements. VO(n). VA finds the maximum element in an array under the given ordering. WO(n). W> finds the minimum element in an array of orderable elements. XO(n). XA finds the minimum element in an array under the given ordering. YTODO maxIndex ZTODO maxIndexBy [TODO minIndex \TODO minIndexBy ]The ] function is a `dual' to G: while G & reduces a vector to a summary value, ] builds a list from ; a seed value. The function takes the element and returns  0 if it is done generating the vector or returns  (a,b) , in which  case, a" is a prepended to the vector and b is used as the next  element in a recursive call. A simple use of unfoldr: > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10  [10,9,8,7,6,5,4,3,2,1] ^Unfold at most n elements _ Prefix scan `$Prefix scan with strict accumulator a Suffix scan b$Suffix scan with strict accumulator cHaskell-style scan function. d+Haskell-style scan with strict accumulator eScan over a non-empty  fScan over a non-empty  with a strict accumulator gPrefix right-to-left scan h2Prefix right-to-left scan with strict accumulator iSuffix right-to-left scan j2Suffix right-to-left scan with strict accumulator k!Haskell-style right-to-left scan l9Haskell-style right-to-left scan with strict accumulator m+Right-to-left scan over a non-empty vector nERight-to-left scan over a non-empty vector with a strict accumulator o9Yield a vector of the given length containing the values x, x+1 etc. / This operation is usually more efficient than q. p9Yield a vector of the given length containing the values x, x+y,  x+y+y5 etc. This operations is usually more efficient than  r. qEnumerate values from x to y. WARNING:A This operation can be very inefficient. If at all possible, use  o instead. rEnumerate values from x to y with a specific step z. WARNING:A This operation can be very inefficient. If at all possible, use  p instead. sConvert a vector to a list tConvert a list to a vector uConvert the first n elements of a list to a vector ' fromListN n xs = fromList (take n xs) vCPerform the monadic action the given number of times and store the  results in a vector. wJApply the monadic action to all elements of the vector, yielding a vector  of results xDApply the monadic action to all elements of a vector and ignore the  results yJApply the monadic action to all elements of the vector, yielding a vector  of results zDApply the monadic action to all elements of a vector and ignore the  results {JZip the two vectors with the monadic action and yield a vector of results |CZip the two vectors with the monadic action and ignore the results }8Drop elements that do not satisfy the monadic predicate ~ Monadic fold $Monadic fold over non-empty vectors %Monadic fold with strict accumulator :Monad fold over non-empty vectors with strict accumulator #Destructively initialise a vector. IApply a destructive operation to a vector. The operation is applied to a @ copy of the vector unless it can be safely performed in place. GCopy an immutable vector into a mutable one. The two vectors must have ' the same length. This is not checked. KCopy an immutable vector into a mutable one. The two vectors must have the  same length.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX[\YZ]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./01234556789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~5:;<=>?@BDEFGHIJKLMNOSTU\]^_`abcdefhjlmnprux{~PQVWgtwz}  < J M N K L     J K L M N < = > ? @ B D E F G H J K L M N O \ ] ^ _ `  a b c d e      f  h j    l m n p    r u x { ~                     ! " # $ % & ' A P Q ( ) V W g t w z } * + ,-.<J  < = > ? @ B D E F G H J K L M N O \ ] ^ _ `  f  h j    l m n p    r u x { ~                     ! " # $ % & ' A P Q ( ) V W g t w z } -./01<J<=>?@BDEFGHJKLMNO\]^_`fhj lmnp   rux{~  !"#$%&'APQ()VWgtwz}/012-.<=>?@BDEFGHJKLMNO\]^_`fhj lmnp   rux{~  !"#$%&'APQ()VWgtwz}abcde<Jabcde-.<J<=>?@BDEFGHJKLMNO\]^_`abcdefhj lmnp   rux{~  !"#$%&'APQ()VWgtwz}3456789:;<=>?@A@BCDCEFGHIJKL M N O P Q R S T = U V W X Y Z [ \ ] ^ _ ` a b c d e fghijklmnopqrstuvwxyz{|}~ vector-0.6Data.Vector.Storable.MutableData.Vector.Primitive.MutableData.Vector.Storable.InternalData.Vector.Fusion.UtilData.Vector.Fusion.Stream.SizeData.Vector.Internal.Check!Data.Vector.Fusion.Stream.MonadicData.Vector.Fusion.StreamData.Vector.Generic.MutableData.Vector.Generic.BaseData.Vector.Generic.NewData.Vector.GenericData.Vector.PrimitiveData.Vector.StorableData.Vector.Unboxed.BaseData.Vector.UnboxedData.Vector.Unboxed.MutableData.Vector.Mutable Data.VectorbaseForeign.StorableStorable primitive-0.3Data.Primitive.TypesPrim ptrToOffset offsetToPtrBoxunBoxIdunId delay_inlineSizeUnknownMaxExactsmallerlargertoMax upperBoundChecksInternalUnsafeBoundsdoCheckserror emptyStreamcheckassert checkIndex checkLength checkSliceStreamStepDoneSkipYieldsizesizedlengthnullempty singleton replicate replicateMgenerate generateMconssnoc++headlast!!sliceinittailtakedropmapmapMmapM_transunboxindexedindexedRzipWithM zipWithM_ zipWith3M zipWith4M zipWith5M zipWith6MzipWithzipWith3zipWith4zipWith5zipWith6zipzip3zip4zip5zip6filterfilterM takeWhile takeWhileM dropWhile dropWhileMelemnotElemfindfindM findIndex findIndexMfoldlfoldlMfoldMfoldl1foldl1Mfold1Mfoldl'foldlM'foldM'foldl1'foldl1M'fold1M'foldrfoldrMfoldr1foldr1Mandor concatMap concatMapMunfoldrunfoldrMunfoldrN unfoldrNMprescanl prescanlM prescanl' prescanlM' postscanl postscanlM postscanl' postscanlM'scanlscanlMscanl'scanlM'scanl1scanl1Mscanl1'scanl1M' enumFromStepN enumFromToenumFromThenTotoListfromList fromListNunsafeFromListMStreaminplace liftStreameqcmpMVector basicLengthbasicUnsafeSlice basicOverlapsbasicUnsafeNewbasicUnsafeNewWithbasicUnsafeReadbasicUnsafeWrite basicClearbasicSetbasicUnsafeCopybasicUnsafeGrowoverlapsfill transformfillR transformRunstream munstream unstreamR munstreamRnewnewWith unsafeNew unsafeNewWithgrow unsafeGrowreadwriteswap unsafeRead unsafeWrite unsafeSwapclearsetcopy unsafeCopy unsafeSlice unsafeInit unsafeTailaccumupdate unsafeAccum unsafeUpdatereverseunstablePartitionunstablePartitionStreampartitionStreamVector unsafeFreezebasicUnsafeIndexMelemseqMutableNewcreaterunapplymodifymodifyWithStreamclonestreamstreamRforce! unsafeIndex unsafeHead unsafeLastindexMheadMlastM unsafeIndexM unsafeHeadM unsafeLastM unsafeTake unsafeDropunsafeAccumulateunsafeAccumulate_ accumulate accumulate_ unsafeUpd unsafeUpdate_//update_ backpermuteunsafeBackpermuteimapizipWith izipWith3 izipWith4 izipWith5 izipWith6unzipunzip3unzip4unzip5unzip6ifilter partitionspanbreak findIndices elemIndex elemIndicesfoldr'foldr1'ifoldlifoldl'ifoldrifoldr'allanysumproductmaximum maximumByminimum minimumBymaxIndex maxIndexByminIndex minIndexByprescanr prescanr' postscanr postscanr'scanrscanr'scanr1scanr1' enumFromNforMforM_gfoldlmkTypedataCastSTVectorIOVectorunsafeFromForeignPtrunsafeToForeignPtr unsafeWithUnboxdistance lowerBounddoBoundsChecksdoUnsafeChecksdoInternalChecks assert_msgcheckIndex_msgcheckLength_msgcheckSlice_msg DropWhileDropWhile_NextDropWhile_YieldDropWhile_DropSPECSPEC2consume Data.MaybeJustNothingenumFromTo_smallenumFromTo_intenumFromTo_big_wordenumFromTo_big_intenumFromTo_charenumFromTo_doubletoListFB unsafeAppend1unsafePrepend1mstreammstreamR munstreamMaxmunstreamUnknown munstreamRMaxmunstreamRUnknown growFrontenlarge enlargeFrontunsafeGrowFrontexchangeunsafeExchangeunstablePartitionMax partitionMaxpartitionUnknownunsafeAccum_stream accum_streamunsafeUpdate_stream update_streampartition_streamunstablePartition_streamunstablePartition_new unstreamMGHC.ForeignPtr ForeignPtrvectorTyfromBooltoBoolV_6MV_6V_5MV_5V_4MV_4V_3MV_3V_2MV_2 V_Complex MV_ComplexV_BoolMV_BoolV_CharMV_CharV_Double MV_DoubleV_FloatMV_FloatV_Word64 MV_Word64V_Word32 MV_Word32V_Word16 MV_Word16V_Word8MV_Word8V_WordMV_WordV_Int64MV_Int64V_Int32MV_Int32V_Int16MV_Int16V_Int8MV_Int8V_IntMV_IntV_UnitMV_Unitghc-prim GHC.TypesIO uninitialisedInt