`9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None-16FK&:A wrapper to tag mutable vectors with a type level length.Be careful when using the constructor here to not construct sized vectors which have a different length than that specified in the type parameter!None -;<=QSTVz\.O(1). Yield the length of the mutable vector as an .O(1)- Yield the length of the mutable vector as a .O(1)* Check whether the mutable vector is empty O(1)Z Yield a slice of the mutable vector without copying it with an inferred length argument. O(1)Z Yield a slice of the mutable vector without copying it with an explicit length argument. O(1)O Yield all but the last element of a non-empty mutable vector without copying. O(1)P Yield all but the first element of a non-empty mutable vector without copying. O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a  argument.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a  argument.O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a  argument.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.CCreate a mutable vector where the length is inferred from the type.cCreate a mutable vector where the length is inferred from the type. The memory is not initialized.fCreate a mutable vector where the length is inferred from the type and fill it with an initial value.CCreate a mutable vector where the length is given explicitly as a , argument and fill it with an initial value.Create a mutable vector where the length is inferred from the type and fill it with values produced by repeatedly executing the monadic action.CCreate a mutable vector where the length is given explicitly as a W argument and fill it with values produced by repeatedly executing the monadic action."Create a copy of a mutable vector.9Grow a mutable vector by an amount given explicitly as a  argument.KGrow a mutable vector (from the front) by an amount given explicitly as a  argument.gReset all elements of the vector to some undefined value, clearing all references to external objects.O(1)7 Yield the element at a given type-safe position using .O(1)7 Yield the element at a given type-safe position using . O(1) Yield the element at a given # position without bounds checking.!O(1)9 Replace the element at a given type-safe position using ."O(1)9 Replace the element at a given type-safe position using .#O(1) Replace the element at a given # position without bounds checking.$O(1)8 Modify the element at a given type-safe position using .%O(1)8 Modify the element at a given type-safe position using .&O(1) Modify the element at a given # position without bounds checking.'O(1)7 Swap the elements at a given type-safe position using s.(O(1) Swap the elements at a given # position without bounds checking.)O(1)V Replace the element at a given type-safe position and return the old element, using .*O(1)V Replace the element at a given type-safe position and return the old element, using .+O(1) Replace the element at a given F position and return the old element. No bounds checks are performed.,WCompute the next (lexicographically) permutation of a given vector in-place. Returns ( when the input is the last permutation.-2Set all elements of the vector to the given value../Copy a vector. The two vectors may not overlap./DCopy a vector. The two vectors may not overlap. This is not checked.0ZMove the contents of a vector. If the two vectors do not overlap, this is equivalent to .. Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.1 Convert a    into a  7 if it has the correct size, otherwise return Nothing.-Note that this does no copying; the returned  is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given   .2Takes a   ) and returns a continuation providing a   with a size parameter nH that is determined at runtime based on the length of the input vector.Essentially converts a    into a  " with the correct size parameter n.-Note that this does no copying; the returned  is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given   .3 Convert a   into a   ..Note that this does no copying; the returned    is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given . starting index starting indexlength.targetsource/targetsource0targetsource/  !"#$%&'()*+,-./0123/ !"$%')* #&(+,-.0/123None-13456FKl42A wrapper to tag vectors with a type level length.Be careful when using the constructor here to not construct sized vectors which have a different length than that specified in the type parameter!454545None-13456;<=FKQSTVhգBO(1)& Yield the length of the vector as an . This is more like  than   , extracting the value from the 0 instance and not looking at the vector itself.CO(1)% Yield the length of the vector as a . This function doesn't doW anything; it merely allows the size parameter of the vector to be passed around as a .DO(1) Reveal a 8 instance for a vector's length, determined at runtime.EO(1) Reveal a  instance and / for a vector's length, determined at runtime.FO(1) Safe indexing using a .GO(1) Safe indexing using a .HO(1)/ Indexing using an Int without bounds checking.IO(1)/ Yield the first element of a non-empty vector.JO(1). Yield the last element of a non-empty vector.KLens to access (O(1)) and update (O(n)$) an arbitrary element by its index.LLens to access (O(1)) and update (O(n)*) the first element of a non-empty vector.MLens to access (O(1)) and update (O(n))) the last element of a non-empty vector.NO(1)5 Safe indexing in a monad. See the documentation for + for an explanation of why this is useful.OO(1)" Safe indexing in a monad using a . See the documentation for * for an explanation of why this is useful.PO(1)K Indexing using an Int without bounds checking. See the documentation for * for an explanation of why this is useful.QO(1)V Yield the first element of a non-empty vector in a monad. See the documentation for * for an explanation of why this is useful.RO(1)U Yield the last element of a non-empty vector in a monad. See the documentation for * for an explanation of why this is useful.SO(1)R Yield a slice of the vector without copying it with an inferred length argument.TO(1)R Yield a slice of the vector without copying it with an explicit length argument.UO(1)G Yield all but the last element of a non-empty vector without copying.VO(1)H Yield all but the first element of a non-empty vector without copying.WO(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.XO(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a  argument.YO(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.ZO(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a  argument.[O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.\O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a  argument.]O(1) Empty vector.^O(1)! Vector with exactly one element._O(n) Construct a vector in a type safe manner fromTuple (1,2) :: Vector v 2 Int fromTuple ("hey", "what's", "going", "on") :: Vector v 4 String`O(n)g Construct a vector with the same element in each position where the length is inferred from the type.aO(n)f Construct a vector with the same element in each position where the length is given explicitly as a  argument.bO(n){ construct a vector of the given length by applying the function to each index where the length is inferred from the type.cO(n)z construct a vector of the given length by applying the function to each index where the length is given explicitly as a  argument.dO(n)j Apply function n times to value. Zeroth element is original value. The length is inferred from the type.eO(n)i Apply function n times to value. Zeroth element is original value. The length is given explicitly as a  argument.fO(n) Execute the monadic action n0 times and store the results in a vector where n is inferred from the type.gO(n) Execute the monadic action n0 times and store the results in a vector where n is given explicitly as a  argument.hO(n) Construct a vector of length nQ by applying the monadic action to each index where n is inferred from the type.iO(n) Construct a vector of length nP by applying the monadic action to each index where n is given explicitly as a  argument.jO(n)! Construct a vector with exactly nT elements by repeatedly applying the generator function to the a seed. The length, n, is inferred from the type.kO(n)! Construct a vector with exactly nT elements by repeatedly applying the generator function to the a seed. The length, n, is given explicitly as a  argument.lO(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is inferred from the type.mO(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is given explicitly as a  argument.nO(n): Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is inferred from the type.oO(n): Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is given explicitly as a  argument.pO(n) Prepend an element.qO(n) Append an element.rO(m+n) Concatenate two vectors.sO(n)Y Yield the argument but force it not to retain any extra memory, possibly by copying it.@This is especially useful when dealing with slices. For example: force (slice 0 2 <huge vector>)Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.tO(m+n) For each pair (i,a)8 from the list, replace the vector element at position i by a. ,<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>uO(m+n) For each pair (i,a)O from the vector of index/value pairs, replace the vector element at position i by a. 0update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>vO(m+n) For each index i4 from the index vector and the corresponding value aO from the value vector, replace the element of the initial vector at position i by a. .update_ <5,9,2,7> <2,0,2> <1,3,8> = <3,9,8,7>)This function is useful for instances of 4& that cannot store pairs. Otherwise, u is probably more convenient. update_ xs is ys = u xs ( is ys) w Same as (t) but without bounds checking.xSame as u but without bounds checking.ySame as v but without bounds checking.zO(m+n) For each pair (i,b), from the list, replace the vector element a at position i by f a b. ?accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>{O(m+n) For each pair (i,b)7 from the vector of pairs, replace the vector element a at position i by f a b. Daccumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>|O(m+n) For each index i4 from the index vector and the corresponding value bT from the the value vector, replace the element of the initial vector at position i by f a b. ?accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>)This function is useful for instances of 4& that cannot store pairs. Otherwise, { is probably more convenient: accumulate_ f as is bs = { f as ( is bs) }Same as z but without bounds checking.~Same as { but without bounds checking.Same as | but without bounds checking.O(n) Reverse a vectorO(n)5 Yield the vector obtained by replacing each element i of the index vector by xs!i. This is equivalent to  (xs!) is# but is often much more efficient. 3backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>Same as  but without bounds checking.O(n)- Pair each element in a vector with its indexO(n) Map a function over a vectorO(n)< Apply a function to every element of a vector and its indexO(n*m)} Map a function over a vector and concatenate the results. The function is required to always return the same length vector.O(n)V Apply the monadic action to all elements of the vector, yielding a vector of resultsO(n)c Apply the monadic action to every element of a vector and its index, yielding a vector of resultsO(n)M Apply the monadic action to all elements of a vector and ignore the resultsO(n)[ Apply the monadic action to every element of a vector and its index, ignoring the resultsO(n)e Apply the monadic action to all elements of the vector, yielding a vector of results. Equvalent to flip .O(n)] Apply the monadic action to all elements of a vector and ignore the results. Equivalent to flip .O(n)< Zip two vectors of the same length with the given function.*Zip three vectors with the given function.O(n)\ Zip two vectors of the same length with a function that also takes the elements' indices).O(n)# Zip two vectors of the same lengthO(n)^ Zip the two vectors of the same length with the monadic action and yield a vector of resultsO(n)k Zip the two vectors with a monadic action that also takes the element index and yield a vector of resultsO(n)C Zip the two vectors with the monadic action and ignore the resultsO(n)d Zip the two vectors with a monadic action that also takes the element index and ignore the results O(min(m,n)) Unzip a vector of pairs.O(n)( Check if the vector contains an elementO(n)= Check if the vector does not contain an element (inverse of )O(n) Yield - the first element matching the predicate or  if no such element exists.O(n) Yield ; the index of the first element matching the predicate or  if no such element exists.O(n) Yield ; the index of the first occurence of the given element or O if the vector does not contain the element. This is a specialised version of .O(n) Left foldO(n) Left fold on non-empty vectorsO(n)" Left fold with strict accumulatorO(n)7 Left fold on non-empty vectors with strict accumulatorO(n) Right foldO(n) Right fold on non-empty vectorsO(n)% Right fold with a strict accumulatorO(n)8 Right fold on non-empty vectors with strict accumulatorO(n); Left fold (function applied to each element and its index)O(n)T Left fold with strict accumulator (function applied to each element and its index)O(n)< Right fold (function applied to each element and its index)O(n)U Right fold with strict accumulator (function applied to each element and its index)O(n)- Check if all elements satisfy the predicate.O(n). Check if any element satisfies the predicate.O(n) Check if all elements are O(n) Check if any element is O(n) Compute the sum of the elementsO(n)$ Compute the produce of the elementsO(n)3 Yield the maximum element of the non-empty vector.O(n)_ Yield the maximum element of the non-empty vector according to the given comparison function.O(n)3 Yield the minimum element of the non-empty vector.O(n)_ Yield the minimum element of the non-empty vector according to the given comparison function.O(n)@ Yield the index of the maximum element of the non-empty vector.O(n)l Yield the index of the maximum element of the non-empty vector according to the given comparison function.O(n)@ Yield the index of the minimum element of the non-empty vector.O(n)l Yield the index of the minimum element of the non-empty vector according to the given comparison function.O(n) Monadic foldO(n)< Monadic fold (action applied to each element and its index)O(n)$ Monadic fold over non-empty vectorsO(n)% Monadic fold with strict accumulatorO(n)U Monadic fold with strict accumulator (action applied to each element and its index)O(n)< Monadic fold over non-empty vectors with strict accumulatorO(n)& Monadic fold that discards the resultO(n)V Monadic fold that discards the result (action applied to each element and its index)O(n)= Monadic fold over non-empty vectors that discards the resultO(n)> Monadic fold with strict accumulator that discards the resultO(n)n Monadic fold with strict accumulator that discards the result (action applied to each element and its index)O(n)T Monad fold over non-empty vectors with strict accumulator that discards the result,Evaluate each action and collect the results,Evaluate each action and discard the resultsO(n) Prescan prescanl f z = U .  f z  Example: $prescanl (+) 0 <1,2,3,4> = <0,1,3,6>O(n) Prescan with strict accumulatorO(n) ScanO(n) Scan with strict accumulatorO(n) Haskell-style scanO(n)+ Haskell-style scan with strict accumulatorO(n) Scan over a non-empty vectorO(n)7 Scan over a non-empty vector with a strict accumulatorO(n) Right-to-left prescanO(n). Right-to-left prescan with strict accumulatorO(n) Right-to-left scanO(n)+ Right-to-left scan with strict accumulatorO(n)! Right-to-left Haskell-style scanO(n)9 Right-to-left Haskell-style scan with strict accumulatorO(n)+ Right-to-left scan over a non-empty vectorO(n)F Right-to-left scan over a non-empty vector with a strict accumulatorO(n) Convert a vector to a listO(n) Convert a list to a vectorO(n) Convert the first n_ elements of a list to a vector. The length of the resultant vector is inferred from the type.O(n) Convert the first n^ elements of a list to a vector. The length of the resultant vector is given explicitly as a  argument.O(n){ Takes a list and returns a continuation providing a vector with a size parameter corresponding to the length of the list.aEssentially converts a list into a vector with the proper size parameter, determined at runtime.See O(n) Convert different vector typesO(n)/ Yield an immutable copy of the mutable vector.O(1) Unsafely convert a mutable vector to an immutable one withouy copying. The mutable vector may not be used after this operation.O(n). Yield a mutable copy of the immutable vector.O(n) Unsafely convert an immutable vector to a mutable one without copying. The immutable vector may not be used after this operation.O(n)- Copy an immutable vector into a mutable one. Convert a   into a 7 if it has the correct size, otherwise return Nothing.Takes a  ) and returns a continuation providing a   with a size parameter nH that is determined at runtime based on the length of the input vector.Essentially converts a   into a " with the correct size parameter n.Apply a function on unsized vectors to a sized vector. The function must preserve the size of the vector, this is not checked.The E instance for sized vectors does not have the same behaviour as the 0 instance for the unsized vectors found in the vectors package. This instance has mempty = replicate mempty and mappend = zipWith mappend , where the vectors3 instance uses the empty vector and concatenation.If  is not necessary, using the  instance over this  will dodge the  constraint.The E instance for sized vectors does not have the same behaviour as the 0 instance for the unsized vectors found in the vectors package. This instance has (<>) = zipWith (<>), but vectors uses concatentation.The E instance for sized vectors does not have the same behaviour as the 0 instance for the unsized vectors found in the vectorsC package. The instance defined here has the same behaviour as the  instance.AAny sized vector containing storable elements is itself storable.D-a vector of some (potentially unknown) length3a value that depends on knowing the vector's length"the value computed with the lengthE-a vector of some (potentially unknown) lengthIa value that depends on knowing the vector's length, which is given as a "the value computed with the lengthSstarting indexTstarting indexlengthtinitial vector (of length m)%list of index/value pairs (of length n)uinitial vector (of length m)'vector of index/value pairs (of length n)vinitial vector (of length m)index vector (of length n)value vector (of length n)winitial vector (of length m)%list of index/value pairs (of length n)xinitial vector (of length m)'vector of index/value pairs (of length n)yinitial vector (of length m)index vector (of length n)value vector (of length n)zaccumulating function finitial vector (of length m)%list of index/value pairs (of length n){accumulating function finitial vector (of length m)'vector of index/value pairs (of length n)|accumulating function finitial vector (of length m)index vector (of length n)value vector (of length n)}accumulating function finitial vector (of length m)%list of index/value pairs (of length n)~accumulating function finitial vector (of length m)'vector of index/value pairs (of length n)accumulating function finitial vector (of length m)index vector (of length n)value vector (of length n)xs value vectoris index vector (of length n)xs value vectoris index vector (of length n)4BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~4BCDEFGHIJNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~KLM44None-<QSTV!/ specialized to use O(1). Yield the length of the mutable vector as an .O(1)- Yield the length of the mutable vector as a .O(1)* Check whether the mutable vector is emptyO(1)Z Yield a slice of the mutable vector without copying it with an inferred length argument.O(1)Z Yield a slice of the mutable vector without copying it with an explicit length argument.O(1)O Yield all but the last element of a non-empty mutable vector without copying.O(1)P Yield all but the first element of a non-empty mutable vector without copying.O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a  argument.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a  argument.O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a  argument. O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type. CCreate a mutable vector where the length is inferred from the type. cCreate a mutable vector where the length is inferred from the type. The memory is not initialized. fCreate a mutable vector where the length is inferred from the type and fill it with an initial value. CCreate a mutable vector where the length is given explicitly as a , argument and fill it with an initial value.Create a mutable vector where the length is inferred from the type and fill it with values produced by repeatedly executing the monadic action.CCreate a mutable vector where the length is given explicitly as a W argument and fill it with values produced by repeatedly executing the monadic action."Create a copy of a mutable vector.9Grow a mutable vector by an amount given explicitly as a  argument.KGrow a mutable vector (from the front) by an amount given explicitly as a  argument.gReset all elements of the vector to some undefined value, clearing all references to external objects.O(1)7 Yield the element at a given type-safe position using .O(1)7 Yield the element at a given type-safe position using .O(1) Yield the element at a given # position without bounds checking.O(1)9 Replace the element at a given type-safe position using .O(1)9 Replace the element at a given type-safe position using .O(1) Replace the element at a given # position without bounds checking.O(1)8 Modify the element at a given type-safe position using .O(1)8 Modify the element at a given type-safe position using .O(1) Modify the element at a given # position without bounds checking.O(1)7 Swap the elements at a given type-safe position using s.O(1) Swap the elements at a given # position without bounds checking.O(1)V Replace the element at a given type-safe position and return the old element, using . O(1)V Replace the element at a given type-safe position and return the old element, using .!O(1) Replace the element at a given F position and return the old element. No bounds checks are performed."WCompute the next (lexicographically) permutation of a given vector in-place. Returns ( when the input is the last permutation.#2Set all elements of the vector to the given value.$/Copy a vector. The two vectors may not overlap.%DCopy a vector. The two vectors may not overlap. This is not checked.&ZMove the contents of a vector. If the two vectors do not overlap, this is equivalent to $. Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.' Convert a    into a  7 if it has the correct size, otherwise return Nothing.-Note that this does no copying; the returned  is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given   .(Takes a  ) and returns a continuation providing a  with a size parameter nH that is determined at runtime based on the length of the input vector.Essentially converts a   into a  " with the correct size parameter n.-Note that this does no copying; the returned  is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given  .) Convert a   into a   ..Note that this does no copying; the returned    is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given .starting indexstarting indexlength$targetsource%targetsource&targetsource/      !"#$%&'()/      !"#$&%'()None -;<=QSTVށ* specialized to use +O(1)& Yield the length of the vector as an . This is more like  than   , extracting the value from the 0 instance and not looking at the vector itself.,O(1)% Yield the length of the vector as a . This function doesn't doW anything; it merely allows the size parameter of the vector to be passed around as a .-O(1) Reveal a 8 instance for a vector's length, determined at runtime..O(1) Reveal a  instance and / for a vector's length, determined at runtime./O(1) Safe indexing using a .0O(1) Safe indexing using a .1O(1)/ Indexing using an Int without bounds checking.2O(1)/ Yield the first element of a non-empty vector.3O(1). Yield the last element of a non-empty vector.4Lens to access (O(1)) and update (O(n)$) an arbitrary element by its index.5Lens to access (O(1)) and update (O(n)*) the first element of a non-empty vector.6Lens to access (O(1)) and update (O(n))) the last element of a non-empty vector.7O(1)5 Safe indexing in a monad. See the documentation for + for an explanation of why this is useful.8O(1)" Safe indexing in a monad using a . See the documentation for * for an explanation of why this is useful.9O(1)K Indexing using an Int without bounds checking. See the documentation for * for an explanation of why this is useful.:O(1)V Yield the first element of a non-empty vector in a monad. See the documentation for * for an explanation of why this is useful.;O(1)U Yield the last element of a non-empty vector in a monad. See the documentation for * for an explanation of why this is useful.<O(1)R Yield a slice of the vector without copying it with an inferred length argument.=O(1)R Yield a slice of the vector without copying it with an explicit length argument.>O(1)G Yield all but the last element of a non-empty vector without copying.?O(1)H Yield all but the first element of a non-empty vector without copying.@O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.AO(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a  argument.BO(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.CO(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a  argument.DO(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.EO(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a  argument.FO(1) Empty vector.GO(1)! Vector with exactly one element.HO(n) Construct a vector in a type safe manner fromTuple (1,2) :: Vector 2 Int fromTuple ("hey", "what's", "going", "on") :: Vector 4 StringIO(n)g Construct a vector with the same element in each position where the length is inferred from the type.JO(n)f Construct a vector with the same element in each position where the length is given explicitly as a  argument.KO(n){ construct a vector of the given length by applying the function to each index where the length is inferred from the type.LO(n)z construct a vector of the given length by applying the function to each index where the length is given explicitly as a  argument.MO(n)j Apply function n times to value. Zeroth element is original value. The length is inferred from the type.NO(n)i Apply function n times to value. Zeroth element is original value. The length is given explicitly as a  argument.OO(n) Execute the monadic action n0 times and store the results in a vector where n is inferred from the type.PO(n) Execute the monadic action n0 times and store the results in a vector where n is given explicitly as a  argument.QO(n) Construct a vector of length nQ by applying the monadic action to each index where n is inferred from the type.RO(n) Construct a vector of length nP by applying the monadic action to each index where n is given explicitly as a  argument.SO(n)! Construct a vector with exactly nT elements by repeatedly applying the generator function to the a seed. The length, n, is inferred from the type.TO(n)! Construct a vector with exactly nT elements by repeatedly applying the generator function to the a seed. The length, n, is given explicitly as a  argument.UO(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is inferred from the type.VO(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is given explicitly as a  argument.WO(n): Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is inferred from the type.XO(n): Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is given explicitly as a  argument.YO(n) Prepend an element.ZO(n) Append an element.[O(m+n) Concatenate two vectors.\O(n)Y Yield the argument but force it not to retain any extra memory, possibly by copying it.@This is especially useful when dealing with slices. For example: force (slice 0 2 <huge vector>)Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.]O(m+n) For each pair (i,a)8 from the list, replace the vector element at position i by a. ,<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>^O(m+n) For each pair (i,a)O from the vector of index/value pairs, replace the vector element at position i by a. 0update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>_O(m+n) For each index i4 from the index vector and the corresponding value aO from the value vector, replace the element of the initial vector at position i by a. .update_ <5,9,2,7> <2,0,2> <1,3,8> = <3,9,8,7>)This function is useful for instances of *& that cannot store pairs. Otherwise, ^ is probably more convenient. update_ xs is ys = ^ xs ( is ys) ` Same as (]) but without bounds checking.aSame as ^ but without bounds checking.bSame as _ but without bounds checking.cO(m+n) For each pair (i,b), from the list, replace the vector element a at position i by f a b. ?accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>dO(m+n) For each pair (i,b)7 from the vector of pairs, replace the vector element a at position i by f a b. Daccumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>eO(m+n) For each index i4 from the index vector and the corresponding value bT from the the value vector, replace the element of the initial vector at position i by f a b. ?accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>)This function is useful for instances of *& that cannot store pairs. Otherwise, d is probably more convenient: accumulate_ f as is bs = d f as ( is bs) fSame as c but without bounds checking.gSame as d but without bounds checking.hSame as e but without bounds checking.iO(n) Reverse a vectorjO(n)5 Yield the vector obtained by replacing each element i of the index vector by xs!i. This is equivalent to m (xs!) is# but is often much more efficient. 3backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>kSame as j but without bounds checking.lO(n)- Pair each element in a vector with its indexmO(n) Map a function over a vectornO(n)< Apply a function to every element of a vector and its indexoO(n*m)} Map a function over a vector and concatenate the results. The function is required to always return the same length vector.pO(n)V Apply the monadic action to all elements of the vector, yielding a vector of resultsqO(n)c Apply the monadic action to every element of a vector and its index, yielding a vector of resultsrO(n)M Apply the monadic action to all elements of a vector and ignore the resultssO(n)[ Apply the monadic action to every element of a vector and its index, ignoring the resultstO(n)e Apply the monadic action to all elements of the vector, yielding a vector of results. Equvalent to flip p.uO(n)] Apply the monadic action to all elements of a vector and ignore the results. Equivalent to flip r.vO(n)< Zip two vectors of the same length with the given function.w*Zip three vectors with the given function.{O(n)\ Zip two vectors of the same length with a function that also takes the elements' indices).O(n)# Zip two vectors of the same lengthO(n)^ Zip the two vectors of the same length with the monadic action and yield a vector of resultsO(n)k Zip the two vectors with a monadic action that also takes the element index and yield a vector of resultsO(n)C Zip the two vectors with the monadic action and ignore the resultsO(n)d Zip the two vectors with a monadic action that also takes the element index and ignore the results O(min(m,n)) Unzip a vector of pairs.O(n)( Check if the vector contains an elementO(n)= Check if the vector does not contain an element (inverse of )O(n) Yield - the first element matching the predicate or  if no such element exists.O(n) Yield ; the index of the first element matching the predicate or  if no such element exists.O(n) Yield ; the index of the first occurence of the given element or O if the vector does not contain the element. This is a specialised version of .O(n) Left foldO(n) Left fold on non-empty vectorsO(n)" Left fold with strict accumulatorO(n)7 Left fold on non-empty vectors with strict accumulatorO(n) Right foldO(n) Right fold on non-empty vectorsO(n)% Right fold with a strict accumulatorO(n)8 Right fold on non-empty vectors with strict accumulatorO(n); Left fold (function applied to each element and its index)O(n)T Left fold with strict accumulator (function applied to each element and its index)O(n)< Right fold (function applied to each element and its index)O(n)U Right fold with strict accumulator (function applied to each element and its index)O(n)- Check if all elements satisfy the predicate.O(n). Check if any element satisfies the predicate.O(n) Check if all elements are O(n) Check if any element is O(n) Compute the sum of the elementsO(n)$ Compute the produce of the elementsO(n)3 Yield the maximum element of the non-empty vector.O(n)_ Yield the maximum element of the non-empty vector according to the given comparison function.O(n)3 Yield the minimum element of the non-empty vector.O(n)_ Yield the minimum element of the non-empty vector according to the given comparison function.O(n)@ Yield the index of the maximum element of the non-empty vector.O(n)l Yield the index of the maximum element of the non-empty vector according to the given comparison function.O(n)@ Yield the index of the minimum element of the non-empty vector.O(n)l Yield the index of the minimum element of the non-empty vector according to the given comparison function.O(n) Monadic foldO(n)< Monadic fold (action applied to each element and its index)O(n)$ Monadic fold over non-empty vectorsO(n)% Monadic fold with strict accumulatorO(n)U Monadic fold with strict accumulator (action applied to each element and its index)O(n)< Monadic fold over non-empty vectors with strict accumulatorO(n)& Monadic fold that discards the resultO(n)V Monadic fold that discards the result (action applied to each element and its index)O(n)= Monadic fold over non-empty vectors that discards the resultO(n)> Monadic fold with strict accumulator that discards the resultO(n)n Monadic fold with strict accumulator that discards the result (action applied to each element and its index)O(n)T Monad fold over non-empty vectors with strict accumulator that discards the result,Evaluate each action and collect the results,Evaluate each action and discard the resultsO(n) Prescan prescanl f z = > .  f z  Example: $prescanl (+) 0 <1,2,3,4> = <0,1,3,6>O(n) Prescan with strict accumulatorO(n) ScanO(n) Scan with strict accumulatorO(n) Haskell-style scanO(n)+ Haskell-style scan with strict accumulatorO(n) Scan over a non-empty vectorO(n)7 Scan over a non-empty vector with a strict accumulatorO(n) Right-to-left prescanO(n). Right-to-left prescan with strict accumulatorO(n) Right-to-left scanO(n)+ Right-to-left scan with strict accumulatorO(n)! Right-to-left Haskell-style scanO(n)9 Right-to-left Haskell-style scan with strict accumulatorO(n)+ Right-to-left scan over a non-empty vectorO(n)F Right-to-left scan over a non-empty vector with a strict accumulatorO(n) Convert a vector to a listO(n) Convert a list to a vectorO(n) Convert the first n_ elements of a list to a vector. The length of the resultant vector is inferred from the type.O(n) Convert the first n^ elements of a list to a vector. The length of the resultant vector is given explicitly as a  argument.O(n){ Takes a list and returns a continuation providing a vector with a size parameter corresponding to the length of the list.aEssentially converts a list into a vector with the proper size parameter, determined at runtime.See O(n)/ Yield an immutable copy of the mutable vector.O(1) Unsafely convert a mutable vector to an immutable one withouy copying. The mutable vector may not be used after this operation.O(n). Yield a mutable copy of the immutable vector.O(n) Unsafely convert an immutable vector to a mutable one without copying. The immutable vector may not be used after this operation.O(n)- Copy an immutable vector into a mutable one. Convert a   into a 7 if it has the correct size, otherwise return Nothing.Takes a  ) and returns a continuation providing a * with a size parameter nH that is determined at runtime based on the length of the input vector.Essentially converts a   into a *" with the correct size parameter n.Apply a function on unsized vectors to a sized vector. The function must preserve the size of the vector, this is not checked.--a vector of some (potentially unknown) length3a value that depends on knowing the vector's length"the value computed with the length.-a vector of some (potentially unknown) lengthIa value that depends on knowing the vector's length, which is given as a "the value computed with the length<starting index=starting indexlength]initial vector (of length m)%list of index/value pairs (of length n)^initial vector (of length m)'vector of index/value pairs (of length n)_initial vector (of length m)index vector (of length n)value vector (of length n)`initial vector (of length m)%list of index/value pairs (of length n)ainitial vector (of length m)'vector of index/value pairs (of length n)binitial vector (of length m)index vector (of length n)value vector (of length n)caccumulating function finitial vector (of length m)%list of index/value pairs (of length n)daccumulating function finitial vector (of length m)'vector of index/value pairs (of length n)eaccumulating function finitial vector (of length m)index vector (of length n)value vector (of length n)faccumulating function finitial vector (of length m)%list of index/value pairs (of length n)gaccumulating function finitial vector (of length m)'vector of index/value pairs (of length n)haccumulating function finitial vector (of length m)index vector (of length n)value vector (of length n)jxs value vectoris index vector (of length n)kxs value vectoris index vector (of length n)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ذ*+,-./0123789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk456lmnopqrstuvwxyz{|}~44None-<QSTV7/ specialized to use O(1). Yield the length of the mutable vector as an .O(1)- Yield the length of the mutable vector as a .O(1)* Check whether the mutable vector is emptyO(1)Z Yield a slice of the mutable vector without copying it with an inferred length argument.O(1)Z Yield a slice of the mutable vector without copying it with an explicit length argument.O(1)O Yield all but the last element of a non-empty mutable vector without copying.O(1)P Yield all but the first element of a non-empty mutable vector without copying.O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a  argument.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a  argument.O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a  argument.O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.CCreate a mutable vector where the length is inferred from the type.cCreate a mutable vector where the length is inferred from the type. The memory is not initialized.fCreate a mutable vector where the length is inferred from the type and fill it with an initial value.CCreate a mutable vector where the length is given explicitly as a , argument and fill it with an initial value.Create a mutable vector where the length is inferred from the type and fill it with values produced by repeatedly executing the monadic action.CCreate a mutable vector where the length is given explicitly as a W argument and fill it with values produced by repeatedly executing the monadic action."Create a copy of a mutable vector.9Grow a mutable vector by an amount given explicitly as a  argument.KGrow a mutable vector (from the front) by an amount given explicitly as a  argument.gReset all elements of the vector to some undefined value, clearing all references to external objects.O(1)7 Yield the element at a given type-safe position using .O(1)7 Yield the element at a given type-safe position using .O(1) Yield the element at a given # position without bounds checking.O(1)9 Replace the element at a given type-safe position using .O(1)9 Replace the element at a given type-safe position using .O(1) Replace the element at a given # position without bounds checking.O(1)8 Modify the element at a given type-safe position using .O(1)8 Modify the element at a given type-safe position using .O(1) Modify the element at a given # position without bounds checking.O(1)7 Swap the elements at a given type-safe position using s.O(1) Swap the elements at a given # position without bounds checking.O(1)V Replace the element at a given type-safe position and return the old element, using .O(1)V Replace the element at a given type-safe position and return the old element, using .O(1) Replace the element at a given F position and return the old element. No bounds checks are performed.WCompute the next (lexicographically) permutation of a given vector in-place. Returns ( when the input is the last permutation.2Set all elements of the vector to the given value./Copy a vector. The two vectors may not overlap.DCopy a vector. The two vectors may not overlap. This is not checked.ZMove the contents of a vector. If the two vectors do not overlap, this is equivalent to . Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector. Convert a   into a 7 if it has the correct size, otherwise return Nothing.-Note that this does no copying; the returned  is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given  .Takes a  ) and returns a continuation providing a  with a size parameter nH that is determined at runtime based on the length of the input vector.Essentially converts a   into a  " with the correct size parameter n.-Note that this does no copying; the returned  is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given  . Convert a  into a  ..Note that this does no copying; the returned   is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given .starting indexstarting indexlengthtargetsourcetargetsourcetargetsource//None -;<=FQSTV4' specialized to use   O(1)& Yield the length of the vector as an . This is more like  than   , extracting the value from the 0 instance and not looking at the vector itself. O(1)% Yield the length of the vector as a . This function doesn't doW anything; it merely allows the size parameter of the vector to be passed around as a . O(1) Reveal a 8 instance for a vector's length, determined at runtime. O(1) Reveal a  instance and / for a vector's length, determined at runtime. O(1) Safe indexing using a .O(1) Safe indexing using a .O(1)/ Indexing using an Int without bounds checking.O(1)/ Yield the first element of a non-empty vector.O(1). Yield the last element of a non-empty vector.Lens to access (O(1)) and update (O(n)$) an arbitrary element by its index.Lens to access (O(1)) and update (O(n)*) the first element of a non-empty vector.Lens to access (O(1)) and update (O(n))) the last element of a non-empty vector.O(1)5 Safe indexing in a monad. See the documentation for + for an explanation of why this is useful.O(1)" Safe indexing in a monad using a . See the documentation for * for an explanation of why this is useful.O(1)K Indexing using an Int without bounds checking. See the documentation for * for an explanation of why this is useful.O(1)V Yield the first element of a non-empty vector in a monad. See the documentation for * for an explanation of why this is useful.O(1)U Yield the last element of a non-empty vector in a monad. See the documentation for * for an explanation of why this is useful.O(1)R Yield a slice of the vector without copying it with an inferred length argument.O(1)R Yield a slice of the vector without copying it with an explicit length argument.O(1)G Yield all but the last element of a non-empty vector without copying.O(1)H Yield all but the first element of a non-empty vector without copying.O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a  argument. O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.!O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a  argument."O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.#O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a  argument.$O(1) Empty vector.%O(1)! Vector with exactly one element.&O(n) Construct a vector in a type safe manner fromTuple (1,2) :: Vector 2 Int fromTuple ("hey", "what's", "going", "on") :: Vector 4 String'O(n)g Construct a vector with the same element in each position where the length is inferred from the type.(O(n)f Construct a vector with the same element in each position where the length is given explicitly as a  argument.)O(n){ construct a vector of the given length by applying the function to each index where the length is inferred from the type.*O(n)z construct a vector of the given length by applying the function to each index where the length is given explicitly as a  argument.+O(n)j Apply function n times to value. Zeroth element is original value. The length is inferred from the type.,O(n)i Apply function n times to value. Zeroth element is original value. The length is given explicitly as a  argument.-O(n) Execute the monadic action n0 times and store the results in a vector where n is inferred from the type..O(n) Execute the monadic action n0 times and store the results in a vector where n is given explicitly as a  argument./O(n) Construct a vector of length nQ by applying the monadic action to each index where n is inferred from the type.0O(n) Construct a vector of length nP by applying the monadic action to each index where n is given explicitly as a  argument.1O(n)! Construct a vector with exactly nT elements by repeatedly applying the generator function to the a seed. The length, n, is inferred from the type.2O(n)! Construct a vector with exactly nT elements by repeatedly applying the generator function to the a seed. The length, n, is given explicitly as a  argument.3O(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is inferred from the type.4O(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is given explicitly as a  argument.5O(n): Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is inferred from the type.6O(n): Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is given explicitly as a  argument.7O(n) Prepend an element.8O(n) Append an element.9O(m+n) Concatenate two vectors.:O(n)Y Yield the argument but force it not to retain any extra memory, possibly by copying it.@This is especially useful when dealing with slices. For example: force (slice 0 2 <huge vector>)Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.;O(m+n) For each pair (i,a)8 from the list, replace the vector element at position i by a. ,<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7><O(m+n) For each pair (i,a)O from the vector of index/value pairs, replace the vector element at position i by a. 0update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>=O(m+n) For each index i4 from the index vector and the corresponding value aO from the value vector, replace the element of the initial vector at position i by a. .update_ <5,9,2,7> <2,0,2> <1,3,8> = <3,9,8,7>)This function is useful for instances of & that cannot store pairs. Otherwise, < is probably more convenient. update_ xs is ys = < xs (^ is ys) > Same as (;) but without bounds checking.?Same as < but without bounds checking.@Same as = but without bounds checking.AO(m+n) For each pair (i,b), from the list, replace the vector element a at position i by f a b. ?accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>BO(m+n) For each pair (i,b)7 from the vector of pairs, replace the vector element a at position i by f a b. Daccumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>CO(m+n) For each index i4 from the index vector and the corresponding value bT from the the value vector, replace the element of the initial vector at position i by f a b. ?accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>)This function is useful for instances of & that cannot store pairs. Otherwise, B is probably more convenient: accumulate_ f as is bs = B f as (^ is bs) DSame as A but without bounds checking.ESame as B but without bounds checking.FSame as C but without bounds checking.GO(n) Reverse a vectorHO(n)5 Yield the vector obtained by replacing each element i of the index vector by xs!i. This is equivalent to K (xs!) is# but is often much more efficient. 3backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>ISame as H but without bounds checking.JO(n)- Pair each element in a vector with its indexKO(n) Map a function over a vectorLO(n)< Apply a function to every element of a vector and its indexMO(n*m)} Map a function over a vector and concatenate the results. The function is required to always return the same length vector.NO(n)V Apply the monadic action to all elements of the vector, yielding a vector of resultsOO(n)c Apply the monadic action to every element of a vector and its index, yielding a vector of resultsPO(n)M Apply the monadic action to all elements of a vector and ignore the resultsQO(n)[ Apply the monadic action to every element of a vector and its index, ignoring the resultsRO(n)e Apply the monadic action to all elements of the vector, yielding a vector of results. Equvalent to flip N.SO(n)] Apply the monadic action to all elements of a vector and ignore the results. Equivalent to flip P.TO(n)< Zip two vectors of the same length with the given function.U*Zip three vectors with the given function.YO(n)\ Zip two vectors of the same length with a function that also takes the elements' indices).^O(n)# Zip two vectors of the same lengthcO(n)^ Zip the two vectors of the same length with the monadic action and yield a vector of resultsdO(n)k Zip the two vectors with a monadic action that also takes the element index and yield a vector of resultseO(n)C Zip the two vectors with the monadic action and ignore the resultsfO(n)d Zip the two vectors with a monadic action that also takes the element index and ignore the resultsg O(min(m,n)) Unzip a vector of pairs.lO(n)( Check if the vector contains an elementmO(n)= Check if the vector does not contain an element (inverse of l)nO(n) Yield - the first element matching the predicate or  if no such element exists.oO(n) Yield ; the index of the first element matching the predicate or  if no such element exists.pO(n) Yield ; the index of the first occurence of the given element or O if the vector does not contain the element. This is a specialised version of o.qO(n) Left foldrO(n) Left fold on non-empty vectorssO(n)" Left fold with strict accumulatortO(n)7 Left fold on non-empty vectors with strict accumulatoruO(n) Right foldvO(n) Right fold on non-empty vectorswO(n)% Right fold with a strict accumulatorxO(n)8 Right fold on non-empty vectors with strict accumulatoryO(n); Left fold (function applied to each element and its index)zO(n)T Left fold with strict accumulator (function applied to each element and its index){O(n)< Right fold (function applied to each element and its index)|O(n)U Right fold with strict accumulator (function applied to each element and its index)}O(n)- Check if all elements satisfy the predicate.~O(n). Check if any element satisfies the predicate.O(n) Check if all elements are O(n) Check if any element is O(n) Compute the sum of the elementsO(n)$ Compute the produce of the elementsO(n)3 Yield the maximum element of the non-empty vector.O(n)_ Yield the maximum element of the non-empty vector according to the given comparison function.O(n)3 Yield the minimum element of the non-empty vector.O(n)_ Yield the minimum element of the non-empty vector according to the given comparison function.O(n)@ Yield the index of the maximum element of the non-empty vector.O(n)l Yield the index of the maximum element of the non-empty vector according to the given comparison function.O(n)@ Yield the index of the minimum element of the non-empty vector.O(n)l Yield the index of the minimum element of the non-empty vector according to the given comparison function.O(n) Monadic foldO(n)< Monadic fold (action applied to each element and its index)O(n)$ Monadic fold over non-empty vectorsO(n)% Monadic fold with strict accumulatorO(n)U Monadic fold with strict accumulator (action applied to each element and its index)O(n)< Monadic fold over non-empty vectors with strict accumulatorO(n)& Monadic fold that discards the resultO(n)V Monadic fold that discards the result (action applied to each element and its index)O(n)= Monadic fold over non-empty vectors that discards the resultO(n)> Monadic fold with strict accumulator that discards the resultO(n)n Monadic fold with strict accumulator that discards the result (action applied to each element and its index)O(n)T Monad fold over non-empty vectors with strict accumulator that discards the result,Evaluate each action and collect the results,Evaluate each action and discard the resultsO(n) Prescan prescanl f z =  .  f z  Example: $prescanl (+) 0 <1,2,3,4> = <0,1,3,6>O(n) Prescan with strict accumulatorO(n) ScanO(n) Scan with strict accumulatorO(n) Haskell-style scanO(n)+ Haskell-style scan with strict accumulatorO(n) Scan over a non-empty vectorO(n)7 Scan over a non-empty vector with a strict accumulatorO(n) Right-to-left prescanO(n). Right-to-left prescan with strict accumulatorO(n) Right-to-left scanO(n)+ Right-to-left scan with strict accumulatorO(n)! Right-to-left Haskell-style scanO(n)9 Right-to-left Haskell-style scan with strict accumulatorO(n)+ Right-to-left scan over a non-empty vectorO(n)F Right-to-left scan over a non-empty vector with a strict accumulatorO(n) Convert a vector to a listO(n) Convert a list to a vectorO(n) Convert the first n_ elements of a list to a vector. The length of the resultant vector is inferred from the type.O(n) Convert the first n^ elements of a list to a vector. The length of the resultant vector is given explicitly as a  argument.O(n){ Takes a list and returns a continuation providing a vector with a size parameter corresponding to the length of the list.aEssentially converts a list into a vector with the proper size parameter, determined at runtime.See O(n)/ Yield an immutable copy of the mutable vector.O(1) Unsafely convert a mutable vector to an immutable one withouy copying. The mutable vector may not be used after this operation.O(n). Yield a mutable copy of the immutable vector.O(n) Unsafely convert an immutable vector to a mutable one without copying. The immutable vector may not be used after this operation.O(n)- Copy an immutable vector into a mutable one. Convert a   into a 7 if it has the correct size, otherwise return Nothing.Takes a ) and returns a continuation providing a  with a size parameter nH that is determined at runtime based on the length of the input vector.Essentially converts a  into a " with the correct size parameter n.Apply a function on unsized vectors to a sized vector. The function must preserve the size of the vector, this is not checked. -a vector of some (potentially unknown) length3a value that depends on knowing the vector's length"the value computed with the length -a vector of some (potentially unknown) lengthIa value that depends on knowing the vector's length, which is given as a "the value computed with the lengthstarting indexstarting indexlength;initial vector (of length m)%list of index/value pairs (of length n)<initial vector (of length m)'vector of index/value pairs (of length n)=initial vector (of length m)index vector (of length n)value vector (of length n)>initial vector (of length m)%list of index/value pairs (of length n)?initial vector (of length m)'vector of index/value pairs (of length n)@initial vector (of length m)index vector (of length n)value vector (of length n)Aaccumulating function finitial vector (of length m)%list of index/value pairs (of length n)Baccumulating function finitial vector (of length m)'vector of index/value pairs (of length n)Caccumulating function finitial vector (of length m)index vector (of length n)value vector (of length n)Daccumulating function finitial vector (of length m)%list of index/value pairs (of length n)Eaccumulating function finitial vector (of length m)'vector of index/value pairs (of length n)Faccumulating function finitial vector (of length m)index vector (of length n)value vector (of length n)Hxs value vectoris index vector (of length n)Ixs value vectoris index vector (of length n)      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~l4m4    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV WXYZ[\]^_`abcd !"#$%&'()efg-.hijk/0lmnopqrstuvwxyz{|}~EHIJ   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ WXYZ[\]^_`abcd !"#$%&'()efg-.hijk/0lmnopqrstuvwxyz{|}~EHIJ   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ WXYZ[\]^_`abcd !"#$%&'()efg-.hijk/0lmnopqrstuvwxyz{|}~EHIJ         +vector-sized-1.0.2.0-CE8NV4R5WDnGSFE6VC4g9i!Data.Vector.Generic.Mutable.Sized*Data.Vector.Generic.Mutable.Sized.InternalData.Vector.Generic.Sized"Data.Vector.Generic.Sized.InternalData.Vector.Mutable.SizedData.Vector.Sized"Data.Vector.Storable.Mutable.SizedData.Vector.Storable.SizedData.Vector.Generic.MutableMVector Data.VectorlengthData.Vector.GenericVectorSizedControl.ApplicativeZipListData.Vector.StorableMutableData.Vector.MutableDataVGindexMData.Vector.Storable.MutableStorable$fGenericMVector $fDataMVector$fStorableMVector$fNFDataMVectorlength'nullsliceslice'inittailtaketake'dropdrop'splitAtsplitAt'overlapsnew unsafeNew replicate replicate' replicateM replicateM'clonegrow growFrontclearreadread' unsafeReadwritewrite' unsafeWritemodifymodify' unsafeModifyswap unsafeSwapexchange exchange'unsafeExchangenextPermutationsetcopy unsafeCopymovetoSized withSized fromSized $fShowVector $fEqVector $fOrdVector$fFunctorVector$fFoldableVector$fTraversableVector$fNFDataVector$fGenericVector $fShow1Vector $fEq1Vector $fOrd1Vector $fDataVector knownLength knownLength'indexindex' unsafeIndexheadlastix_head_lastindexM' unsafeIndexMheadMlastMempty singleton fromTuplegenerate generate'iterateN iterateN' generateM generateM'unfoldrN unfoldrN' enumFromN enumFromN' enumFromStepNenumFromStepN'conssnoc++force//updateupdate_ unsafeUpd unsafeUpdate unsafeUpdate_accum accumulate accumulate_ unsafeAccumunsafeAccumulateunsafeAccumulate_reverse backpermuteunsafeBackpermuteindexedmapimap concatMapmapMimapMmapM_imapM_forMforM_zipWithzipWith3zipWith4zipWith5zipWith6izipWith izipWith3 izipWith4 izipWith5 izipWith6zipzip3zip4zip5zip6zipWithM izipWithM zipWithM_ izipWithM_unzipunzip3unzip4unzip5unzip6elemnotElemfind findIndex elemIndexfoldlfoldl1foldl'foldl1'foldrfoldr1foldr'foldr1'ifoldlifoldl'ifoldrifoldr'allanyandorsumproductmaximum maximumByminimum minimumBymaxIndex maxIndexByminIndex minIndexByfoldMifoldMfold1MfoldM'ifoldM'fold1M'foldM_ifoldM_fold1M_foldM'_ifoldM'_fold1M'_sequence sequence_prescanl prescanl' postscanl postscanl'scanlscanl'scanl1scanl1'prescanr prescanr' postscanr postscanr'scanrscanr'scanr1scanr1'toListfromList fromListN fromListN' withSizedListconvertfreeze unsafeFreezethaw unsafeThawwithVectorUnsafe$fFloatingVector$fFractionalVector $fNumVector$fRepresentableVector$fDistributiveVector$fMonoidVector$fSemigroupVector$fApplicativeVector$fStorableVector $fReadVectorghc-prim GHC.TypesIntbase Data.ProxyProxy.finite-typelits-0.1.3.0-HWLAJONdZTFFx5hRCyDKcLData.Finite.InternalFiniteFalse GHC.TypeLitsnatVal GHC.TypeNatsKnownNat&vector-0.12.0.1-JlawpRjIcMJIYPJVsWriIAGHC.BaseJustNothingTrueMonoidmemptyData.Semigroup Semigroup Applicative