HI      !"#$%&'()*+,-./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 6789:;<=>?@ABCDEFGHIJKLMNOPQ 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 { | } ~                                                                                     !"#$%&'()*+,-./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>sMonadic 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 +,#Generate a stream from its indices -Prepend an element .Append an element /Concatenate two s 0First element of the  or error if empty 1Last element of the  or error if empty 2Element at the given position 3HExtract a substream of the given length starting at the given position. starting index length 4All but the last element 5All but the first element 6 The first n elements 7All but the first n elements 8Map a function over a  9Map 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 ?Zip two "s with the given monadic function @ABCDEFGHIJKLMN1Drop elements which do not satisfy the predicate O9Drop elements which do not satisfy the monadic predicate P6Longest prefix of elements that satisfy the predicate Q>Longest prefix of elements that satisfy the monadic predicate R?Drop the longest prefix of elements that satisfy the predicate SGDrop the longest prefix of elements that satisfy the monadic predicate TCheck whether the  contains an element U Inverse of T VYield #3 the first element that satisfies the predicate or $  if no such element exists. WYield #; the first element that satisfies the monadic predicate or  $ if no such element exists. XYield #= the index of the first element that satisfies the predicate  or $ if no such element exists. YYield #; the index of the first element that satisfies the monadic  predicate or $ if no such element exists. Z Left fold ["Left fold with a monadic operator \Same as [ ]Left fold over a non-empty  ^Left fold over a non-empty  with a monadic operator _Same as ^ `$Left fold with a strict accumulator a;Left fold with a strict accumulator and a monadic operator bSame as a cLeft fold over a non-empty  with a strict accumulator dLeft fold over a non-empty ! with a strict accumulator and a  monadic operator eSame as d f Right fold g#Right fold with a monadic operator h#Right fold over a non-empty stream i;Right fold over a non-empty stream with a monadic operator jklmnUnfold oUnfold with a monadic function p Prefix scan q$Prefix scan with a monadic operator r$Prefix scan with strict accumulator s;Prefix scan with strict accumulator and a monadic operator t Suffix scan u$Suffix scan with a monadic operator v$Suffix scan with strict accumulator w<Suffix scan with strict acccumulator and a monadic operator xHaskell-style scan y+Haskell-style scan with a monadic operator z+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  g !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~g #"!$%&'()-.*+,/0123456789:;<l=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^\_`acdbefghijkmnopqrstuvwxyz{|}~g #"!!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>J%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  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 5Apply a monadic action to each element of the stream  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 L !"#L #"!H  non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>HDClass 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. ,-./01?Create a new mutable vector and fill it with elements from the . - The vector will grow logarithmically if the   hint of the  is  inexact. 23?Create a new mutable vector and fill it with elements from the . - The vector will grow logarithmically if the   hint of the  is  inexact. 45Length of the mutable vector. 6"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. 78Grow a vector logarithmically 9BGrow 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 =>?@A222  non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>BC                      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. 4Construct a pure vector from a monadic initialiser DSame as : but with a dummy argument necessary for correctly typing  the rule  uninplace.  See http:hackage.haskell.orgtracghcticket2600 Convert a vector to a  Create a vector from a  Convert a vector to a  Create a vector from a   ! 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. 012.Unsafe monadic indexing without bounds checks 345/Yield a part of the vector without copying it. starting index length 60Yield all but the last element without copying. 7-All but the first element (without copying). 8Yield the first n elements without copying. 9Yield 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 ;<=>E?@AFBCDGEFGHHIJKLMNMap a function over a vector OApply a function to every index/ value pair PQ)Zip two vectors with the given function. R+Zip three vectors with the given function. STUV;Zip two vectors and their indices with the given function. W=Zip three vectors and their indices with the given function. XYZ[\]^_`abcdefg0Drop elements that do not satisfy the predicate hGDrop elements that do not satisfy the predicate (applied to values and  their indices) i?Yield the longest prefix of elements satisfying the predicate. j@Drop the longest prefix of elements that satisfy the predicate. kGSplit 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 l. IlGSplit 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  k. JKmFSplit the vector into the longest prefix of elements that satisfy the  predicate and the rest. nISplit the vector into the longest prefix of elements that do not satisfy  the predicate and the rest. o-Check whether the vector contains an element p Inverse of o qYield #- the first element matching the predicate or $ if no  such element exists. rYield #: the index of the first element matching the predicate or  $ if no such element exists. s7Yield the indices of elements satisfying the predicate tYield #: the index of the first occurence of the given element or  $, if the vector does not contain the element u9Yield the indices of all occurences of the given element v Left fold wLeft fold on non-empty vectors x"Left fold with strict accumulator y7Left fold on non-empty vectors with strict accumulator z 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)  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  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"%&#$'()*+/01,-.23456789:;<=>BCDHIJKM?@AEFGLNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./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>x#Unboxed vectors of primitive types L 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)   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 09Yield a vector of the given length containing the values x, x+1 etc. / This operation is usually more efficient than 2. 19Yield a vector of the given length containing the values x, x+y,  x+y+y5 etc. This operations is usually more efficient than  3. 2Enumerate values from x to y. WARNING:A This operation can be very inefficient. If at all possible, use  0 instead. 3Enumerate values from x to y with a specific step z. WARNING:A This operation can be very inefficient. If at all possible, use  1 instead. 4Convert a vector to a list 5Convert a list to a vector z      !"#$%&'()*+,-./012345z      !"#$%&'()*+,-./012345w      !"#$%&'()*+,-./012345 non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>678Mutable -based vectors 9:Create a mutable vector from a M with an offset and a length.  Modifying data through the M$ afterwards is unsafe if the vector 1 could have been frozen before the modification. pointer offset length ;Yield the underlying M& together with the offset to the data 0 and its length. Modifying the data through the M is A unsafe if the vector could have frozen before the modification. <Pass 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. =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. AKReplace the element at the given position. No bounds checks are performed. BJSwap the elements at the given positions. No bounds checks are performed. CECopy a vector. The two vectors must have the same length and may not  overlap. This is not checked. target source DBGrow a vector by the given number of elements. The number must be # positive but this is not checked. ELength of the mutable vector. FG7Yield a part of the mutable vector without copying it. H-Create a mutable vector of the given length. I@Create a mutable vector of the given length and fill it with an  initial value. J)Yield the element at the given position. K+Replace the element at the given position. L*Swap the elements at the given positions. MGReset all elements of the vector to some undefined value, clearing all N references to external objects. This is usually a noop for unboxed vectors. N3Set all elements of the vector to the given value. OECopy a vector. The two vectors must have the same length and may not  overlap. PBGrow a vector by the given number of elements. The number must be  positive. 6789:;<=>?@ABCDEFGHIJKLMNOP8976EFGHIJKLMNOP=>?@ABCD:;<67899:;<=>?@ABCDEFGHIJKLMNOP  non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>}Q-based vectors NRST Empty vector U Vector with exaclty one element VAVector of the given length with the given value in each position WGGenerate a vector of the given length by applying the function to each  index XPrepend an element YAppend an element ZConcatenate 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 aEYield the last element of a vector without checking if the vector is  empty bKMonadic indexing which can be strict in the vector while remaining lazy in  the element cde.Unsafe monadic indexing without bounds checks fgh@Yield a part of the vector without copying it. Safer version of  basicUnsafeSlice. starting index length i0Yield all but the last element without copying. j-All but the first element (without copying). kYield the first n elements without copying. lYield all but the first n elements without copying. mCUnsafely yield a part of the vector without copying it and without  performing bounds checks. starting index length nopqrstuvwxyz{|}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)  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 Q Scan over a non-empty Q 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 Create a vector from a M' with an offset and a length. The data ! may not be modified through the M afterwards. pointer offset length Yield the underlying M& together with the offset to the data : and its length. The data may not be modified through the M. Pass a pointer to the vector'-s data to the IO action. The data may not be  modified through the 'Ptr. 89QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Q89RSTUXYVWZ[\]^bcd_`aefghijklmnopqtuxyz|rsvw{}~|QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>OP/QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz 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 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) )*+,-./012345678 Prefix scan 9$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 A2Prefix right-to-left scan with strict accumulator BSuffix right-to-left scan C2Suffix right-to-left scan with strict accumulator D!Haskell-style right-to-left scan E9Haskell-style right-to-left scan with strict accumulator F+Right-to-left scan over a non-empty vector GERight-to-left scan over a non-empty vector with a strict accumulator H9Yield a vector of the given length containing the values x, x+1 etc. / This operation is usually more efficient than J. I9Yield a vector of the given length containing the values x, x+y,  x+y+y5 etc. This operations is usually more efficient than  K. JEnumerate values from x to y. WARNING:A This operation can be very inefficient. If at all possible, use  H instead. KEnumerate values from x to y with a specific step z. WARNING:A This operation can be very inefficient. If at all possible, use  I instead. LConvert a vector to a list MConvert a list to a vector NOPQRSTUVWRTVXZ\^`bdfhjlnprtvxz      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW     NPRTVOQSUW !"#$%&'()*+,-./0125634789:;<=>?@ABCDEFGHIJKLM      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>XHYield a part of the mutable vector without copying it. No bounds checks  are performed. starting index length of the slice YHCreate a mutable vector of the given length. The length is not checked. Z@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. ab7Yield a part of the mutable vector without copying it. c-Create a mutable vector of the given length. d@Create a mutable vector of the given length and fill it with an  initial value. e)Yield the element at the given position. f+Replace the element at the given position. g*Swap the elements at the given positions. hGReset all elements of the vector to some undefined value, clearing all N references to external objects. This is usually a noop for unboxed vectors. i3Set all elements of the vector to the given value. jECopy a vector. The two vectors must have the same length and may not  overlap. kBGrow a vector by the given number of elements. The number must be  positive. lmnopqrstu7RTVXZ\^`bdfhjlnprtvxzXYZ[\]^_`abcdefghijklmnopqrstu"`abcdefghijklnprtmoqsuXYZ[\]^_XYZ[\]^_`abcdefghijklmnopqrstu non-portable experimental'Roman Leshchinskiy <rl@cse.unsw.edu.au>vwx7Mutable boxed vectors keyed on the monad they live in ({ or | s). y}zHYield 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. vwxyz{|}~xywvz{|}~vwxyyz{|}~ 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 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)  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 x     x           !"#$%&'()*+,-./01233456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~389:;<=>?ABCDEFGHIJKLPQRXYZ[\]^_`abdfhijlnqtwz|~Npsvy  : G J K H I   G H I J K   : ; < = > ? A B C D E G H I J K L X Y Z [ \ ] ^ _ ` a b d f h i j l n q t w z |    ~                     :G  : ; < = > ? A B C D E G H I J K L X Y Z [ \ b d f h i j l n q t w z |                       :G  : ; < = > ? A B C D E G H I J K L X Y Z [ \ b d f h i j l n q t w z |    ~                       :;<=>?ABCDEGHIJKLXYZ[\bdfhijlnqtwz|~     ]^_`a:G]^_`a:G:;<=>?ABCDEGHIJKLXYZ[\]^_`abdfhijlnqtwz|~      !"#$%&'()(*+*,-./01 2 3 4 5 6 7 8 9 : ; ; < = > ? @ A B C D E F G H I J K L M N OP QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ vector-0.5Data.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.NewData.Vector.GenericData.Vector.PrimitiveData.Vector.StorableData.Vector.Unboxed.BaseData.Vector.UnboxedData.Vector.Unboxed.MutableData.Vector.Mutable Data.VectorbaseForeign.StorableStorableprimitive-0.2.1Data.Primitive.TypesPriminlinePerformIOBoxunBoxIdunId delay_inlineSizeUnknownMaxExactsmallerlargertoMax upperBoundChecksInternalUnsafeBoundsdoCheckserror emptyStreamcheckassert checkIndex checkLength checkSliceStreamStepDoneSkipYieldsizesizedlengthnullempty singleton replicategenerate generateMconssnoc++headlast!!sliceinittailtakedropmapmapMmapM_transunboxindexedindexedRzipWithM zipWith3M zipWith4M zipWith5M zipWith6MzipWithzipWith3zipWith4zipWith5zipWith6zipzip3zip4zip5zip6filterfilterM takeWhile takeWhileM dropWhile dropWhileMelemnotElemfindfindM findIndex findIndexMfoldlfoldlMfoldMfoldl1foldl1Mfold1Mfoldl'foldlM'foldM'foldl1'foldl1M'fold1M'foldrfoldrMfoldr1foldr1Mandor concatMap concatMapMunfoldrunfoldrMprescanl prescanlM prescanl' prescanlM' postscanl postscanlM postscanl' postscanlM'scanlscanlMscanl'scanlM'scanl1scanl1Mscanl1'scanl1M' enumFromStepN enumFromToenumFromThenTotoListfromListMStreaminplace liftStreamMVector basicLengthbasicUnsafeSlice basicOverlapsbasicUnsafeNewbasicUnsafeNewWithbasicUnsafeReadbasicUnsafeWrite basicClearbasicSetbasicUnsafeCopybasicUnsafeGrowoverlaps transform transformRunstream unstreamRnewnewWith unsafeNew unsafeNewWithgrow unsafeGrowreadwriteswap unsafeRead unsafeWrite unsafeSwapclearsetcopy unsafeCopy unsafeSlice unsafeInit unsafeTailaccumupdate unsafeAccum unsafeUpdatereverseunstablePartitionunstablePartitionStreampartitionStreamNewrunVector unsafeFreezebasicUnsafeIndexMelemseqMutablestreamstreamR! unsafeIndex unsafeHead unsafeLastindexMheadMlastM unsafeIndexM unsafeHeadM unsafeLastM unsafeTake unsafeDropunsafeAccumulateunsafeAccumulate_ accumulate accumulate_ unsafeUpd unsafeUpdate_//update_ backpermuteunsafeBackpermuteimapizipWith izipWith3 izipWith4 izipWith5 izipWith6unzipunzip3unzip4unzip5unzip6eqcmpifilter partitionspanbreak findIndices elemIndex elemIndicesfoldr'foldr1'ifoldlifoldl'ifoldrifoldr'allanysumproductmaximum maximumByminimum minimumBymaxIndex maxIndexByminIndex minIndexByprescanr prescanr' postscanr postscanr'scanrscanr'scanr1scanr1' enumFromNSTVectorIOVectorunsafeFromForeignPtrunsafeToForeignPtr unsafeWithUnbox lowerBounddoBoundsChecksdoUnsafeChecksdoInternalChecks assert_msgcheckIndex_msgcheckLength_msgcheckSlice_msg DropWhileDropWhile_NextDropWhile_YieldDropWhile_DropSPECSPEC2 Data.MaybeJustNothingenumFromTo_smallenumFromTo_intenumFromTo_big_wordenumFromTo_big_intenumFromTo_char unsafeAppend1unsafePrepend1mstream munstreammrstream munstreamR unstreamMaxunstreamUnknown unstreamRMaxunstreamRUnknown growFrontenlarge enlargeFrontunsafeGrowFrontexchangeunsafeExchangeunstablePartitionMax partitionMaxpartitionUnknownapplymodifynew'unsafeAccum_stream accum_streamunsafeUpdate_stream update_streampartition_streamunstablePartition_streamunstablePartition_newGHC.ForeignPtr ForeignPtrfromBooltoBoolV_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.TypesIOGHC.STST uninitialised