<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<!-- Generated by HsColour, http://code.haskell.org/~malcolm/hscolour/ -->
<title>Data/Vector/Primitive.hs</title>
<link type='text/css' rel='stylesheet' href='hscolour.css' />
</head>
<body>
<pre><a name="line-1"></a><span class='hs-comment'>{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeFamilies, ScopedTypeVariables, Rank2Types #-}</span>
<a name="line-2"></a>
<a name="line-3"></a><span class='hs-comment'>-- |</span>
<a name="line-4"></a><span class='hs-comment'>-- Module : Data.Vector.Primitive</span>
<a name="line-5"></a><span class='hs-comment'>-- Copyright : (c) Roman Leshchinskiy 2008-2010</span>
<a name="line-6"></a><span class='hs-comment'>-- License : BSD-style</span>
<a name="line-7"></a><span class='hs-comment'>--</span>
<a name="line-8"></a><span class='hs-comment'>-- Maintainer : Roman Leshchinskiy <rl@cse.unsw.edu.au></span>
<a name="line-9"></a><span class='hs-comment'>-- Stability : experimental</span>
<a name="line-10"></a><span class='hs-comment'>-- Portability : non-portable</span>
<a name="line-11"></a><span class='hs-comment'>-- </span>
<a name="line-12"></a><span class='hs-comment'>-- Unboxed vectors of primitive types. The use of this module is not</span>
<a name="line-13"></a><span class='hs-comment'>-- recommended except in very special cases. Adaptive unboxed vectors defined</span>
<a name="line-14"></a><span class='hs-comment'>-- in "Data.Vector.Unboxed" are significantly more flexible at no performance</span>
<a name="line-15"></a><span class='hs-comment'>-- cost.</span>
<a name="line-16"></a><span class='hs-comment'>--</span>
<a name="line-17"></a>
<a name="line-18"></a><span class='hs-keyword'>module</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Vector</span><span class='hs-varop'>.</span><span class='hs-conid'>Primitive</span> <span class='hs-layout'>(</span>
<a name="line-19"></a> <span class='hs-comment'>-- * Primitive vectors</span>
<a name="line-20"></a> <span class='hs-conid'>Vector</span><span class='hs-layout'>,</span> <span class='hs-conid'>MVector</span><span class='hs-layout'>(</span><span class='hs-keyglyph'>..</span><span class='hs-layout'>)</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span><span class='hs-layout'>,</span>
<a name="line-21"></a>
<a name="line-22"></a> <span class='hs-comment'>-- * Accessors</span>
<a name="line-23"></a>
<a name="line-24"></a> <span class='hs-comment'>-- ** Length information</span>
<a name="line-25"></a> <span class='hs-varid'>length</span><span class='hs-layout'>,</span> <span class='hs-varid'>null</span><span class='hs-layout'>,</span>
<a name="line-26"></a>
<a name="line-27"></a> <span class='hs-comment'>-- ** Indexing</span>
<a name="line-28"></a> <span class='hs-layout'>(</span><span class='hs-varop'>!</span><span class='hs-layout'>)</span><span class='hs-layout'>,</span> <span class='hs-layout'>(</span><span class='hs-varop'>!?</span><span class='hs-layout'>)</span><span class='hs-layout'>,</span> <span class='hs-varid'>head</span><span class='hs-layout'>,</span> <span class='hs-varid'>last</span><span class='hs-layout'>,</span>
<a name="line-29"></a> <span class='hs-varid'>unsafeIndex</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeHead</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeLast</span><span class='hs-layout'>,</span>
<a name="line-30"></a>
<a name="line-31"></a> <span class='hs-comment'>-- ** Monadic indexing</span>
<a name="line-32"></a> <span class='hs-varid'>indexM</span><span class='hs-layout'>,</span> <span class='hs-varid'>headM</span><span class='hs-layout'>,</span> <span class='hs-varid'>lastM</span><span class='hs-layout'>,</span>
<a name="line-33"></a> <span class='hs-varid'>unsafeIndexM</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeHeadM</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeLastM</span><span class='hs-layout'>,</span>
<a name="line-34"></a>
<a name="line-35"></a> <span class='hs-comment'>-- ** Extracting subvectors (slicing)</span>
<a name="line-36"></a> <span class='hs-varid'>slice</span><span class='hs-layout'>,</span> <span class='hs-varid'>init</span><span class='hs-layout'>,</span> <span class='hs-varid'>tail</span><span class='hs-layout'>,</span> <span class='hs-varid'>take</span><span class='hs-layout'>,</span> <span class='hs-varid'>drop</span><span class='hs-layout'>,</span> <span class='hs-varid'>splitAt</span><span class='hs-layout'>,</span>
<a name="line-37"></a> <span class='hs-varid'>unsafeSlice</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeInit</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeTail</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeTake</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeDrop</span><span class='hs-layout'>,</span>
<a name="line-38"></a>
<a name="line-39"></a> <span class='hs-comment'>-- * Construction</span>
<a name="line-40"></a>
<a name="line-41"></a> <span class='hs-comment'>-- ** Initialisation</span>
<a name="line-42"></a> <span class='hs-varid'>empty</span><span class='hs-layout'>,</span> <span class='hs-varid'>singleton</span><span class='hs-layout'>,</span> <span class='hs-varid'>replicate</span><span class='hs-layout'>,</span> <span class='hs-varid'>generate</span><span class='hs-layout'>,</span> <span class='hs-varid'>iterateN</span><span class='hs-layout'>,</span>
<a name="line-43"></a>
<a name="line-44"></a> <span class='hs-comment'>-- ** Monadic initialisation</span>
<a name="line-45"></a> <span class='hs-varid'>replicateM</span><span class='hs-layout'>,</span> <span class='hs-varid'>generateM</span><span class='hs-layout'>,</span> <span class='hs-varid'>create</span><span class='hs-layout'>,</span>
<a name="line-46"></a>
<a name="line-47"></a> <span class='hs-comment'>-- ** Unfolding</span>
<a name="line-48"></a> <span class='hs-varid'>unfoldr</span><span class='hs-layout'>,</span> <span class='hs-varid'>unfoldrN</span><span class='hs-layout'>,</span>
<a name="line-49"></a> <span class='hs-varid'>constructN</span><span class='hs-layout'>,</span> <span class='hs-varid'>constructrN</span><span class='hs-layout'>,</span>
<a name="line-50"></a>
<a name="line-51"></a> <span class='hs-comment'>-- ** Enumeration</span>
<a name="line-52"></a> <span class='hs-varid'>enumFromN</span><span class='hs-layout'>,</span> <span class='hs-varid'>enumFromStepN</span><span class='hs-layout'>,</span> <span class='hs-varid'>enumFromTo</span><span class='hs-layout'>,</span> <span class='hs-varid'>enumFromThenTo</span><span class='hs-layout'>,</span>
<a name="line-53"></a>
<a name="line-54"></a> <span class='hs-comment'>-- ** Concatenation</span>
<a name="line-55"></a> <span class='hs-varid'>cons</span><span class='hs-layout'>,</span> <span class='hs-varid'>snoc</span><span class='hs-layout'>,</span> <span class='hs-layout'>(</span><span class='hs-varop'>++</span><span class='hs-layout'>)</span><span class='hs-layout'>,</span> <span class='hs-varid'>concat</span><span class='hs-layout'>,</span>
<a name="line-56"></a>
<a name="line-57"></a> <span class='hs-comment'>-- ** Restricting memory usage</span>
<a name="line-58"></a> <span class='hs-varid'>force</span><span class='hs-layout'>,</span>
<a name="line-59"></a>
<a name="line-60"></a> <span class='hs-comment'>-- * Modifying vectors</span>
<a name="line-61"></a>
<a name="line-62"></a> <span class='hs-comment'>-- ** Bulk updates</span>
<a name="line-63"></a> <span class='hs-layout'>(</span><span class='hs-varop'>//</span><span class='hs-layout'>)</span><span class='hs-layout'>,</span> <span class='hs-varid'>update_</span><span class='hs-layout'>,</span>
<a name="line-64"></a> <span class='hs-varid'>unsafeUpd</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeUpdate_</span><span class='hs-layout'>,</span>
<a name="line-65"></a>
<a name="line-66"></a> <span class='hs-comment'>-- ** Accumulations</span>
<a name="line-67"></a> <span class='hs-varid'>accum</span><span class='hs-layout'>,</span> <span class='hs-varid'>accumulate_</span><span class='hs-layout'>,</span>
<a name="line-68"></a> <span class='hs-varid'>unsafeAccum</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeAccumulate_</span><span class='hs-layout'>,</span>
<a name="line-69"></a>
<a name="line-70"></a> <span class='hs-comment'>-- ** Permutations </span>
<a name="line-71"></a> <span class='hs-varid'>reverse</span><span class='hs-layout'>,</span> <span class='hs-varid'>backpermute</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeBackpermute</span><span class='hs-layout'>,</span>
<a name="line-72"></a>
<a name="line-73"></a> <span class='hs-comment'>-- ** Safe destructive updates</span>
<a name="line-74"></a> <span class='hs-varid'>modify</span><span class='hs-layout'>,</span>
<a name="line-75"></a>
<a name="line-76"></a> <span class='hs-comment'>-- * Elementwise operations</span>
<a name="line-77"></a>
<a name="line-78"></a> <span class='hs-comment'>-- ** Mapping</span>
<a name="line-79"></a> <span class='hs-varid'>map</span><span class='hs-layout'>,</span> <span class='hs-varid'>imap</span><span class='hs-layout'>,</span> <span class='hs-varid'>concatMap</span><span class='hs-layout'>,</span>
<a name="line-80"></a>
<a name="line-81"></a> <span class='hs-comment'>-- ** Monadic mapping</span>
<a name="line-82"></a> <span class='hs-varid'>mapM</span><span class='hs-layout'>,</span> <span class='hs-varid'>mapM_</span><span class='hs-layout'>,</span> <span class='hs-varid'>forM</span><span class='hs-layout'>,</span> <span class='hs-varid'>forM_</span><span class='hs-layout'>,</span>
<a name="line-83"></a>
<a name="line-84"></a> <span class='hs-comment'>-- ** Zipping</span>
<a name="line-85"></a> <span class='hs-varid'>zipWith</span><span class='hs-layout'>,</span> <span class='hs-varid'>zipWith3</span><span class='hs-layout'>,</span> <span class='hs-varid'>zipWith4</span><span class='hs-layout'>,</span> <span class='hs-varid'>zipWith5</span><span class='hs-layout'>,</span> <span class='hs-varid'>zipWith6</span><span class='hs-layout'>,</span>
<a name="line-86"></a> <span class='hs-varid'>izipWith</span><span class='hs-layout'>,</span> <span class='hs-varid'>izipWith3</span><span class='hs-layout'>,</span> <span class='hs-varid'>izipWith4</span><span class='hs-layout'>,</span> <span class='hs-varid'>izipWith5</span><span class='hs-layout'>,</span> <span class='hs-varid'>izipWith6</span><span class='hs-layout'>,</span>
<a name="line-87"></a>
<a name="line-88"></a> <span class='hs-comment'>-- ** Monadic zipping</span>
<a name="line-89"></a> <span class='hs-varid'>zipWithM</span><span class='hs-layout'>,</span> <span class='hs-varid'>zipWithM_</span><span class='hs-layout'>,</span>
<a name="line-90"></a>
<a name="line-91"></a> <span class='hs-comment'>-- * Working with predicates</span>
<a name="line-92"></a>
<a name="line-93"></a> <span class='hs-comment'>-- ** Filtering</span>
<a name="line-94"></a> <span class='hs-varid'>filter</span><span class='hs-layout'>,</span> <span class='hs-varid'>ifilter</span><span class='hs-layout'>,</span> <span class='hs-varid'>filterM</span><span class='hs-layout'>,</span>
<a name="line-95"></a> <span class='hs-varid'>takeWhile</span><span class='hs-layout'>,</span> <span class='hs-varid'>dropWhile</span><span class='hs-layout'>,</span>
<a name="line-96"></a>
<a name="line-97"></a> <span class='hs-comment'>-- ** Partitioning</span>
<a name="line-98"></a> <span class='hs-varid'>partition</span><span class='hs-layout'>,</span> <span class='hs-varid'>unstablePartition</span><span class='hs-layout'>,</span> <span class='hs-varid'>span</span><span class='hs-layout'>,</span> <span class='hs-varid'>break</span><span class='hs-layout'>,</span>
<a name="line-99"></a>
<a name="line-100"></a> <span class='hs-comment'>-- ** Searching</span>
<a name="line-101"></a> <span class='hs-varid'>elem</span><span class='hs-layout'>,</span> <span class='hs-varid'>notElem</span><span class='hs-layout'>,</span> <span class='hs-varid'>find</span><span class='hs-layout'>,</span> <span class='hs-varid'>findIndex</span><span class='hs-layout'>,</span> <span class='hs-varid'>findIndices</span><span class='hs-layout'>,</span> <span class='hs-varid'>elemIndex</span><span class='hs-layout'>,</span> <span class='hs-varid'>elemIndices</span><span class='hs-layout'>,</span>
<a name="line-102"></a>
<a name="line-103"></a> <span class='hs-comment'>-- * Folding</span>
<a name="line-104"></a> <span class='hs-varid'>foldl</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldl1</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldl'</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldl1'</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldr</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldr1</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldr'</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldr1'</span><span class='hs-layout'>,</span>
<a name="line-105"></a> <span class='hs-varid'>ifoldl</span><span class='hs-layout'>,</span> <span class='hs-varid'>ifoldl'</span><span class='hs-layout'>,</span> <span class='hs-varid'>ifoldr</span><span class='hs-layout'>,</span> <span class='hs-varid'>ifoldr'</span><span class='hs-layout'>,</span>
<a name="line-106"></a>
<a name="line-107"></a> <span class='hs-comment'>-- ** Specialised folds</span>
<a name="line-108"></a> <span class='hs-varid'>all</span><span class='hs-layout'>,</span> <span class='hs-varid'>any</span><span class='hs-layout'>,</span>
<a name="line-109"></a> <span class='hs-varid'>sum</span><span class='hs-layout'>,</span> <span class='hs-varid'>product</span><span class='hs-layout'>,</span>
<a name="line-110"></a> <span class='hs-varid'>maximum</span><span class='hs-layout'>,</span> <span class='hs-varid'>maximumBy</span><span class='hs-layout'>,</span> <span class='hs-varid'>minimum</span><span class='hs-layout'>,</span> <span class='hs-varid'>minimumBy</span><span class='hs-layout'>,</span>
<a name="line-111"></a> <span class='hs-varid'>minIndex</span><span class='hs-layout'>,</span> <span class='hs-varid'>minIndexBy</span><span class='hs-layout'>,</span> <span class='hs-varid'>maxIndex</span><span class='hs-layout'>,</span> <span class='hs-varid'>maxIndexBy</span><span class='hs-layout'>,</span>
<a name="line-112"></a>
<a name="line-113"></a> <span class='hs-comment'>-- ** Monadic folds</span>
<a name="line-114"></a> <span class='hs-varid'>foldM</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldM'</span><span class='hs-layout'>,</span> <span class='hs-varid'>fold1M</span><span class='hs-layout'>,</span> <span class='hs-varid'>fold1M'</span><span class='hs-layout'>,</span>
<a name="line-115"></a> <span class='hs-varid'>foldM_</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldM'_</span><span class='hs-layout'>,</span> <span class='hs-varid'>fold1M_</span><span class='hs-layout'>,</span> <span class='hs-varid'>fold1M'_</span><span class='hs-layout'>,</span>
<a name="line-116"></a>
<a name="line-117"></a> <span class='hs-comment'>-- * Prefix sums (scans)</span>
<a name="line-118"></a> <span class='hs-varid'>prescanl</span><span class='hs-layout'>,</span> <span class='hs-varid'>prescanl'</span><span class='hs-layout'>,</span>
<a name="line-119"></a> <span class='hs-varid'>postscanl</span><span class='hs-layout'>,</span> <span class='hs-varid'>postscanl'</span><span class='hs-layout'>,</span>
<a name="line-120"></a> <span class='hs-varid'>scanl</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanl'</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanl1</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanl1'</span><span class='hs-layout'>,</span>
<a name="line-121"></a> <span class='hs-varid'>prescanr</span><span class='hs-layout'>,</span> <span class='hs-varid'>prescanr'</span><span class='hs-layout'>,</span>
<a name="line-122"></a> <span class='hs-varid'>postscanr</span><span class='hs-layout'>,</span> <span class='hs-varid'>postscanr'</span><span class='hs-layout'>,</span>
<a name="line-123"></a> <span class='hs-varid'>scanr</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanr'</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanr1</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanr1'</span><span class='hs-layout'>,</span>
<a name="line-124"></a>
<a name="line-125"></a> <span class='hs-comment'>-- * Conversions</span>
<a name="line-126"></a>
<a name="line-127"></a> <span class='hs-comment'>-- ** Lists</span>
<a name="line-128"></a> <span class='hs-varid'>toList</span><span class='hs-layout'>,</span> <span class='hs-varid'>fromList</span><span class='hs-layout'>,</span> <span class='hs-varid'>fromListN</span><span class='hs-layout'>,</span>
<a name="line-129"></a>
<a name="line-130"></a> <span class='hs-comment'>-- ** Other vector types</span>
<a name="line-131"></a> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>convert</span><span class='hs-layout'>,</span>
<a name="line-132"></a>
<a name="line-133"></a> <span class='hs-comment'>-- ** Mutable vectors</span>
<a name="line-134"></a> <span class='hs-varid'>freeze</span><span class='hs-layout'>,</span> <span class='hs-varid'>thaw</span><span class='hs-layout'>,</span> <span class='hs-varid'>copy</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeFreeze</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeThaw</span><span class='hs-layout'>,</span> <span class='hs-varid'>unsafeCopy</span>
<a name="line-135"></a><span class='hs-layout'>)</span> <span class='hs-keyword'>where</span>
<a name="line-136"></a>
<a name="line-137"></a><span class='hs-keyword'>import</span> <span class='hs-keyword'>qualified</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Vector</span><span class='hs-varop'>.</span><span class='hs-conid'>Generic</span> <span class='hs-keyword'>as</span> <span class='hs-conid'>G</span>
<a name="line-138"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Vector</span><span class='hs-varop'>.</span><span class='hs-conid'>Primitive</span><span class='hs-varop'>.</span><span class='hs-conid'>Mutable</span> <span class='hs-layout'>(</span> <span class='hs-conid'>MVector</span><span class='hs-layout'>(</span><span class='hs-keyglyph'>..</span><span class='hs-layout'>)</span> <span class='hs-layout'>)</span>
<a name="line-139"></a><span class='hs-keyword'>import</span> <span class='hs-keyword'>qualified</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Vector</span><span class='hs-varop'>.</span><span class='hs-conid'>Fusion</span><span class='hs-varop'>.</span><span class='hs-conid'>Stream</span> <span class='hs-keyword'>as</span> <span class='hs-conid'>Stream</span>
<a name="line-140"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Primitive</span><span class='hs-varop'>.</span><span class='hs-conid'>ByteArray</span>
<a name="line-141"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Primitive</span> <span class='hs-layout'>(</span> <span class='hs-conid'>Prim</span><span class='hs-layout'>,</span> <span class='hs-varid'>sizeOf</span> <span class='hs-layout'>)</span>
<a name="line-142"></a>
<a name="line-143"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Control</span><span class='hs-varop'>.</span><span class='hs-conid'>Monad</span> <span class='hs-layout'>(</span> <span class='hs-varid'>liftM</span> <span class='hs-layout'>)</span>
<a name="line-144"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Control</span><span class='hs-varop'>.</span><span class='hs-conid'>Monad</span><span class='hs-varop'>.</span><span class='hs-conid'>ST</span> <span class='hs-layout'>(</span> <span class='hs-conid'>ST</span> <span class='hs-layout'>)</span>
<a name="line-145"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Control</span><span class='hs-varop'>.</span><span class='hs-conid'>Monad</span><span class='hs-varop'>.</span><span class='hs-conid'>Primitive</span>
<a name="line-146"></a>
<a name="line-147"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Prelude</span> <span class='hs-varid'>hiding</span> <span class='hs-layout'>(</span> <span class='hs-varid'>length</span><span class='hs-layout'>,</span> <span class='hs-varid'>null</span><span class='hs-layout'>,</span>
<a name="line-148"></a> <span class='hs-varid'>replicate</span><span class='hs-layout'>,</span> <span class='hs-layout'>(</span><span class='hs-varop'>++</span><span class='hs-layout'>)</span><span class='hs-layout'>,</span> <span class='hs-varid'>concat</span><span class='hs-layout'>,</span>
<a name="line-149"></a> <span class='hs-varid'>head</span><span class='hs-layout'>,</span> <span class='hs-varid'>last</span><span class='hs-layout'>,</span>
<a name="line-150"></a> <span class='hs-varid'>init</span><span class='hs-layout'>,</span> <span class='hs-varid'>tail</span><span class='hs-layout'>,</span> <span class='hs-varid'>take</span><span class='hs-layout'>,</span> <span class='hs-varid'>drop</span><span class='hs-layout'>,</span> <span class='hs-varid'>splitAt</span><span class='hs-layout'>,</span> <span class='hs-varid'>reverse</span><span class='hs-layout'>,</span>
<a name="line-151"></a> <span class='hs-varid'>map</span><span class='hs-layout'>,</span> <span class='hs-varid'>concatMap</span><span class='hs-layout'>,</span>
<a name="line-152"></a> <span class='hs-varid'>zipWith</span><span class='hs-layout'>,</span> <span class='hs-varid'>zipWith3</span><span class='hs-layout'>,</span> <span class='hs-varid'>zip</span><span class='hs-layout'>,</span> <span class='hs-varid'>zip3</span><span class='hs-layout'>,</span> <span class='hs-varid'>unzip</span><span class='hs-layout'>,</span> <span class='hs-varid'>unzip3</span><span class='hs-layout'>,</span>
<a name="line-153"></a> <span class='hs-varid'>filter</span><span class='hs-layout'>,</span> <span class='hs-varid'>takeWhile</span><span class='hs-layout'>,</span> <span class='hs-varid'>dropWhile</span><span class='hs-layout'>,</span> <span class='hs-varid'>span</span><span class='hs-layout'>,</span> <span class='hs-varid'>break</span><span class='hs-layout'>,</span>
<a name="line-154"></a> <span class='hs-varid'>elem</span><span class='hs-layout'>,</span> <span class='hs-varid'>notElem</span><span class='hs-layout'>,</span>
<a name="line-155"></a> <span class='hs-varid'>foldl</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldl1</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldr</span><span class='hs-layout'>,</span> <span class='hs-varid'>foldr1</span><span class='hs-layout'>,</span>
<a name="line-156"></a> <span class='hs-varid'>all</span><span class='hs-layout'>,</span> <span class='hs-varid'>any</span><span class='hs-layout'>,</span> <span class='hs-varid'>sum</span><span class='hs-layout'>,</span> <span class='hs-varid'>product</span><span class='hs-layout'>,</span> <span class='hs-varid'>minimum</span><span class='hs-layout'>,</span> <span class='hs-varid'>maximum</span><span class='hs-layout'>,</span>
<a name="line-157"></a> <span class='hs-varid'>scanl</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanl1</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanr</span><span class='hs-layout'>,</span> <span class='hs-varid'>scanr1</span><span class='hs-layout'>,</span>
<a name="line-158"></a> <span class='hs-varid'>enumFromTo</span><span class='hs-layout'>,</span> <span class='hs-varid'>enumFromThenTo</span><span class='hs-layout'>,</span>
<a name="line-159"></a> <span class='hs-varid'>mapM</span><span class='hs-layout'>,</span> <span class='hs-varid'>mapM_</span> <span class='hs-layout'>)</span>
<a name="line-160"></a>
<a name="line-161"></a><span class='hs-keyword'>import</span> <span class='hs-keyword'>qualified</span> <span class='hs-conid'>Prelude</span>
<a name="line-162"></a>
<a name="line-163"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Typeable</span> <span class='hs-layout'>(</span> <span class='hs-conid'>Typeable</span> <span class='hs-layout'>)</span>
<a name="line-164"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Data</span> <span class='hs-layout'>(</span> <span class='hs-conid'>Data</span><span class='hs-layout'>(</span><span class='hs-keyglyph'>..</span><span class='hs-layout'>)</span> <span class='hs-layout'>)</span>
<a name="line-165"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Text</span><span class='hs-varop'>.</span><span class='hs-conid'>Read</span> <span class='hs-layout'>(</span> <span class='hs-conid'>Read</span><span class='hs-layout'>(</span><span class='hs-keyglyph'>..</span><span class='hs-layout'>)</span><span class='hs-layout'>,</span> <span class='hs-varid'>readListPrecDefault</span> <span class='hs-layout'>)</span>
<a name="line-166"></a>
<a name="line-167"></a><span class='hs-keyword'>import</span> <span class='hs-conid'>Data</span><span class='hs-varop'>.</span><span class='hs-conid'>Monoid</span> <span class='hs-layout'>(</span> <span class='hs-conid'>Monoid</span><span class='hs-layout'>(</span><span class='hs-keyglyph'>..</span><span class='hs-layout'>)</span> <span class='hs-layout'>)</span>
<a name="line-168"></a>
<a name="line-169"></a><a name="Vector"></a><span class='hs-comment'>-- | Unboxed vectors of primitive types</span>
<a name="line-170"></a><a name="Vector"></a><span class='hs-keyword'>data</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Vector</span> <span class='hs-comment'>{-# UNPACK #-}</span> <span class='hs-varop'>!</span><span class='hs-conid'>Int</span>
<a name="line-171"></a> <span class='hs-comment'>{-# UNPACK #-}</span> <span class='hs-varop'>!</span><span class='hs-conid'>Int</span>
<a name="line-172"></a> <span class='hs-comment'>{-# UNPACK #-}</span> <span class='hs-varop'>!</span><span class='hs-conid'>ByteArray</span>
<a name="line-173"></a> <span class='hs-keyword'>deriving</span> <span class='hs-layout'>(</span> <span class='hs-conid'>Typeable</span> <span class='hs-layout'>)</span>
<a name="line-174"></a>
<a name="line-175"></a><a name="instance%20Show%20(Vector%20a)"></a><span class='hs-keyword'>instance</span> <span class='hs-layout'>(</span><span class='hs-conid'>Show</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Show</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyword'>where</span>
<a name="line-176"></a> <span class='hs-varid'>showsPrec</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>showsPrec</span>
<a name="line-177"></a>
<a name="line-178"></a><a name="instance%20Read%20(Vector%20a)"></a><span class='hs-keyword'>instance</span> <span class='hs-layout'>(</span><span class='hs-conid'>Read</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Read</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyword'>where</span>
<a name="line-179"></a> <span class='hs-varid'>readPrec</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>readPrec</span>
<a name="line-180"></a> <span class='hs-varid'>readListPrec</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>readListPrecDefault</span>
<a name="line-181"></a>
<a name="line-182"></a><a name="instance%20Data%20(Vector%20a)"></a><span class='hs-keyword'>instance</span> <span class='hs-layout'>(</span><span class='hs-conid'>Data</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Data</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyword'>where</span>
<a name="line-183"></a> <span class='hs-varid'>gfoldl</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>gfoldl</span>
<a name="line-184"></a> <span class='hs-varid'>toConstr</span> <span class='hs-keyword'>_</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>error</span> <span class='hs-str'>"toConstr"</span>
<a name="line-185"></a> <span class='hs-varid'>gunfold</span> <span class='hs-keyword'>_</span> <span class='hs-keyword'>_</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>error</span> <span class='hs-str'>"gunfold"</span>
<a name="line-186"></a> <span class='hs-varid'>dataTypeOf</span> <span class='hs-keyword'>_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>mkType</span> <span class='hs-str'>"Data.Vector.Primitive.Vector"</span>
<a name="line-187"></a> <span class='hs-varid'>dataCast1</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>dataCast</span>
<a name="line-188"></a>
<a name="line-189"></a>
<a name="line-190"></a><span class='hs-keyword'>type</span> <span class='hs-keyword'>instance</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-conid'>Mutable</span> <span class='hs-conid'>Vector</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>MVector</span>
<a name="line-191"></a>
<a name="line-192"></a><a name="instance%20G.Vector%20Vector%20a"></a><span class='hs-keyword'>instance</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-conid'>Vector</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyword'>where</span>
<a name="line-193"></a> <span class='hs-comment'>{-# INLINE basicUnsafeFreeze #-}</span>
<a name="line-194"></a> <span class='hs-varid'>basicUnsafeFreeze</span> <span class='hs-layout'>(</span><span class='hs-conid'>MVector</span> <span class='hs-varid'>i</span> <span class='hs-varid'>n</span> <span class='hs-varid'>marr</span><span class='hs-layout'>)</span>
<a name="line-195"></a> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>i</span> <span class='hs-varid'>n</span> <span class='hs-varop'>`liftM`</span> <span class='hs-varid'>unsafeFreezeByteArray</span> <span class='hs-varid'>marr</span>
<a name="line-196"></a>
<a name="line-197"></a> <span class='hs-comment'>{-# INLINE basicUnsafeThaw #-}</span>
<a name="line-198"></a> <span class='hs-varid'>basicUnsafeThaw</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>i</span> <span class='hs-varid'>n</span> <span class='hs-varid'>arr</span><span class='hs-layout'>)</span>
<a name="line-199"></a> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>MVector</span> <span class='hs-varid'>i</span> <span class='hs-varid'>n</span> <span class='hs-varop'>`liftM`</span> <span class='hs-varid'>unsafeThawByteArray</span> <span class='hs-varid'>arr</span>
<a name="line-200"></a>
<a name="line-201"></a> <span class='hs-comment'>{-# INLINE basicLength #-}</span>
<a name="line-202"></a> <span class='hs-varid'>basicLength</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-keyword'>_</span> <span class='hs-varid'>n</span> <span class='hs-keyword'>_</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>n</span>
<a name="line-203"></a>
<a name="line-204"></a> <span class='hs-comment'>{-# INLINE basicUnsafeSlice #-}</span>
<a name="line-205"></a> <span class='hs-varid'>basicUnsafeSlice</span> <span class='hs-varid'>j</span> <span class='hs-varid'>n</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>i</span> <span class='hs-keyword'>_</span> <span class='hs-varid'>arr</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Vector</span> <span class='hs-layout'>(</span><span class='hs-varid'>i</span><span class='hs-varop'>+</span><span class='hs-varid'>j</span><span class='hs-layout'>)</span> <span class='hs-varid'>n</span> <span class='hs-varid'>arr</span>
<a name="line-206"></a>
<a name="line-207"></a> <span class='hs-comment'>{-# INLINE basicUnsafeIndexM #-}</span>
<a name="line-208"></a> <span class='hs-varid'>basicUnsafeIndexM</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>i</span> <span class='hs-keyword'>_</span> <span class='hs-varid'>arr</span><span class='hs-layout'>)</span> <span class='hs-varid'>j</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>return</span> <span class='hs-layout'>(</span><span class='hs-varid'>indexByteArray</span> <span class='hs-varid'>arr</span> <span class='hs-layout'>(</span><span class='hs-varid'>i</span><span class='hs-varop'>+</span><span class='hs-varid'>j</span><span class='hs-layout'>)</span><span class='hs-layout'>)</span>
<a name="line-209"></a>
<a name="line-210"></a> <span class='hs-comment'>{-# INLINE basicUnsafeCopy #-}</span>
<a name="line-211"></a> <span class='hs-varid'>basicUnsafeCopy</span> <span class='hs-layout'>(</span><span class='hs-conid'>MVector</span> <span class='hs-varid'>i</span> <span class='hs-varid'>n</span> <span class='hs-varid'>dst</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>j</span> <span class='hs-keyword'>_</span> <span class='hs-varid'>src</span><span class='hs-layout'>)</span>
<a name="line-212"></a> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>copyByteArray</span> <span class='hs-varid'>dst</span> <span class='hs-layout'>(</span><span class='hs-varid'>i</span><span class='hs-varop'>*</span><span class='hs-varid'>sz</span><span class='hs-layout'>)</span> <span class='hs-varid'>src</span> <span class='hs-layout'>(</span><span class='hs-varid'>j</span><span class='hs-varop'>*</span><span class='hs-varid'>sz</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-varid'>n</span><span class='hs-varop'>*</span><span class='hs-varid'>sz</span><span class='hs-layout'>)</span>
<a name="line-213"></a> <span class='hs-keyword'>where</span>
<a name="line-214"></a> <span class='hs-varid'>sz</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>sizeOf</span> <span class='hs-layout'>(</span><span class='hs-varid'>undefined</span> <span class='hs-keyglyph'>::</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-215"></a>
<a name="line-216"></a> <span class='hs-comment'>{-# INLINE elemseq #-}</span>
<a name="line-217"></a> <span class='hs-varid'>elemseq</span> <span class='hs-keyword'>_</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>seq</span>
<a name="line-218"></a>
<a name="line-219"></a><a name="instance%20Eq%20(Vector%20a)"></a><span class='hs-comment'>-- See <a href="http://trac.haskell.org/vector/ticket/12">http://trac.haskell.org/vector/ticket/12</a></span>
<a name="line-220"></a><a name="instance%20Eq%20(Vector%20a)"></a><span class='hs-keyword'>instance</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Eq</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Eq</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyword'>where</span>
<a name="line-221"></a> <span class='hs-comment'>{-# INLINE (==) #-}</span>
<a name="line-222"></a> <span class='hs-varid'>xs</span> <span class='hs-varop'>==</span> <span class='hs-varid'>ys</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Stream</span><span class='hs-varop'>.</span><span class='hs-varid'>eq</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>xs</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>ys</span><span class='hs-layout'>)</span>
<a name="line-223"></a>
<a name="line-224"></a> <span class='hs-comment'>{-# INLINE (/=) #-}</span>
<a name="line-225"></a> <span class='hs-varid'>xs</span> <span class='hs-varop'>/=</span> <span class='hs-varid'>ys</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>not</span> <span class='hs-layout'>(</span><span class='hs-conid'>Stream</span><span class='hs-varop'>.</span><span class='hs-varid'>eq</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>xs</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>ys</span><span class='hs-layout'>)</span><span class='hs-layout'>)</span>
<a name="line-226"></a>
<a name="line-227"></a><a name="instance%20Ord%20(Vector%20a)"></a><span class='hs-comment'>-- See <a href="http://trac.haskell.org/vector/ticket/12">http://trac.haskell.org/vector/ticket/12</a></span>
<a name="line-228"></a><a name="instance%20Ord%20(Vector%20a)"></a><span class='hs-keyword'>instance</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Ord</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Ord</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyword'>where</span>
<a name="line-229"></a> <span class='hs-comment'>{-# INLINE compare #-}</span>
<a name="line-230"></a> <span class='hs-varid'>compare</span> <span class='hs-varid'>xs</span> <span class='hs-varid'>ys</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Stream</span><span class='hs-varop'>.</span><span class='hs-varid'>cmp</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>xs</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>ys</span><span class='hs-layout'>)</span>
<a name="line-231"></a>
<a name="line-232"></a> <span class='hs-comment'>{-# INLINE (<) #-}</span>
<a name="line-233"></a> <span class='hs-varid'>xs</span> <span class='hs-varop'><</span> <span class='hs-varid'>ys</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Stream</span><span class='hs-varop'>.</span><span class='hs-varid'>cmp</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>xs</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>ys</span><span class='hs-layout'>)</span> <span class='hs-varop'>==</span> <span class='hs-conid'>LT</span>
<a name="line-234"></a>
<a name="line-235"></a> <span class='hs-comment'>{-# INLINE (<=) #-}</span>
<a name="line-236"></a> <span class='hs-varid'>xs</span> <span class='hs-varop'><=</span> <span class='hs-varid'>ys</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Stream</span><span class='hs-varop'>.</span><span class='hs-varid'>cmp</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>xs</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>ys</span><span class='hs-layout'>)</span> <span class='hs-varop'>/=</span> <span class='hs-conid'>GT</span>
<a name="line-237"></a>
<a name="line-238"></a> <span class='hs-comment'>{-# INLINE (>) #-}</span>
<a name="line-239"></a> <span class='hs-varid'>xs</span> <span class='hs-varop'>></span> <span class='hs-varid'>ys</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Stream</span><span class='hs-varop'>.</span><span class='hs-varid'>cmp</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>xs</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>ys</span><span class='hs-layout'>)</span> <span class='hs-varop'>==</span> <span class='hs-conid'>GT</span>
<a name="line-240"></a>
<a name="line-241"></a> <span class='hs-comment'>{-# INLINE (>=) #-}</span>
<a name="line-242"></a> <span class='hs-varid'>xs</span> <span class='hs-varop'>>=</span> <span class='hs-varid'>ys</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>Stream</span><span class='hs-varop'>.</span><span class='hs-varid'>cmp</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>xs</span><span class='hs-layout'>)</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>stream</span> <span class='hs-varid'>ys</span><span class='hs-layout'>)</span> <span class='hs-varop'>/=</span> <span class='hs-conid'>LT</span>
<a name="line-243"></a>
<a name="line-244"></a><a name="instance%20Monoid%20(Vector%20a)"></a><span class='hs-keyword'>instance</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Monoid</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyword'>where</span>
<a name="line-245"></a> <span class='hs-comment'>{-# INLINE mempty #-}</span>
<a name="line-246"></a> <span class='hs-varid'>mempty</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>empty</span>
<a name="line-247"></a>
<a name="line-248"></a> <span class='hs-comment'>{-# INLINE mappend #-}</span>
<a name="line-249"></a> <span class='hs-varid'>mappend</span> <span class='hs-keyglyph'>=</span> <span class='hs-layout'>(</span><span class='hs-varop'>++</span><span class='hs-layout'>)</span>
<a name="line-250"></a>
<a name="line-251"></a> <span class='hs-comment'>{-# INLINE mconcat #-}</span>
<a name="line-252"></a> <span class='hs-varid'>mconcat</span> <span class='hs-keyglyph'>=</span> <span class='hs-varid'>concat</span>
<a name="line-253"></a>
<a name="line-254"></a><span class='hs-comment'>-- Length</span>
<a name="line-255"></a><span class='hs-comment'>-- ------</span>
<a name="line-256"></a>
<a name="line-257"></a><a name="length"></a><span class='hs-comment'>-- | /O(1)/ Yield the length of the vector.</span>
<a name="line-258"></a><span class='hs-definition'>length</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span>
<a name="line-259"></a><span class='hs-comment'>{-# INLINE length #-}</span>
<a name="line-260"></a><span class='hs-definition'>length</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>length</span>
<a name="line-261"></a>
<a name="line-262"></a><a name="null"></a><span class='hs-comment'>-- | /O(1)/ Test whether a vector if empty</span>
<a name="line-263"></a><span class='hs-definition'>null</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span>
<a name="line-264"></a><span class='hs-comment'>{-# INLINE null #-}</span>
<a name="line-265"></a><span class='hs-definition'>null</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>null</span>
<a name="line-266"></a>
<a name="line-267"></a><span class='hs-comment'>-- Indexing</span>
<a name="line-268"></a><span class='hs-comment'>-- --------</span>
<a name="line-269"></a>
<a name="line-270"></a><a name="!"></a><span class='hs-comment'>-- | O(1) Indexing</span>
<a name="line-271"></a><span class='hs-layout'>(</span><span class='hs-varop'>!</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-272"></a><span class='hs-comment'>{-# INLINE (!) #-}</span>
<a name="line-273"></a><span class='hs-layout'>(</span><span class='hs-varop'>!</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.!</span><span class='hs-layout'>)</span>
<a name="line-274"></a>
<a name="line-275"></a><a name="!?"></a><span class='hs-comment'>-- | O(1) Safe indexing</span>
<a name="line-276"></a><span class='hs-layout'>(</span><span class='hs-varop'>!?</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Maybe</span> <span class='hs-varid'>a</span>
<a name="line-277"></a><span class='hs-comment'>{-# INLINE (!?) #-}</span>
<a name="line-278"></a><span class='hs-layout'>(</span><span class='hs-varop'>!?</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.!?</span><span class='hs-layout'>)</span>
<a name="line-279"></a>
<a name="line-280"></a><a name="head"></a><span class='hs-comment'>-- | /O(1)/ First element</span>
<a name="line-281"></a><span class='hs-definition'>head</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-282"></a><span class='hs-comment'>{-# INLINE head #-}</span>
<a name="line-283"></a><span class='hs-definition'>head</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>head</span>
<a name="line-284"></a>
<a name="line-285"></a><a name="last"></a><span class='hs-comment'>-- | /O(1)/ Last element</span>
<a name="line-286"></a><span class='hs-definition'>last</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-287"></a><span class='hs-comment'>{-# INLINE last #-}</span>
<a name="line-288"></a><span class='hs-definition'>last</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>last</span>
<a name="line-289"></a>
<a name="line-290"></a><a name="unsafeIndex"></a><span class='hs-comment'>-- | /O(1)/ Unsafe indexing without bounds checking</span>
<a name="line-291"></a><span class='hs-definition'>unsafeIndex</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-292"></a><span class='hs-comment'>{-# INLINE unsafeIndex #-}</span>
<a name="line-293"></a><span class='hs-definition'>unsafeIndex</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeIndex</span>
<a name="line-294"></a>
<a name="line-295"></a><a name="unsafeHead"></a><span class='hs-comment'>-- | /O(1)/ First element without checking if the vector is empty</span>
<a name="line-296"></a><span class='hs-definition'>unsafeHead</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-297"></a><span class='hs-comment'>{-# INLINE unsafeHead #-}</span>
<a name="line-298"></a><span class='hs-definition'>unsafeHead</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeHead</span>
<a name="line-299"></a>
<a name="line-300"></a><a name="unsafeLast"></a><span class='hs-comment'>-- | /O(1)/ Last element without checking if the vector is empty</span>
<a name="line-301"></a><span class='hs-definition'>unsafeLast</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-302"></a><span class='hs-comment'>{-# INLINE unsafeLast #-}</span>
<a name="line-303"></a><span class='hs-definition'>unsafeLast</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeLast</span>
<a name="line-304"></a>
<a name="line-305"></a><span class='hs-comment'>-- Monadic indexing</span>
<a name="line-306"></a><span class='hs-comment'>-- ----------------</span>
<a name="line-307"></a>
<a name="line-308"></a><a name="indexM"></a><span class='hs-comment'>-- | /O(1)/ Indexing in a monad.</span>
<a name="line-309"></a><span class='hs-comment'>--</span>
<a name="line-310"></a><span class='hs-comment'>-- The monad allows operations to be strict in the vector when necessary.</span>
<a name="line-311"></a><span class='hs-comment'>-- Suppose vector copying is implemented like this:</span>
<a name="line-312"></a><span class='hs-comment'>--</span>
<a name="line-313"></a><span class='hs-comment'>-- > copy mv v = ... write mv i (v ! i) ...</span>
<a name="line-314"></a><span class='hs-comment'>--</span>
<a name="line-315"></a><span class='hs-comment'>-- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@</span>
<a name="line-316"></a><span class='hs-comment'>-- would unnecessarily retain a reference to @v@ in each element written.</span>
<a name="line-317"></a><span class='hs-comment'>--</span>
<a name="line-318"></a><span class='hs-comment'>-- With 'indexM', copying can be implemented like this instead:</span>
<a name="line-319"></a><span class='hs-comment'>--</span>
<a name="line-320"></a><span class='hs-comment'>-- > copy mv v = ... do</span>
<a name="line-321"></a><span class='hs-comment'>-- > x <- indexM v i</span>
<a name="line-322"></a><span class='hs-comment'>-- > write mv i x</span>
<a name="line-323"></a><span class='hs-comment'>--</span>
<a name="line-324"></a><span class='hs-comment'>-- Here, no references to @v@ are retained because indexing (but /not/ the</span>
<a name="line-325"></a><span class='hs-comment'>-- elements) is evaluated eagerly.</span>
<a name="line-326"></a><span class='hs-comment'>--</span>
<a name="line-327"></a><span class='hs-definition'>indexM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-328"></a><span class='hs-comment'>{-# INLINE indexM #-}</span>
<a name="line-329"></a><span class='hs-definition'>indexM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>indexM</span>
<a name="line-330"></a>
<a name="line-331"></a><a name="headM"></a><span class='hs-comment'>-- | /O(1)/ First element of a vector in a monad. See 'indexM' for an</span>
<a name="line-332"></a><span class='hs-comment'>-- explanation of why this is useful.</span>
<a name="line-333"></a><span class='hs-definition'>headM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-334"></a><span class='hs-comment'>{-# INLINE headM #-}</span>
<a name="line-335"></a><span class='hs-definition'>headM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>headM</span>
<a name="line-336"></a>
<a name="line-337"></a><a name="lastM"></a><span class='hs-comment'>-- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an</span>
<a name="line-338"></a><span class='hs-comment'>-- explanation of why this is useful.</span>
<a name="line-339"></a><span class='hs-definition'>lastM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-340"></a><span class='hs-comment'>{-# INLINE lastM #-}</span>
<a name="line-341"></a><span class='hs-definition'>lastM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>lastM</span>
<a name="line-342"></a>
<a name="line-343"></a><a name="unsafeIndexM"></a><span class='hs-comment'>-- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an</span>
<a name="line-344"></a><span class='hs-comment'>-- explanation of why this is useful.</span>
<a name="line-345"></a><span class='hs-definition'>unsafeIndexM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-346"></a><span class='hs-comment'>{-# INLINE unsafeIndexM #-}</span>
<a name="line-347"></a><span class='hs-definition'>unsafeIndexM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeIndexM</span>
<a name="line-348"></a>
<a name="line-349"></a><a name="unsafeHeadM"></a><span class='hs-comment'>-- | /O(1)/ First element in a monad without checking for empty vectors.</span>
<a name="line-350"></a><span class='hs-comment'>-- See 'indexM' for an explanation of why this is useful.</span>
<a name="line-351"></a><span class='hs-definition'>unsafeHeadM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-352"></a><span class='hs-comment'>{-# INLINE unsafeHeadM #-}</span>
<a name="line-353"></a><span class='hs-definition'>unsafeHeadM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeHeadM</span>
<a name="line-354"></a>
<a name="line-355"></a><a name="unsafeLastM"></a><span class='hs-comment'>-- | /O(1)/ Last element in a monad without checking for empty vectors.</span>
<a name="line-356"></a><span class='hs-comment'>-- See 'indexM' for an explanation of why this is useful.</span>
<a name="line-357"></a><span class='hs-definition'>unsafeLastM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-358"></a><span class='hs-comment'>{-# INLINE unsafeLastM #-}</span>
<a name="line-359"></a><span class='hs-definition'>unsafeLastM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeLastM</span>
<a name="line-360"></a>
<a name="line-361"></a><span class='hs-comment'>-- Extracting subvectors (slicing)</span>
<a name="line-362"></a><span class='hs-comment'>-- -------------------------------</span>
<a name="line-363"></a>
<a name="line-364"></a><a name="slice"></a><span class='hs-comment'>-- | /O(1)/ Yield a slice of the vector without copying it. The vector must</span>
<a name="line-365"></a><span class='hs-comment'>-- contain at least @i+n@ elements.</span>
<a name="line-366"></a><span class='hs-definition'>slice</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span>
<a name="line-367"></a> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-comment'>-- ^ @i@ starting index</span>
<a name="line-368"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-comment'>-- ^ @n@ length</span>
<a name="line-369"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-370"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-371"></a><span class='hs-comment'>{-# INLINE slice #-}</span>
<a name="line-372"></a><span class='hs-definition'>slice</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>slice</span>
<a name="line-373"></a>
<a name="line-374"></a><a name="init"></a><span class='hs-comment'>-- | /O(1)/ Yield all but the last element without copying. The vector may not</span>
<a name="line-375"></a><span class='hs-comment'>-- be empty.</span>
<a name="line-376"></a><span class='hs-definition'>init</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-377"></a><span class='hs-comment'>{-# INLINE init #-}</span>
<a name="line-378"></a><span class='hs-definition'>init</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>init</span>
<a name="line-379"></a>
<a name="line-380"></a><a name="tail"></a><span class='hs-comment'>-- | /O(1)/ Yield all but the first element without copying. The vector may not</span>
<a name="line-381"></a><span class='hs-comment'>-- be empty.</span>
<a name="line-382"></a><span class='hs-definition'>tail</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-383"></a><span class='hs-comment'>{-# INLINE tail #-}</span>
<a name="line-384"></a><span class='hs-definition'>tail</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>tail</span>
<a name="line-385"></a>
<a name="line-386"></a><a name="take"></a><span class='hs-comment'>-- | /O(1)/ Yield at the first @n@ elements without copying. The vector may</span>
<a name="line-387"></a><span class='hs-comment'>-- contain less than @n@ elements in which case it is returned unchanged.</span>
<a name="line-388"></a><span class='hs-definition'>take</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-389"></a><span class='hs-comment'>{-# INLINE take #-}</span>
<a name="line-390"></a><span class='hs-definition'>take</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>take</span>
<a name="line-391"></a>
<a name="line-392"></a><a name="drop"></a><span class='hs-comment'>-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may</span>
<a name="line-393"></a><span class='hs-comment'>-- contain less than @n@ elements in which case an empty vector is returned.</span>
<a name="line-394"></a><span class='hs-definition'>drop</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-395"></a><span class='hs-comment'>{-# INLINE drop #-}</span>
<a name="line-396"></a><span class='hs-definition'>drop</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>drop</span>
<a name="line-397"></a>
<a name="line-398"></a><a name="splitAt"></a><span class='hs-comment'>-- | /O(1)/ Yield the first @n@ elements paired with the remainder without copying.</span>
<a name="line-399"></a><span class='hs-comment'>--</span>
<a name="line-400"></a><span class='hs-comment'>-- Note that @'splitAt' n v@ is equivalent to @('take' n v, 'drop' n v)@</span>
<a name="line-401"></a><span class='hs-comment'>-- but slightly more efficient.</span>
<a name="line-402"></a><span class='hs-comment'>{-# INLINE splitAt #-}</span>
<a name="line-403"></a><span class='hs-definition'>splitAt</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-404"></a><span class='hs-definition'>splitAt</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>splitAt</span>
<a name="line-405"></a>
<a name="line-406"></a><a name="unsafeSlice"></a><span class='hs-comment'>-- | /O(1)/ Yield a slice of the vector without copying. The vector must</span>
<a name="line-407"></a><span class='hs-comment'>-- contain at least @i+n@ elements but this is not checked.</span>
<a name="line-408"></a><span class='hs-definition'>unsafeSlice</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-comment'>-- ^ @i@ starting index</span>
<a name="line-409"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-comment'>-- ^ @n@ length</span>
<a name="line-410"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-411"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-412"></a><span class='hs-comment'>{-# INLINE unsafeSlice #-}</span>
<a name="line-413"></a><span class='hs-definition'>unsafeSlice</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeSlice</span>
<a name="line-414"></a>
<a name="line-415"></a><a name="unsafeInit"></a><span class='hs-comment'>-- | /O(1)/ Yield all but the last element without copying. The vector may not</span>
<a name="line-416"></a><span class='hs-comment'>-- be empty but this is not checked.</span>
<a name="line-417"></a><span class='hs-definition'>unsafeInit</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-418"></a><span class='hs-comment'>{-# INLINE unsafeInit #-}</span>
<a name="line-419"></a><span class='hs-definition'>unsafeInit</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeInit</span>
<a name="line-420"></a>
<a name="line-421"></a><a name="unsafeTail"></a><span class='hs-comment'>-- | /O(1)/ Yield all but the first element without copying. The vector may not</span>
<a name="line-422"></a><span class='hs-comment'>-- be empty but this is not checked.</span>
<a name="line-423"></a><span class='hs-definition'>unsafeTail</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-424"></a><span class='hs-comment'>{-# INLINE unsafeTail #-}</span>
<a name="line-425"></a><span class='hs-definition'>unsafeTail</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeTail</span>
<a name="line-426"></a>
<a name="line-427"></a><a name="unsafeTake"></a><span class='hs-comment'>-- | /O(1)/ Yield the first @n@ elements without copying. The vector must</span>
<a name="line-428"></a><span class='hs-comment'>-- contain at least @n@ elements but this is not checked.</span>
<a name="line-429"></a><span class='hs-definition'>unsafeTake</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-430"></a><span class='hs-comment'>{-# INLINE unsafeTake #-}</span>
<a name="line-431"></a><span class='hs-definition'>unsafeTake</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeTake</span>
<a name="line-432"></a>
<a name="line-433"></a><a name="unsafeDrop"></a><span class='hs-comment'>-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector</span>
<a name="line-434"></a><span class='hs-comment'>-- must contain at least @n@ elements but this is not checked.</span>
<a name="line-435"></a><span class='hs-definition'>unsafeDrop</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-436"></a><span class='hs-comment'>{-# INLINE unsafeDrop #-}</span>
<a name="line-437"></a><span class='hs-definition'>unsafeDrop</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeDrop</span>
<a name="line-438"></a>
<a name="line-439"></a><span class='hs-comment'>-- Initialisation</span>
<a name="line-440"></a><span class='hs-comment'>-- --------------</span>
<a name="line-441"></a>
<a name="line-442"></a><a name="empty"></a><span class='hs-comment'>-- | /O(1)/ Empty vector</span>
<a name="line-443"></a><span class='hs-definition'>empty</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-444"></a><span class='hs-comment'>{-# INLINE empty #-}</span>
<a name="line-445"></a><span class='hs-definition'>empty</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>empty</span>
<a name="line-446"></a>
<a name="line-447"></a><a name="singleton"></a><span class='hs-comment'>-- | /O(1)/ Vector with exactly one element</span>
<a name="line-448"></a><span class='hs-definition'>singleton</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-449"></a><span class='hs-comment'>{-# INLINE singleton #-}</span>
<a name="line-450"></a><span class='hs-definition'>singleton</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>singleton</span>
<a name="line-451"></a>
<a name="line-452"></a><a name="replicate"></a><span class='hs-comment'>-- | /O(n)/ Vector of the given length with the same value in each position</span>
<a name="line-453"></a><span class='hs-definition'>replicate</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-454"></a><span class='hs-comment'>{-# INLINE replicate #-}</span>
<a name="line-455"></a><span class='hs-definition'>replicate</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>replicate</span>
<a name="line-456"></a>
<a name="line-457"></a><a name="generate"></a><span class='hs-comment'>-- | /O(n)/ Construct a vector of the given length by applying the function to</span>
<a name="line-458"></a><span class='hs-comment'>-- each index</span>
<a name="line-459"></a><span class='hs-definition'>generate</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-460"></a><span class='hs-comment'>{-# INLINE generate #-}</span>
<a name="line-461"></a><span class='hs-definition'>generate</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>generate</span>
<a name="line-462"></a>
<a name="line-463"></a><a name="iterateN"></a><span class='hs-comment'>-- | /O(n)/ Apply function n times to value. Zeroth element is original value.</span>
<a name="line-464"></a><span class='hs-definition'>iterateN</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-465"></a><span class='hs-comment'>{-# INLINE iterateN #-}</span>
<a name="line-466"></a><span class='hs-definition'>iterateN</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>iterateN</span>
<a name="line-467"></a>
<a name="line-468"></a><span class='hs-comment'>-- Unfolding</span>
<a name="line-469"></a><span class='hs-comment'>-- ---------</span>
<a name="line-470"></a>
<a name="line-471"></a><a name="unfoldr"></a><span class='hs-comment'>-- | /O(n)/ Construct a vector by repeatedly applying the generator function</span>
<a name="line-472"></a><span class='hs-comment'>-- to a seed. The generator function yields 'Just' the next element and the</span>
<a name="line-473"></a><span class='hs-comment'>-- new seed or 'Nothing' if there are no more elements.</span>
<a name="line-474"></a><span class='hs-comment'>--</span>
<a name="line-475"></a><span class='hs-comment'>-- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10</span>
<a name="line-476"></a><span class='hs-comment'>-- > = <10,9,8,7,6,5,4,3,2,1></span>
<a name="line-477"></a><span class='hs-definition'>unfoldr</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Maybe</span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-478"></a><span class='hs-comment'>{-# INLINE unfoldr #-}</span>
<a name="line-479"></a><span class='hs-definition'>unfoldr</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unfoldr</span>
<a name="line-480"></a>
<a name="line-481"></a><a name="unfoldrN"></a><span class='hs-comment'>-- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the</span>
<a name="line-482"></a><span class='hs-comment'>-- generator function to the a seed. The generator function yields 'Just' the</span>
<a name="line-483"></a><span class='hs-comment'>-- next element and the new seed or 'Nothing' if there are no more elements.</span>
<a name="line-484"></a><span class='hs-comment'>--</span>
<a name="line-485"></a><span class='hs-comment'>-- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8></span>
<a name="line-486"></a><span class='hs-definition'>unfoldrN</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Maybe</span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-487"></a><span class='hs-comment'>{-# INLINE unfoldrN #-}</span>
<a name="line-488"></a><span class='hs-definition'>unfoldrN</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unfoldrN</span>
<a name="line-489"></a>
<a name="line-490"></a><a name="constructN"></a><span class='hs-comment'>-- | /O(n)/ Construct a vector with @n@ elements by repeatedly applying the</span>
<a name="line-491"></a><span class='hs-comment'>-- generator function to the already constructed part of the vector.</span>
<a name="line-492"></a><span class='hs-comment'>--</span>
<a name="line-493"></a><span class='hs-comment'>-- > constructN 3 f = let a = f <> ; b = f <a> ; c = f <a,b> in f <a,b,c></span>
<a name="line-494"></a><span class='hs-comment'>--</span>
<a name="line-495"></a><span class='hs-definition'>constructN</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-496"></a><span class='hs-comment'>{-# INLINE constructN #-}</span>
<a name="line-497"></a><span class='hs-definition'>constructN</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>constructN</span>
<a name="line-498"></a>
<a name="line-499"></a><a name="constructrN"></a><span class='hs-comment'>-- | /O(n)/ Construct a vector with @n@ elements from right to left by</span>
<a name="line-500"></a><span class='hs-comment'>-- repeatedly applying the generator function to the already constructed part</span>
<a name="line-501"></a><span class='hs-comment'>-- of the vector.</span>
<a name="line-502"></a><span class='hs-comment'>--</span>
<a name="line-503"></a><span class='hs-comment'>-- > constructrN 3 f = let a = f <> ; b = f<a> ; c = f <b,a> in f <c,b,a></span>
<a name="line-504"></a><span class='hs-comment'>--</span>
<a name="line-505"></a><span class='hs-definition'>constructrN</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-506"></a><span class='hs-comment'>{-# INLINE constructrN #-}</span>
<a name="line-507"></a><span class='hs-definition'>constructrN</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>constructrN</span>
<a name="line-508"></a>
<a name="line-509"></a><span class='hs-comment'>-- Enumeration</span>
<a name="line-510"></a><span class='hs-comment'>-- -----------</span>
<a name="line-511"></a>
<a name="line-512"></a><a name="enumFromN"></a><span class='hs-comment'>-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@</span>
<a name="line-513"></a><span class='hs-comment'>-- etc. This operation is usually more efficient than 'enumFromTo'.</span>
<a name="line-514"></a><span class='hs-comment'>--</span>
<a name="line-515"></a><span class='hs-comment'>-- > enumFromN 5 3 = <5,6,7></span>
<a name="line-516"></a><span class='hs-definition'>enumFromN</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Num</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-517"></a><span class='hs-comment'>{-# INLINE enumFromN #-}</span>
<a name="line-518"></a><span class='hs-definition'>enumFromN</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>enumFromN</span>
<a name="line-519"></a>
<a name="line-520"></a><a name="enumFromStepN"></a><span class='hs-comment'>-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@,</span>
<a name="line-521"></a><span class='hs-comment'>-- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.</span>
<a name="line-522"></a><span class='hs-comment'>--</span>
<a name="line-523"></a><span class='hs-comment'>-- > enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4></span>
<a name="line-524"></a><span class='hs-definition'>enumFromStepN</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Num</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-525"></a><span class='hs-comment'>{-# INLINE enumFromStepN #-}</span>
<a name="line-526"></a><span class='hs-definition'>enumFromStepN</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>enumFromStepN</span>
<a name="line-527"></a>
<a name="line-528"></a><a name="enumFromTo"></a><span class='hs-comment'>-- | /O(n)/ Enumerate values from @x@ to @y@.</span>
<a name="line-529"></a><span class='hs-comment'>--</span>
<a name="line-530"></a><span class='hs-comment'>-- /WARNING:/ This operation can be very inefficient. If at all possible, use</span>
<a name="line-531"></a><span class='hs-comment'>-- 'enumFromN' instead.</span>
<a name="line-532"></a><span class='hs-definition'>enumFromTo</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Enum</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-533"></a><span class='hs-comment'>{-# INLINE enumFromTo #-}</span>
<a name="line-534"></a><span class='hs-definition'>enumFromTo</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>enumFromTo</span>
<a name="line-535"></a>
<a name="line-536"></a><a name="enumFromThenTo"></a><span class='hs-comment'>-- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.</span>
<a name="line-537"></a><span class='hs-comment'>--</span>
<a name="line-538"></a><span class='hs-comment'>-- /WARNING:/ This operation can be very inefficient. If at all possible, use</span>
<a name="line-539"></a><span class='hs-comment'>-- 'enumFromStepN' instead.</span>
<a name="line-540"></a><span class='hs-definition'>enumFromThenTo</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Enum</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-541"></a><span class='hs-comment'>{-# INLINE enumFromThenTo #-}</span>
<a name="line-542"></a><span class='hs-definition'>enumFromThenTo</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>enumFromThenTo</span>
<a name="line-543"></a>
<a name="line-544"></a><span class='hs-comment'>-- Concatenation</span>
<a name="line-545"></a><span class='hs-comment'>-- -------------</span>
<a name="line-546"></a>
<a name="line-547"></a><a name="cons"></a><span class='hs-comment'>-- | /O(n)/ Prepend an element</span>
<a name="line-548"></a><span class='hs-definition'>cons</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-549"></a><span class='hs-comment'>{-# INLINE cons #-}</span>
<a name="line-550"></a><span class='hs-definition'>cons</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>cons</span>
<a name="line-551"></a>
<a name="line-552"></a><a name="snoc"></a><span class='hs-comment'>-- | /O(n)/ Append an element</span>
<a name="line-553"></a><span class='hs-definition'>snoc</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-554"></a><span class='hs-comment'>{-# INLINE snoc #-}</span>
<a name="line-555"></a><span class='hs-definition'>snoc</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>snoc</span>
<a name="line-556"></a>
<a name="line-557"></a><span class='hs-keyword'>infixr</span> <span class='hs-num'>5</span> <span class='hs-varop'>++</span>
<a name="line-558"></a><a name="++"></a><span class='hs-comment'>-- | /O(m+n)/ Concatenate two vectors</span>
<a name="line-559"></a><span class='hs-layout'>(</span><span class='hs-varop'>++</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-560"></a><span class='hs-comment'>{-# INLINE (++) #-}</span>
<a name="line-561"></a><span class='hs-layout'>(</span><span class='hs-varop'>++</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.++</span><span class='hs-layout'>)</span>
<a name="line-562"></a>
<a name="line-563"></a><a name="concat"></a><span class='hs-comment'>-- | /O(n)/ Concatenate all vectors in the list</span>
<a name="line-564"></a><span class='hs-definition'>concat</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-keyglyph'>[</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-keyglyph'>]</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-565"></a><span class='hs-comment'>{-# INLINE concat #-}</span>
<a name="line-566"></a><span class='hs-definition'>concat</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>concat</span>
<a name="line-567"></a>
<a name="line-568"></a><span class='hs-comment'>-- Monadic initialisation</span>
<a name="line-569"></a><span class='hs-comment'>-- ----------------------</span>
<a name="line-570"></a>
<a name="line-571"></a><a name="replicateM"></a><span class='hs-comment'>-- | /O(n)/ Execute the monadic action the given number of times and store the</span>
<a name="line-572"></a><span class='hs-comment'>-- results in a vector.</span>
<a name="line-573"></a><span class='hs-definition'>replicateM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-574"></a><span class='hs-comment'>{-# INLINE replicateM #-}</span>
<a name="line-575"></a><span class='hs-definition'>replicateM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>replicateM</span>
<a name="line-576"></a>
<a name="line-577"></a><a name="generateM"></a><span class='hs-comment'>-- | /O(n)/ Construct a vector of the given length by applying the monadic</span>
<a name="line-578"></a><span class='hs-comment'>-- action to each index</span>
<a name="line-579"></a><span class='hs-definition'>generateM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-580"></a><span class='hs-comment'>{-# INLINE generateM #-}</span>
<a name="line-581"></a><span class='hs-definition'>generateM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>generateM</span>
<a name="line-582"></a>
<a name="line-583"></a><a name="create"></a><span class='hs-comment'>-- | Execute the monadic action and freeze the resulting vector.</span>
<a name="line-584"></a><span class='hs-comment'>--</span>
<a name="line-585"></a><span class='hs-comment'>-- @</span>
<a name="line-586"></a><span class='hs-comment'>-- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\' }) = \<'a','b'\></span>
<a name="line-587"></a><span class='hs-comment'>-- @</span>
<a name="line-588"></a><span class='hs-definition'>create</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-keyword'>forall</span> <span class='hs-varid'>s</span><span class='hs-varop'>.</span> <span class='hs-conid'>ST</span> <span class='hs-varid'>s</span> <span class='hs-layout'>(</span><span class='hs-conid'>MVector</span> <span class='hs-varid'>s</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-589"></a><span class='hs-comment'>{-# INLINE create #-}</span>
<a name="line-590"></a><span class='hs-comment'>-- NOTE: eta-expanded due to <a href="http://hackage.haskell.org/trac/ghc/ticket/4120">http://hackage.haskell.org/trac/ghc/ticket/4120</a></span>
<a name="line-591"></a><span class='hs-definition'>create</span> <span class='hs-varid'>p</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>create</span> <span class='hs-varid'>p</span>
<a name="line-592"></a>
<a name="line-593"></a><span class='hs-comment'>-- Restricting memory usage</span>
<a name="line-594"></a><span class='hs-comment'>-- ------------------------</span>
<a name="line-595"></a>
<a name="line-596"></a><a name="force"></a><span class='hs-comment'>-- | /O(n)/ Yield the argument but force it not to retain any extra memory,</span>
<a name="line-597"></a><span class='hs-comment'>-- possibly by copying it.</span>
<a name="line-598"></a><span class='hs-comment'>--</span>
<a name="line-599"></a><span class='hs-comment'>-- This is especially useful when dealing with slices. For example:</span>
<a name="line-600"></a><span class='hs-comment'>--</span>
<a name="line-601"></a><span class='hs-comment'>-- > force (slice 0 2 <huge vector>)</span>
<a name="line-602"></a><span class='hs-comment'>--</span>
<a name="line-603"></a><span class='hs-comment'>-- Here, the slice retains a reference to the huge vector. Forcing it creates</span>
<a name="line-604"></a><span class='hs-comment'>-- a copy of just the elements that belong to the slice and allows the huge</span>
<a name="line-605"></a><span class='hs-comment'>-- vector to be garbage collected.</span>
<a name="line-606"></a><span class='hs-definition'>force</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-607"></a><span class='hs-comment'>{-# INLINE force #-}</span>
<a name="line-608"></a><span class='hs-definition'>force</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>force</span>
<a name="line-609"></a>
<a name="line-610"></a><span class='hs-comment'>-- Bulk updates</span>
<a name="line-611"></a><span class='hs-comment'>-- ------------</span>
<a name="line-612"></a>
<a name="line-613"></a><a name="//"></a><span class='hs-comment'>-- | /O(m+n)/ For each pair @(i,a)@ from the list, replace the vector</span>
<a name="line-614"></a><span class='hs-comment'>-- element at position @i@ by @a@.</span>
<a name="line-615"></a><span class='hs-comment'>--</span>
<a name="line-616"></a><span class='hs-comment'>-- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7></span>
<a name="line-617"></a><span class='hs-comment'>--</span>
<a name="line-618"></a><span class='hs-layout'>(</span><span class='hs-varop'>//</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-comment'>-- ^ initial vector (of length @m@)</span>
<a name="line-619"></a> <span class='hs-keyglyph'>-></span> <span class='hs-keyglyph'>[</span><span class='hs-layout'>(</span><span class='hs-conid'>Int</span><span class='hs-layout'>,</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span><span class='hs-keyglyph'>]</span> <span class='hs-comment'>-- ^ list of index/value pairs (of length @n@) </span>
<a name="line-620"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-621"></a><span class='hs-comment'>{-# INLINE (//) #-}</span>
<a name="line-622"></a><span class='hs-layout'>(</span><span class='hs-varop'>//</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=</span> <span class='hs-layout'>(</span><span class='hs-conid'>G</span><span class='hs-varop'>.//</span><span class='hs-layout'>)</span>
<a name="line-623"></a>
<a name="line-624"></a><a name="update_"></a><span class='hs-comment'>-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the</span>
<a name="line-625"></a><span class='hs-comment'>-- corresponding value @a@ from the value vector, replace the element of the</span>
<a name="line-626"></a><span class='hs-comment'>-- initial vector at position @i@ by @a@.</span>
<a name="line-627"></a><span class='hs-comment'>--</span>
<a name="line-628"></a><span class='hs-comment'>-- > update_ <5,9,2,7> <2,0,2> <1,3,8> = <3,9,8,7></span>
<a name="line-629"></a><span class='hs-comment'>--</span>
<a name="line-630"></a><span class='hs-definition'>update_</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span>
<a name="line-631"></a> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-comment'>-- ^ initial vector (of length @m@)</span>
<a name="line-632"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span> <span class='hs-comment'>-- ^ index vector (of length @n1@)</span>
<a name="line-633"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-comment'>-- ^ value vector (of length @n2@)</span>
<a name="line-634"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-635"></a><span class='hs-comment'>{-# INLINE update_ #-}</span>
<a name="line-636"></a><span class='hs-definition'>update_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>update_</span>
<a name="line-637"></a>
<a name="line-638"></a><a name="unsafeUpd"></a><span class='hs-comment'>-- | Same as ('//') but without bounds checking.</span>
<a name="line-639"></a><span class='hs-definition'>unsafeUpd</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-keyglyph'>[</span><span class='hs-layout'>(</span><span class='hs-conid'>Int</span><span class='hs-layout'>,</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span><span class='hs-keyglyph'>]</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-640"></a><span class='hs-comment'>{-# INLINE unsafeUpd #-}</span>
<a name="line-641"></a><span class='hs-definition'>unsafeUpd</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeUpd</span>
<a name="line-642"></a>
<a name="line-643"></a><a name="unsafeUpdate_"></a><span class='hs-comment'>-- | Same as 'update_' but without bounds checking.</span>
<a name="line-644"></a><span class='hs-definition'>unsafeUpdate_</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-645"></a><span class='hs-comment'>{-# INLINE unsafeUpdate_ #-}</span>
<a name="line-646"></a><span class='hs-definition'>unsafeUpdate_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeUpdate_</span>
<a name="line-647"></a>
<a name="line-648"></a><span class='hs-comment'>-- Accumulations</span>
<a name="line-649"></a><span class='hs-comment'>-- -------------</span>
<a name="line-650"></a>
<a name="line-651"></a><a name="accum"></a><span class='hs-comment'>-- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element</span>
<a name="line-652"></a><span class='hs-comment'>-- @a@ at position @i@ by @f a b@.</span>
<a name="line-653"></a><span class='hs-comment'>--</span>
<a name="line-654"></a><span class='hs-comment'>-- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4></span>
<a name="line-655"></a><span class='hs-definition'>accum</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span>
<a name="line-656"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-comment'>-- ^ accumulating function @f@</span>
<a name="line-657"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-comment'>-- ^ initial vector (of length @m@)</span>
<a name="line-658"></a> <span class='hs-keyglyph'>-></span> <span class='hs-keyglyph'>[</span><span class='hs-layout'>(</span><span class='hs-conid'>Int</span><span class='hs-layout'>,</span><span class='hs-varid'>b</span><span class='hs-layout'>)</span><span class='hs-keyglyph'>]</span> <span class='hs-comment'>-- ^ list of index/value pairs (of length @n@)</span>
<a name="line-659"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-660"></a><span class='hs-comment'>{-# INLINE accum #-}</span>
<a name="line-661"></a><span class='hs-definition'>accum</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>accum</span>
<a name="line-662"></a>
<a name="line-663"></a><a name="accumulate_"></a><span class='hs-comment'>-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the</span>
<a name="line-664"></a><span class='hs-comment'>-- corresponding value @b@ from the the value vector,</span>
<a name="line-665"></a><span class='hs-comment'>-- replace the element of the initial vector at</span>
<a name="line-666"></a><span class='hs-comment'>-- position @i@ by @f a b@.</span>
<a name="line-667"></a><span class='hs-comment'>--</span>
<a name="line-668"></a><span class='hs-comment'>-- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4></span>
<a name="line-669"></a><span class='hs-comment'>--</span>
<a name="line-670"></a><span class='hs-definition'>accumulate_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span>
<a name="line-671"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-comment'>-- ^ accumulating function @f@</span>
<a name="line-672"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-comment'>-- ^ initial vector (of length @m@)</span>
<a name="line-673"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span> <span class='hs-comment'>-- ^ index vector (of length @n1@)</span>
<a name="line-674"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-comment'>-- ^ value vector (of length @n2@)</span>
<a name="line-675"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-676"></a><span class='hs-comment'>{-# INLINE accumulate_ #-}</span>
<a name="line-677"></a><span class='hs-definition'>accumulate_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>accumulate_</span>
<a name="line-678"></a>
<a name="line-679"></a><a name="unsafeAccum"></a><span class='hs-comment'>-- | Same as 'accum' but without bounds checking.</span>
<a name="line-680"></a><span class='hs-definition'>unsafeAccum</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-keyglyph'>[</span><span class='hs-layout'>(</span><span class='hs-conid'>Int</span><span class='hs-layout'>,</span><span class='hs-varid'>b</span><span class='hs-layout'>)</span><span class='hs-keyglyph'>]</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-681"></a><span class='hs-comment'>{-# INLINE unsafeAccum #-}</span>
<a name="line-682"></a><span class='hs-definition'>unsafeAccum</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeAccum</span>
<a name="line-683"></a>
<a name="line-684"></a><a name="unsafeAccumulate_"></a><span class='hs-comment'>-- | Same as 'accumulate_' but without bounds checking.</span>
<a name="line-685"></a><span class='hs-definition'>unsafeAccumulate_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span>
<a name="line-686"></a> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-687"></a><span class='hs-comment'>{-# INLINE unsafeAccumulate_ #-}</span>
<a name="line-688"></a><span class='hs-definition'>unsafeAccumulate_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeAccumulate_</span>
<a name="line-689"></a>
<a name="line-690"></a><span class='hs-comment'>-- Permutations</span>
<a name="line-691"></a><span class='hs-comment'>-- ------------</span>
<a name="line-692"></a>
<a name="line-693"></a><a name="reverse"></a><span class='hs-comment'>-- | /O(n)/ Reverse a vector</span>
<a name="line-694"></a><span class='hs-definition'>reverse</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-695"></a><span class='hs-comment'>{-# INLINE reverse #-}</span>
<a name="line-696"></a><span class='hs-definition'>reverse</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>reverse</span>
<a name="line-697"></a>
<a name="line-698"></a><a name="backpermute"></a><span class='hs-comment'>-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the</span>
<a name="line-699"></a><span class='hs-comment'>-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is</span>
<a name="line-700"></a><span class='hs-comment'>-- often much more efficient.</span>
<a name="line-701"></a><span class='hs-comment'>--</span>
<a name="line-702"></a><span class='hs-comment'>-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a></span>
<a name="line-703"></a><span class='hs-definition'>backpermute</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-704"></a><span class='hs-comment'>{-# INLINE backpermute #-}</span>
<a name="line-705"></a><span class='hs-definition'>backpermute</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>backpermute</span>
<a name="line-706"></a>
<a name="line-707"></a><a name="unsafeBackpermute"></a><span class='hs-comment'>-- | Same as 'backpermute' but without bounds checking.</span>
<a name="line-708"></a><span class='hs-definition'>unsafeBackpermute</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-709"></a><span class='hs-comment'>{-# INLINE unsafeBackpermute #-}</span>
<a name="line-710"></a><span class='hs-definition'>unsafeBackpermute</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeBackpermute</span>
<a name="line-711"></a>
<a name="line-712"></a><span class='hs-comment'>-- Safe destructive updates</span>
<a name="line-713"></a><span class='hs-comment'>-- ------------------------</span>
<a name="line-714"></a>
<a name="line-715"></a><a name="modify"></a><span class='hs-comment'>-- | Apply a destructive operation to a vector. The operation will be</span>
<a name="line-716"></a><span class='hs-comment'>-- performed in place if it is safe to do so and will modify a copy of the</span>
<a name="line-717"></a><span class='hs-comment'>-- vector otherwise.</span>
<a name="line-718"></a><span class='hs-comment'>--</span>
<a name="line-719"></a><span class='hs-comment'>-- @</span>
<a name="line-720"></a><span class='hs-comment'>-- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\></span>
<a name="line-721"></a><span class='hs-comment'>-- @</span>
<a name="line-722"></a><span class='hs-definition'>modify</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-keyword'>forall</span> <span class='hs-varid'>s</span><span class='hs-varop'>.</span> <span class='hs-conid'>MVector</span> <span class='hs-varid'>s</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>ST</span> <span class='hs-varid'>s</span> <span class='hs-conid'>()</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-723"></a><span class='hs-comment'>{-# INLINE modify #-}</span>
<a name="line-724"></a><span class='hs-definition'>modify</span> <span class='hs-varid'>p</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>modify</span> <span class='hs-varid'>p</span>
<a name="line-725"></a>
<a name="line-726"></a><span class='hs-comment'>-- Mapping</span>
<a name="line-727"></a><span class='hs-comment'>-- -------</span>
<a name="line-728"></a>
<a name="line-729"></a><a name="map"></a><span class='hs-comment'>-- | /O(n)/ Map a function over a vector</span>
<a name="line-730"></a><span class='hs-definition'>map</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-731"></a><span class='hs-comment'>{-# INLINE map #-}</span>
<a name="line-732"></a><span class='hs-definition'>map</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>map</span>
<a name="line-733"></a>
<a name="line-734"></a><a name="imap"></a><span class='hs-comment'>-- | /O(n)/ Apply a function to every element of a vector and its index</span>
<a name="line-735"></a><span class='hs-definition'>imap</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-736"></a><span class='hs-comment'>{-# INLINE imap #-}</span>
<a name="line-737"></a><span class='hs-definition'>imap</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>imap</span>
<a name="line-738"></a>
<a name="line-739"></a><a name="concatMap"></a><span class='hs-comment'>-- | Map a function over a vector and concatenate the results.</span>
<a name="line-740"></a><span class='hs-definition'>concatMap</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-741"></a><span class='hs-comment'>{-# INLINE concatMap #-}</span>
<a name="line-742"></a><span class='hs-definition'>concatMap</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>concatMap</span>
<a name="line-743"></a>
<a name="line-744"></a><span class='hs-comment'>-- Monadic mapping</span>
<a name="line-745"></a><span class='hs-comment'>-- ---------------</span>
<a name="line-746"></a>
<a name="line-747"></a><a name="mapM"></a><span class='hs-comment'>-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a</span>
<a name="line-748"></a><span class='hs-comment'>-- vector of results</span>
<a name="line-749"></a><span class='hs-definition'>mapM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span>
<a name="line-750"></a><span class='hs-comment'>{-# INLINE mapM #-}</span>
<a name="line-751"></a><span class='hs-definition'>mapM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>mapM</span>
<a name="line-752"></a>
<a name="line-753"></a><a name="mapM_"></a><span class='hs-comment'>-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the</span>
<a name="line-754"></a><span class='hs-comment'>-- results</span>
<a name="line-755"></a><span class='hs-definition'>mapM_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-756"></a><span class='hs-comment'>{-# INLINE mapM_ #-}</span>
<a name="line-757"></a><span class='hs-definition'>mapM_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>mapM_</span>
<a name="line-758"></a>
<a name="line-759"></a><a name="forM"></a><span class='hs-comment'>-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a</span>
<a name="line-760"></a><span class='hs-comment'>-- vector of results. Equvalent to @flip 'mapM'@.</span>
<a name="line-761"></a><span class='hs-definition'>forM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span>
<a name="line-762"></a><span class='hs-comment'>{-# INLINE forM #-}</span>
<a name="line-763"></a><span class='hs-definition'>forM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>forM</span>
<a name="line-764"></a>
<a name="line-765"></a><a name="forM_"></a><span class='hs-comment'>-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the</span>
<a name="line-766"></a><span class='hs-comment'>-- results. Equivalent to @flip 'mapM_'@.</span>
<a name="line-767"></a><span class='hs-definition'>forM_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-768"></a><span class='hs-comment'>{-# INLINE forM_ #-}</span>
<a name="line-769"></a><span class='hs-definition'>forM_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>forM_</span>
<a name="line-770"></a>
<a name="line-771"></a><span class='hs-comment'>-- Zipping</span>
<a name="line-772"></a><span class='hs-comment'>-- -------</span>
<a name="line-773"></a>
<a name="line-774"></a><a name="zipWith"></a><span class='hs-comment'>-- | /O(min(m,n))/ Zip two vectors with the given function.</span>
<a name="line-775"></a><span class='hs-definition'>zipWith</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span>
<a name="line-776"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span>
<a name="line-777"></a><span class='hs-comment'>{-# INLINE zipWith #-}</span>
<a name="line-778"></a><span class='hs-definition'>zipWith</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>zipWith</span>
<a name="line-779"></a>
<a name="line-780"></a><a name="zipWith3"></a><span class='hs-comment'>-- | Zip three vectors with the given function.</span>
<a name="line-781"></a><span class='hs-definition'>zipWith3</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>)</span>
<a name="line-782"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span>
<a name="line-783"></a><span class='hs-comment'>{-# INLINE zipWith3 #-}</span>
<a name="line-784"></a><span class='hs-definition'>zipWith3</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>zipWith3</span>
<a name="line-785"></a>
<a name="line-786"></a><a name="zipWith4"></a><span class='hs-definition'>zipWith4</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>e</span><span class='hs-layout'>)</span>
<a name="line-787"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>e</span><span class='hs-layout'>)</span>
<a name="line-788"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>e</span>
<a name="line-789"></a><span class='hs-comment'>{-# INLINE zipWith4 #-}</span>
<a name="line-790"></a><span class='hs-definition'>zipWith4</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>zipWith4</span>
<a name="line-791"></a>
<a name="line-792"></a><a name="zipWith5"></a><span class='hs-definition'>zipWith5</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>e</span><span class='hs-layout'>,</span>
<a name="line-793"></a> <span class='hs-conid'>Prim</span> <span class='hs-varid'>f</span><span class='hs-layout'>)</span>
<a name="line-794"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>e</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>f</span><span class='hs-layout'>)</span>
<a name="line-795"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>e</span>
<a name="line-796"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>f</span>
<a name="line-797"></a><span class='hs-comment'>{-# INLINE zipWith5 #-}</span>
<a name="line-798"></a><span class='hs-definition'>zipWith5</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>zipWith5</span>
<a name="line-799"></a>
<a name="line-800"></a><a name="zipWith6"></a><span class='hs-definition'>zipWith6</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>e</span><span class='hs-layout'>,</span>
<a name="line-801"></a> <span class='hs-conid'>Prim</span> <span class='hs-varid'>f</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>g</span><span class='hs-layout'>)</span>
<a name="line-802"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>e</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>f</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>g</span><span class='hs-layout'>)</span>
<a name="line-803"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>e</span>
<a name="line-804"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>f</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>g</span>
<a name="line-805"></a><span class='hs-comment'>{-# INLINE zipWith6 #-}</span>
<a name="line-806"></a><span class='hs-definition'>zipWith6</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>zipWith6</span>
<a name="line-807"></a>
<a name="line-808"></a><a name="izipWith"></a><span class='hs-comment'>-- | /O(min(m,n))/ Zip two vectors with a function that also takes the</span>
<a name="line-809"></a><span class='hs-comment'>-- elements' indices.</span>
<a name="line-810"></a><span class='hs-definition'>izipWith</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span>
<a name="line-811"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span>
<a name="line-812"></a><span class='hs-comment'>{-# INLINE izipWith #-}</span>
<a name="line-813"></a><span class='hs-definition'>izipWith</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>izipWith</span>
<a name="line-814"></a>
<a name="line-815"></a><a name="izipWith3"></a><span class='hs-comment'>-- | Zip three vectors and their indices with the given function.</span>
<a name="line-816"></a><span class='hs-definition'>izipWith3</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>)</span>
<a name="line-817"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span><span class='hs-layout'>)</span>
<a name="line-818"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span>
<a name="line-819"></a><span class='hs-comment'>{-# INLINE izipWith3 #-}</span>
<a name="line-820"></a><span class='hs-definition'>izipWith3</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>izipWith3</span>
<a name="line-821"></a>
<a name="line-822"></a><a name="izipWith4"></a><span class='hs-definition'>izipWith4</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>e</span><span class='hs-layout'>)</span>
<a name="line-823"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>e</span><span class='hs-layout'>)</span>
<a name="line-824"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>e</span>
<a name="line-825"></a><span class='hs-comment'>{-# INLINE izipWith4 #-}</span>
<a name="line-826"></a><span class='hs-definition'>izipWith4</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>izipWith4</span>
<a name="line-827"></a>
<a name="line-828"></a><a name="izipWith5"></a><span class='hs-definition'>izipWith5</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>e</span><span class='hs-layout'>,</span>
<a name="line-829"></a> <span class='hs-conid'>Prim</span> <span class='hs-varid'>f</span><span class='hs-layout'>)</span>
<a name="line-830"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>e</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>f</span><span class='hs-layout'>)</span>
<a name="line-831"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>e</span>
<a name="line-832"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>f</span>
<a name="line-833"></a><span class='hs-comment'>{-# INLINE izipWith5 #-}</span>
<a name="line-834"></a><span class='hs-definition'>izipWith5</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>izipWith5</span>
<a name="line-835"></a>
<a name="line-836"></a><a name="izipWith6"></a><span class='hs-definition'>izipWith6</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>d</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>e</span><span class='hs-layout'>,</span>
<a name="line-837"></a> <span class='hs-conid'>Prim</span> <span class='hs-varid'>f</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>g</span><span class='hs-layout'>)</span>
<a name="line-838"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>e</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>f</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>g</span><span class='hs-layout'>)</span>
<a name="line-839"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>d</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>e</span>
<a name="line-840"></a> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>f</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>g</span>
<a name="line-841"></a><span class='hs-comment'>{-# INLINE izipWith6 #-}</span>
<a name="line-842"></a><span class='hs-definition'>izipWith6</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>izipWith6</span>
<a name="line-843"></a>
<a name="line-844"></a><span class='hs-comment'>-- Monadic zipping</span>
<a name="line-845"></a><span class='hs-comment'>-- ---------------</span>
<a name="line-846"></a>
<a name="line-847"></a><a name="zipWithM"></a><span class='hs-comment'>-- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a</span>
<a name="line-848"></a><span class='hs-comment'>-- vector of results</span>
<a name="line-849"></a><span class='hs-definition'>zipWithM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span>
<a name="line-850"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span>
<a name="line-851"></a><span class='hs-comment'>{-# INLINE zipWithM #-}</span>
<a name="line-852"></a><span class='hs-definition'>zipWithM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>zipWithM</span>
<a name="line-853"></a>
<a name="line-854"></a><a name="zipWithM_"></a><span class='hs-comment'>-- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the</span>
<a name="line-855"></a><span class='hs-comment'>-- results</span>
<a name="line-856"></a><span class='hs-definition'>zipWithM_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span>
<a name="line-857"></a> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>c</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-858"></a><span class='hs-comment'>{-# INLINE zipWithM_ #-}</span>
<a name="line-859"></a><span class='hs-definition'>zipWithM_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>zipWithM_</span>
<a name="line-860"></a>
<a name="line-861"></a><span class='hs-comment'>-- Filtering</span>
<a name="line-862"></a><span class='hs-comment'>-- ---------</span>
<a name="line-863"></a>
<a name="line-864"></a><a name="filter"></a><span class='hs-comment'>-- | /O(n)/ Drop elements that do not satisfy the predicate</span>
<a name="line-865"></a><span class='hs-definition'>filter</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-866"></a><span class='hs-comment'>{-# INLINE filter #-}</span>
<a name="line-867"></a><span class='hs-definition'>filter</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>filter</span>
<a name="line-868"></a>
<a name="line-869"></a><a name="ifilter"></a><span class='hs-comment'>-- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to</span>
<a name="line-870"></a><span class='hs-comment'>-- values and their indices</span>
<a name="line-871"></a><span class='hs-definition'>ifilter</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-872"></a><span class='hs-comment'>{-# INLINE ifilter #-}</span>
<a name="line-873"></a><span class='hs-definition'>ifilter</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>ifilter</span>
<a name="line-874"></a>
<a name="line-875"></a><a name="filterM"></a><span class='hs-comment'>-- | /O(n)/ Drop elements that do not satisfy the monadic predicate</span>
<a name="line-876"></a><span class='hs-definition'>filterM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-877"></a><span class='hs-comment'>{-# INLINE filterM #-}</span>
<a name="line-878"></a><span class='hs-definition'>filterM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>filterM</span>
<a name="line-879"></a>
<a name="line-880"></a><a name="takeWhile"></a><span class='hs-comment'>-- | /O(n)/ Yield the longest prefix of elements satisfying the predicate</span>
<a name="line-881"></a><span class='hs-comment'>-- without copying.</span>
<a name="line-882"></a><span class='hs-definition'>takeWhile</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-883"></a><span class='hs-comment'>{-# INLINE takeWhile #-}</span>
<a name="line-884"></a><span class='hs-definition'>takeWhile</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>takeWhile</span>
<a name="line-885"></a>
<a name="line-886"></a><a name="dropWhile"></a><span class='hs-comment'>-- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate</span>
<a name="line-887"></a><span class='hs-comment'>-- without copying.</span>
<a name="line-888"></a><span class='hs-definition'>dropWhile</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-889"></a><span class='hs-comment'>{-# INLINE dropWhile #-}</span>
<a name="line-890"></a><span class='hs-definition'>dropWhile</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>dropWhile</span>
<a name="line-891"></a>
<a name="line-892"></a><span class='hs-comment'>-- Parititioning</span>
<a name="line-893"></a><span class='hs-comment'>-- -------------</span>
<a name="line-894"></a>
<a name="line-895"></a><a name="partition"></a><span class='hs-comment'>-- | /O(n)/ Split the vector in two parts, the first one containing those</span>
<a name="line-896"></a><span class='hs-comment'>-- elements that satisfy the predicate and the second one those that don't. The</span>
<a name="line-897"></a><span class='hs-comment'>-- relative order of the elements is preserved at the cost of a sometimes</span>
<a name="line-898"></a><span class='hs-comment'>-- reduced performance compared to 'unstablePartition'.</span>
<a name="line-899"></a><span class='hs-definition'>partition</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-900"></a><span class='hs-comment'>{-# INLINE partition #-}</span>
<a name="line-901"></a><span class='hs-definition'>partition</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>partition</span>
<a name="line-902"></a>
<a name="line-903"></a><a name="unstablePartition"></a><span class='hs-comment'>-- | /O(n)/ Split the vector in two parts, the first one containing those</span>
<a name="line-904"></a><span class='hs-comment'>-- elements that satisfy the predicate and the second one those that don't.</span>
<a name="line-905"></a><span class='hs-comment'>-- The order of the elements is not preserved but the operation is often</span>
<a name="line-906"></a><span class='hs-comment'>-- faster than 'partition'.</span>
<a name="line-907"></a><span class='hs-definition'>unstablePartition</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-908"></a><span class='hs-comment'>{-# INLINE unstablePartition #-}</span>
<a name="line-909"></a><span class='hs-definition'>unstablePartition</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unstablePartition</span>
<a name="line-910"></a>
<a name="line-911"></a><a name="span"></a><span class='hs-comment'>-- | /O(n)/ Split the vector into the longest prefix of elements that satisfy</span>
<a name="line-912"></a><span class='hs-comment'>-- the predicate and the rest without copying.</span>
<a name="line-913"></a><span class='hs-definition'>span</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-914"></a><span class='hs-comment'>{-# INLINE span #-}</span>
<a name="line-915"></a><span class='hs-definition'>span</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>span</span>
<a name="line-916"></a>
<a name="line-917"></a><a name="break"></a><span class='hs-comment'>-- | /O(n)/ Split the vector into the longest prefix of elements that do not</span>
<a name="line-918"></a><span class='hs-comment'>-- satisfy the predicate and the rest without copying.</span>
<a name="line-919"></a><span class='hs-definition'>break</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-920"></a><span class='hs-comment'>{-# INLINE break #-}</span>
<a name="line-921"></a><span class='hs-definition'>break</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>break</span>
<a name="line-922"></a>
<a name="line-923"></a><span class='hs-comment'>-- Searching</span>
<a name="line-924"></a><span class='hs-comment'>-- ---------</span>
<a name="line-925"></a>
<a name="line-926"></a><span class='hs-keyword'>infix</span> <span class='hs-num'>4</span> <span class='hs-varop'>`elem`</span>
<a name="line-927"></a><a name="elem"></a><span class='hs-comment'>-- | /O(n)/ Check if the vector contains an element</span>
<a name="line-928"></a><span class='hs-definition'>elem</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Eq</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span>
<a name="line-929"></a><span class='hs-comment'>{-# INLINE elem #-}</span>
<a name="line-930"></a><span class='hs-definition'>elem</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>elem</span>
<a name="line-931"></a>
<a name="line-932"></a><span class='hs-keyword'>infix</span> <span class='hs-num'>4</span> <span class='hs-varop'>`notElem`</span>
<a name="line-933"></a><a name="notElem"></a><span class='hs-comment'>-- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem')</span>
<a name="line-934"></a><span class='hs-definition'>notElem</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Eq</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span>
<a name="line-935"></a><span class='hs-comment'>{-# INLINE notElem #-}</span>
<a name="line-936"></a><span class='hs-definition'>notElem</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>notElem</span>
<a name="line-937"></a>
<a name="line-938"></a><a name="find"></a><span class='hs-comment'>-- | /O(n)/ Yield 'Just' the first element matching the predicate or 'Nothing'</span>
<a name="line-939"></a><span class='hs-comment'>-- if no such element exists.</span>
<a name="line-940"></a><span class='hs-definition'>find</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Maybe</span> <span class='hs-varid'>a</span>
<a name="line-941"></a><span class='hs-comment'>{-# INLINE find #-}</span>
<a name="line-942"></a><span class='hs-definition'>find</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>find</span>
<a name="line-943"></a>
<a name="line-944"></a><a name="findIndex"></a><span class='hs-comment'>-- | /O(n)/ Yield 'Just' the index of the first element matching the predicate</span>
<a name="line-945"></a><span class='hs-comment'>-- or 'Nothing' if no such element exists.</span>
<a name="line-946"></a><span class='hs-definition'>findIndex</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Maybe</span> <span class='hs-conid'>Int</span>
<a name="line-947"></a><span class='hs-comment'>{-# INLINE findIndex #-}</span>
<a name="line-948"></a><span class='hs-definition'>findIndex</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>findIndex</span>
<a name="line-949"></a>
<a name="line-950"></a><a name="findIndices"></a><span class='hs-comment'>-- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending</span>
<a name="line-951"></a><span class='hs-comment'>-- order.</span>
<a name="line-952"></a><span class='hs-definition'>findIndices</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span>
<a name="line-953"></a><span class='hs-comment'>{-# INLINE findIndices #-}</span>
<a name="line-954"></a><span class='hs-definition'>findIndices</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>findIndices</span>
<a name="line-955"></a>
<a name="line-956"></a><a name="elemIndex"></a><span class='hs-comment'>-- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or</span>
<a name="line-957"></a><span class='hs-comment'>-- 'Nothing' if the vector does not contain the element. This is a specialised</span>
<a name="line-958"></a><span class='hs-comment'>-- version of 'findIndex'.</span>
<a name="line-959"></a><span class='hs-definition'>elemIndex</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Eq</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Maybe</span> <span class='hs-conid'>Int</span>
<a name="line-960"></a><span class='hs-comment'>{-# INLINE elemIndex #-}</span>
<a name="line-961"></a><span class='hs-definition'>elemIndex</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>elemIndex</span>
<a name="line-962"></a>
<a name="line-963"></a><a name="elemIndices"></a><span class='hs-comment'>-- | /O(n)/ Yield the indices of all occurences of the given element in</span>
<a name="line-964"></a><span class='hs-comment'>-- ascending order. This is a specialised version of 'findIndices'.</span>
<a name="line-965"></a><span class='hs-definition'>elemIndices</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Eq</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-conid'>Int</span>
<a name="line-966"></a><span class='hs-comment'>{-# INLINE elemIndices #-}</span>
<a name="line-967"></a><span class='hs-definition'>elemIndices</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>elemIndices</span>
<a name="line-968"></a>
<a name="line-969"></a><span class='hs-comment'>-- Folding</span>
<a name="line-970"></a><span class='hs-comment'>-- -------</span>
<a name="line-971"></a>
<a name="line-972"></a><a name="foldl"></a><span class='hs-comment'>-- | /O(n)/ Left fold</span>
<a name="line-973"></a><span class='hs-definition'>foldl</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-974"></a><span class='hs-comment'>{-# INLINE foldl #-}</span>
<a name="line-975"></a><span class='hs-definition'>foldl</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldl</span>
<a name="line-976"></a>
<a name="line-977"></a><a name="foldl1"></a><span class='hs-comment'>-- | /O(n)/ Left fold on non-empty vectors</span>
<a name="line-978"></a><span class='hs-definition'>foldl1</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-979"></a><span class='hs-comment'>{-# INLINE foldl1 #-}</span>
<a name="line-980"></a><span class='hs-definition'>foldl1</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldl1</span>
<a name="line-981"></a>
<a name="line-982"></a><a name="foldl'"></a><span class='hs-comment'>-- | /O(n)/ Left fold with strict accumulator</span>
<a name="line-983"></a><span class='hs-definition'>foldl'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-984"></a><span class='hs-comment'>{-# INLINE foldl' #-}</span>
<a name="line-985"></a><span class='hs-definition'>foldl'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldl'</span>
<a name="line-986"></a>
<a name="line-987"></a><a name="foldl1'"></a><span class='hs-comment'>-- | /O(n)/ Left fold on non-empty vectors with strict accumulator</span>
<a name="line-988"></a><span class='hs-definition'>foldl1'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-989"></a><span class='hs-comment'>{-# INLINE foldl1' #-}</span>
<a name="line-990"></a><span class='hs-definition'>foldl1'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldl1'</span>
<a name="line-991"></a>
<a name="line-992"></a><a name="foldr"></a><span class='hs-comment'>-- | /O(n)/ Right fold</span>
<a name="line-993"></a><span class='hs-definition'>foldr</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span>
<a name="line-994"></a><span class='hs-comment'>{-# INLINE foldr #-}</span>
<a name="line-995"></a><span class='hs-definition'>foldr</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldr</span>
<a name="line-996"></a>
<a name="line-997"></a><a name="foldr1"></a><span class='hs-comment'>-- | /O(n)/ Right fold on non-empty vectors</span>
<a name="line-998"></a><span class='hs-definition'>foldr1</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-999"></a><span class='hs-comment'>{-# INLINE foldr1 #-}</span>
<a name="line-1000"></a><span class='hs-definition'>foldr1</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldr1</span>
<a name="line-1001"></a>
<a name="line-1002"></a><a name="foldr'"></a><span class='hs-comment'>-- | /O(n)/ Right fold with a strict accumulator</span>
<a name="line-1003"></a><span class='hs-definition'>foldr'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span>
<a name="line-1004"></a><span class='hs-comment'>{-# INLINE foldr' #-}</span>
<a name="line-1005"></a><span class='hs-definition'>foldr'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldr'</span>
<a name="line-1006"></a>
<a name="line-1007"></a><a name="foldr1'"></a><span class='hs-comment'>-- | /O(n)/ Right fold on non-empty vectors with strict accumulator</span>
<a name="line-1008"></a><span class='hs-definition'>foldr1'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1009"></a><span class='hs-comment'>{-# INLINE foldr1' #-}</span>
<a name="line-1010"></a><span class='hs-definition'>foldr1'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldr1'</span>
<a name="line-1011"></a>
<a name="line-1012"></a><a name="ifoldl"></a><span class='hs-comment'>-- | /O(n)/ Left fold (function applied to each element and its index)</span>
<a name="line-1013"></a><span class='hs-definition'>ifoldl</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1014"></a><span class='hs-comment'>{-# INLINE ifoldl #-}</span>
<a name="line-1015"></a><span class='hs-definition'>ifoldl</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>ifoldl</span>
<a name="line-1016"></a>
<a name="line-1017"></a><a name="ifoldl'"></a><span class='hs-comment'>-- | /O(n)/ Left fold with strict accumulator (function applied to each element</span>
<a name="line-1018"></a><span class='hs-comment'>-- and its index)</span>
<a name="line-1019"></a><span class='hs-definition'>ifoldl'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1020"></a><span class='hs-comment'>{-# INLINE ifoldl' #-}</span>
<a name="line-1021"></a><span class='hs-definition'>ifoldl'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>ifoldl'</span>
<a name="line-1022"></a>
<a name="line-1023"></a><a name="ifoldr"></a><span class='hs-comment'>-- | /O(n)/ Right fold (function applied to each element and its index)</span>
<a name="line-1024"></a><span class='hs-definition'>ifoldr</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span>
<a name="line-1025"></a><span class='hs-comment'>{-# INLINE ifoldr #-}</span>
<a name="line-1026"></a><span class='hs-definition'>ifoldr</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>ifoldr</span>
<a name="line-1027"></a>
<a name="line-1028"></a><a name="ifoldr'"></a><span class='hs-comment'>-- | /O(n)/ Right fold with strict accumulator (function applied to each</span>
<a name="line-1029"></a><span class='hs-comment'>-- element and its index)</span>
<a name="line-1030"></a><span class='hs-definition'>ifoldr'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span>
<a name="line-1031"></a><span class='hs-comment'>{-# INLINE ifoldr' #-}</span>
<a name="line-1032"></a><span class='hs-definition'>ifoldr'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>ifoldr'</span>
<a name="line-1033"></a>
<a name="line-1034"></a><span class='hs-comment'>-- Specialised folds</span>
<a name="line-1035"></a><span class='hs-comment'>-- -----------------</span>
<a name="line-1036"></a>
<a name="line-1037"></a><a name="all"></a><span class='hs-comment'>-- | /O(n)/ Check if all elements satisfy the predicate.</span>
<a name="line-1038"></a><span class='hs-definition'>all</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span>
<a name="line-1039"></a><span class='hs-comment'>{-# INLINE all #-}</span>
<a name="line-1040"></a><span class='hs-definition'>all</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>all</span>
<a name="line-1041"></a>
<a name="line-1042"></a><a name="any"></a><span class='hs-comment'>-- | /O(n)/ Check if any element satisfies the predicate.</span>
<a name="line-1043"></a><span class='hs-definition'>any</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Bool</span>
<a name="line-1044"></a><span class='hs-comment'>{-# INLINE any #-}</span>
<a name="line-1045"></a><span class='hs-definition'>any</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>any</span>
<a name="line-1046"></a>
<a name="line-1047"></a><a name="sum"></a><span class='hs-comment'>-- | /O(n)/ Compute the sum of the elements</span>
<a name="line-1048"></a><span class='hs-definition'>sum</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Num</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1049"></a><span class='hs-comment'>{-# INLINE sum #-}</span>
<a name="line-1050"></a><span class='hs-definition'>sum</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>sum</span>
<a name="line-1051"></a>
<a name="line-1052"></a><a name="product"></a><span class='hs-comment'>-- | /O(n)/ Compute the produce of the elements</span>
<a name="line-1053"></a><span class='hs-definition'>product</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Num</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1054"></a><span class='hs-comment'>{-# INLINE product #-}</span>
<a name="line-1055"></a><span class='hs-definition'>product</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>product</span>
<a name="line-1056"></a>
<a name="line-1057"></a><a name="maximum"></a><span class='hs-comment'>-- | /O(n)/ Yield the maximum element of the vector. The vector may not be</span>
<a name="line-1058"></a><span class='hs-comment'>-- empty.</span>
<a name="line-1059"></a><span class='hs-definition'>maximum</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Ord</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1060"></a><span class='hs-comment'>{-# INLINE maximum #-}</span>
<a name="line-1061"></a><span class='hs-definition'>maximum</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>maximum</span>
<a name="line-1062"></a>
<a name="line-1063"></a><a name="maximumBy"></a><span class='hs-comment'>-- | /O(n)/ Yield the maximum element of the vector according to the given</span>
<a name="line-1064"></a><span class='hs-comment'>-- comparison function. The vector may not be empty.</span>
<a name="line-1065"></a><span class='hs-definition'>maximumBy</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Ordering</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1066"></a><span class='hs-comment'>{-# INLINE maximumBy #-}</span>
<a name="line-1067"></a><span class='hs-definition'>maximumBy</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>maximumBy</span>
<a name="line-1068"></a>
<a name="line-1069"></a><a name="minimum"></a><span class='hs-comment'>-- | /O(n)/ Yield the minimum element of the vector. The vector may not be</span>
<a name="line-1070"></a><span class='hs-comment'>-- empty.</span>
<a name="line-1071"></a><span class='hs-definition'>minimum</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Ord</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1072"></a><span class='hs-comment'>{-# INLINE minimum #-}</span>
<a name="line-1073"></a><span class='hs-definition'>minimum</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>minimum</span>
<a name="line-1074"></a>
<a name="line-1075"></a><a name="minimumBy"></a><span class='hs-comment'>-- | /O(n)/ Yield the minimum element of the vector according to the given</span>
<a name="line-1076"></a><span class='hs-comment'>-- comparison function. The vector may not be empty.</span>
<a name="line-1077"></a><span class='hs-definition'>minimumBy</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Ordering</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span>
<a name="line-1078"></a><span class='hs-comment'>{-# INLINE minimumBy #-}</span>
<a name="line-1079"></a><span class='hs-definition'>minimumBy</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>minimumBy</span>
<a name="line-1080"></a>
<a name="line-1081"></a><a name="maxIndex"></a><span class='hs-comment'>-- | /O(n)/ Yield the index of the maximum element of the vector. The vector</span>
<a name="line-1082"></a><span class='hs-comment'>-- may not be empty.</span>
<a name="line-1083"></a><span class='hs-definition'>maxIndex</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Ord</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span>
<a name="line-1084"></a><span class='hs-comment'>{-# INLINE maxIndex #-}</span>
<a name="line-1085"></a><span class='hs-definition'>maxIndex</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>maxIndex</span>
<a name="line-1086"></a>
<a name="line-1087"></a><a name="maxIndexBy"></a><span class='hs-comment'>-- | /O(n)/ Yield the index of the maximum element of the vector according to</span>
<a name="line-1088"></a><span class='hs-comment'>-- the given comparison function. The vector may not be empty.</span>
<a name="line-1089"></a><span class='hs-definition'>maxIndexBy</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Ordering</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span>
<a name="line-1090"></a><span class='hs-comment'>{-# INLINE maxIndexBy #-}</span>
<a name="line-1091"></a><span class='hs-definition'>maxIndexBy</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>maxIndexBy</span>
<a name="line-1092"></a>
<a name="line-1093"></a><a name="minIndex"></a><span class='hs-comment'>-- | /O(n)/ Yield the index of the minimum element of the vector. The vector</span>
<a name="line-1094"></a><span class='hs-comment'>-- may not be empty.</span>
<a name="line-1095"></a><span class='hs-definition'>minIndex</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Ord</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span>
<a name="line-1096"></a><span class='hs-comment'>{-# INLINE minIndex #-}</span>
<a name="line-1097"></a><span class='hs-definition'>minIndex</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>minIndex</span>
<a name="line-1098"></a>
<a name="line-1099"></a><a name="minIndexBy"></a><span class='hs-comment'>-- | /O(n)/ Yield the index of the minimum element of the vector according to</span>
<a name="line-1100"></a><span class='hs-comment'>-- the given comparison function. The vector may not be empty.</span>
<a name="line-1101"></a><span class='hs-definition'>minIndexBy</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Ordering</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Int</span>
<a name="line-1102"></a><span class='hs-comment'>{-# INLINE minIndexBy #-}</span>
<a name="line-1103"></a><span class='hs-definition'>minIndexBy</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>minIndexBy</span>
<a name="line-1104"></a>
<a name="line-1105"></a><span class='hs-comment'>-- Monadic folds</span>
<a name="line-1106"></a><span class='hs-comment'>-- -------------</span>
<a name="line-1107"></a>
<a name="line-1108"></a><a name="foldM"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold</span>
<a name="line-1109"></a><span class='hs-definition'>foldM</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-1110"></a><span class='hs-comment'>{-# INLINE foldM #-}</span>
<a name="line-1111"></a><span class='hs-definition'>foldM</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldM</span>
<a name="line-1112"></a>
<a name="line-1113"></a><a name="fold1M"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold over non-empty vectors</span>
<a name="line-1114"></a><span class='hs-definition'>fold1M</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-1115"></a><span class='hs-comment'>{-# INLINE fold1M #-}</span>
<a name="line-1116"></a><span class='hs-definition'>fold1M</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>fold1M</span>
<a name="line-1117"></a>
<a name="line-1118"></a><a name="foldM'"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold with strict accumulator</span>
<a name="line-1119"></a><span class='hs-definition'>foldM'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-1120"></a><span class='hs-comment'>{-# INLINE foldM' #-}</span>
<a name="line-1121"></a><span class='hs-definition'>foldM'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldM'</span>
<a name="line-1122"></a>
<a name="line-1123"></a><a name="fold1M'"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator</span>
<a name="line-1124"></a><span class='hs-definition'>fold1M'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span>
<a name="line-1125"></a><span class='hs-comment'>{-# INLINE fold1M' #-}</span>
<a name="line-1126"></a><span class='hs-definition'>fold1M'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>fold1M'</span>
<a name="line-1127"></a>
<a name="line-1128"></a><a name="foldM_"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold that discards the result</span>
<a name="line-1129"></a><span class='hs-definition'>foldM_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-1130"></a><span class='hs-comment'>{-# INLINE foldM_ #-}</span>
<a name="line-1131"></a><span class='hs-definition'>foldM_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldM_</span>
<a name="line-1132"></a>
<a name="line-1133"></a><a name="fold1M_"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold over non-empty vectors that discards the result</span>
<a name="line-1134"></a><span class='hs-definition'>fold1M_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-1135"></a><span class='hs-comment'>{-# INLINE fold1M_ #-}</span>
<a name="line-1136"></a><span class='hs-definition'>fold1M_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>fold1M_</span>
<a name="line-1137"></a>
<a name="line-1138"></a><a name="foldM'_"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold with strict accumulator that discards the result</span>
<a name="line-1139"></a><span class='hs-definition'>foldM'_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-1140"></a><span class='hs-comment'>{-# INLINE foldM'_ #-}</span>
<a name="line-1141"></a><span class='hs-definition'>foldM'_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>foldM'_</span>
<a name="line-1142"></a>
<a name="line-1143"></a><a name="fold1M'_"></a><span class='hs-comment'>-- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator</span>
<a name="line-1144"></a><span class='hs-comment'>-- that discards the result</span>
<a name="line-1145"></a><span class='hs-definition'>fold1M'_</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Monad</span> <span class='hs-varid'>m</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-1146"></a><span class='hs-comment'>{-# INLINE fold1M'_ #-}</span>
<a name="line-1147"></a><span class='hs-definition'>fold1M'_</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>fold1M'_</span>
<a name="line-1148"></a>
<a name="line-1149"></a><span class='hs-comment'>-- Prefix sums (scans)</span>
<a name="line-1150"></a><span class='hs-comment'>-- -------------------</span>
<a name="line-1151"></a>
<a name="line-1152"></a><a name="prescanl"></a><span class='hs-comment'>-- | /O(n)/ Prescan</span>
<a name="line-1153"></a><span class='hs-comment'>--</span>
<a name="line-1154"></a><span class='hs-comment'>-- @</span>
<a name="line-1155"></a><span class='hs-comment'>-- prescanl f z = 'init' . 'scanl' f z</span>
<a name="line-1156"></a><span class='hs-comment'>-- @</span>
<a name="line-1157"></a><span class='hs-comment'>--</span>
<a name="line-1158"></a><span class='hs-comment'>-- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@</span>
<a name="line-1159"></a><span class='hs-comment'>--</span>
<a name="line-1160"></a><span class='hs-definition'>prescanl</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1161"></a><span class='hs-comment'>{-# INLINE prescanl #-}</span>
<a name="line-1162"></a><span class='hs-definition'>prescanl</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>prescanl</span>
<a name="line-1163"></a>
<a name="line-1164"></a><a name="prescanl'"></a><span class='hs-comment'>-- | /O(n)/ Prescan with strict accumulator</span>
<a name="line-1165"></a><span class='hs-definition'>prescanl'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1166"></a><span class='hs-comment'>{-# INLINE prescanl' #-}</span>
<a name="line-1167"></a><span class='hs-definition'>prescanl'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>prescanl'</span>
<a name="line-1168"></a>
<a name="line-1169"></a><a name="postscanl"></a><span class='hs-comment'>-- | /O(n)/ Scan</span>
<a name="line-1170"></a><span class='hs-comment'>--</span>
<a name="line-1171"></a><span class='hs-comment'>-- @</span>
<a name="line-1172"></a><span class='hs-comment'>-- postscanl f z = 'tail' . 'scanl' f z</span>
<a name="line-1173"></a><span class='hs-comment'>-- @</span>
<a name="line-1174"></a><span class='hs-comment'>--</span>
<a name="line-1175"></a><span class='hs-comment'>-- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@</span>
<a name="line-1176"></a><span class='hs-comment'>--</span>
<a name="line-1177"></a><span class='hs-definition'>postscanl</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1178"></a><span class='hs-comment'>{-# INLINE postscanl #-}</span>
<a name="line-1179"></a><span class='hs-definition'>postscanl</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>postscanl</span>
<a name="line-1180"></a>
<a name="line-1181"></a><a name="postscanl'"></a><span class='hs-comment'>-- | /O(n)/ Scan with strict accumulator</span>
<a name="line-1182"></a><span class='hs-definition'>postscanl'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1183"></a><span class='hs-comment'>{-# INLINE postscanl' #-}</span>
<a name="line-1184"></a><span class='hs-definition'>postscanl'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>postscanl'</span>
<a name="line-1185"></a>
<a name="line-1186"></a><a name="scanl"></a><span class='hs-comment'>-- | /O(n)/ Haskell-style scan</span>
<a name="line-1187"></a><span class='hs-comment'>--</span>
<a name="line-1188"></a><span class='hs-comment'>-- > scanl f z <x1,...,xn> = <y1,...,y(n+1)></span>
<a name="line-1189"></a><span class='hs-comment'>-- > where y1 = z</span>
<a name="line-1190"></a><span class='hs-comment'>-- > yi = f y(i-1) x(i-1)</span>
<a name="line-1191"></a><span class='hs-comment'>--</span>
<a name="line-1192"></a><span class='hs-comment'>-- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@</span>
<a name="line-1193"></a><span class='hs-comment'>-- </span>
<a name="line-1194"></a><span class='hs-definition'>scanl</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1195"></a><span class='hs-comment'>{-# INLINE scanl #-}</span>
<a name="line-1196"></a><span class='hs-definition'>scanl</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanl</span>
<a name="line-1197"></a>
<a name="line-1198"></a><a name="scanl'"></a><span class='hs-comment'>-- | /O(n)/ Haskell-style scan with strict accumulator</span>
<a name="line-1199"></a><span class='hs-definition'>scanl'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1200"></a><span class='hs-comment'>{-# INLINE scanl' #-}</span>
<a name="line-1201"></a><span class='hs-definition'>scanl'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanl'</span>
<a name="line-1202"></a>
<a name="line-1203"></a><a name="scanl1"></a><span class='hs-comment'>-- | /O(n)/ Scan over a non-empty vector</span>
<a name="line-1204"></a><span class='hs-comment'>--</span>
<a name="line-1205"></a><span class='hs-comment'>-- > scanl f <x1,...,xn> = <y1,...,yn></span>
<a name="line-1206"></a><span class='hs-comment'>-- > where y1 = x1</span>
<a name="line-1207"></a><span class='hs-comment'>-- > yi = f y(i-1) xi</span>
<a name="line-1208"></a><span class='hs-comment'>--</span>
<a name="line-1209"></a><span class='hs-definition'>scanl1</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1210"></a><span class='hs-comment'>{-# INLINE scanl1 #-}</span>
<a name="line-1211"></a><span class='hs-definition'>scanl1</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanl1</span>
<a name="line-1212"></a>
<a name="line-1213"></a><a name="scanl1'"></a><span class='hs-comment'>-- | /O(n)/ Scan over a non-empty vector with a strict accumulator</span>
<a name="line-1214"></a><span class='hs-definition'>scanl1'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1215"></a><span class='hs-comment'>{-# INLINE scanl1' #-}</span>
<a name="line-1216"></a><span class='hs-definition'>scanl1'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanl1'</span>
<a name="line-1217"></a>
<a name="line-1218"></a><a name="prescanr"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left prescan</span>
<a name="line-1219"></a><span class='hs-comment'>--</span>
<a name="line-1220"></a><span class='hs-comment'>-- @</span>
<a name="line-1221"></a><span class='hs-comment'>-- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'</span>
<a name="line-1222"></a><span class='hs-comment'>-- @</span>
<a name="line-1223"></a><span class='hs-comment'>--</span>
<a name="line-1224"></a><span class='hs-definition'>prescanr</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-1225"></a><span class='hs-comment'>{-# INLINE prescanr #-}</span>
<a name="line-1226"></a><span class='hs-definition'>prescanr</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>prescanr</span>
<a name="line-1227"></a>
<a name="line-1228"></a><a name="prescanr'"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left prescan with strict accumulator</span>
<a name="line-1229"></a><span class='hs-definition'>prescanr'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-1230"></a><span class='hs-comment'>{-# INLINE prescanr' #-}</span>
<a name="line-1231"></a><span class='hs-definition'>prescanr'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>prescanr'</span>
<a name="line-1232"></a>
<a name="line-1233"></a><a name="postscanr"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left scan</span>
<a name="line-1234"></a><span class='hs-definition'>postscanr</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-1235"></a><span class='hs-comment'>{-# INLINE postscanr #-}</span>
<a name="line-1236"></a><span class='hs-definition'>postscanr</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>postscanr</span>
<a name="line-1237"></a>
<a name="line-1238"></a><a name="postscanr'"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left scan with strict accumulator</span>
<a name="line-1239"></a><span class='hs-definition'>postscanr'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-1240"></a><span class='hs-comment'>{-# INLINE postscanr' #-}</span>
<a name="line-1241"></a><span class='hs-definition'>postscanr'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>postscanr'</span>
<a name="line-1242"></a>
<a name="line-1243"></a><a name="scanr"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left Haskell-style scan</span>
<a name="line-1244"></a><span class='hs-definition'>scanr</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-1245"></a><span class='hs-comment'>{-# INLINE scanr #-}</span>
<a name="line-1246"></a><span class='hs-definition'>scanr</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanr</span>
<a name="line-1247"></a>
<a name="line-1248"></a><a name="scanr'"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator</span>
<a name="line-1249"></a><span class='hs-definition'>scanr'</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>b</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>b</span>
<a name="line-1250"></a><span class='hs-comment'>{-# INLINE scanr' #-}</span>
<a name="line-1251"></a><span class='hs-definition'>scanr'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanr'</span>
<a name="line-1252"></a>
<a name="line-1253"></a><a name="scanr1"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left scan over a non-empty vector</span>
<a name="line-1254"></a><span class='hs-definition'>scanr1</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1255"></a><span class='hs-comment'>{-# INLINE scanr1 #-}</span>
<a name="line-1256"></a><span class='hs-definition'>scanr1</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanr1</span>
<a name="line-1257"></a>
<a name="line-1258"></a><a name="scanr1'"></a><span class='hs-comment'>-- | /O(n)/ Right-to-left scan over a non-empty vector with a strict</span>
<a name="line-1259"></a><span class='hs-comment'>-- accumulator</span>
<a name="line-1260"></a><span class='hs-definition'>scanr1'</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-layout'>(</span><span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1261"></a><span class='hs-comment'>{-# INLINE scanr1' #-}</span>
<a name="line-1262"></a><span class='hs-definition'>scanr1'</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>scanr1'</span>
<a name="line-1263"></a>
<a name="line-1264"></a><span class='hs-comment'>-- Conversions - Lists</span>
<a name="line-1265"></a><span class='hs-comment'>-- ------------------------</span>
<a name="line-1266"></a>
<a name="line-1267"></a><a name="toList"></a><span class='hs-comment'>-- | /O(n)/ Convert a vector to a list</span>
<a name="line-1268"></a><span class='hs-definition'>toList</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-keyglyph'>[</span><span class='hs-varid'>a</span><span class='hs-keyglyph'>]</span>
<a name="line-1269"></a><span class='hs-comment'>{-# INLINE toList #-}</span>
<a name="line-1270"></a><span class='hs-definition'>toList</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>toList</span>
<a name="line-1271"></a>
<a name="line-1272"></a><a name="fromList"></a><span class='hs-comment'>-- | /O(n)/ Convert a list to a vector</span>
<a name="line-1273"></a><span class='hs-definition'>fromList</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-keyglyph'>[</span><span class='hs-varid'>a</span><span class='hs-keyglyph'>]</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1274"></a><span class='hs-comment'>{-# INLINE fromList #-}</span>
<a name="line-1275"></a><span class='hs-definition'>fromList</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>fromList</span>
<a name="line-1276"></a>
<a name="line-1277"></a><a name="fromListN"></a><span class='hs-comment'>-- | /O(n)/ Convert the first @n@ elements of a list to a vector</span>
<a name="line-1278"></a><span class='hs-comment'>--</span>
<a name="line-1279"></a><span class='hs-comment'>-- @</span>
<a name="line-1280"></a><span class='hs-comment'>-- fromListN n xs = 'fromList' ('take' n xs)</span>
<a name="line-1281"></a><span class='hs-comment'>-- @</span>
<a name="line-1282"></a><span class='hs-definition'>fromListN</span> <span class='hs-keyglyph'>::</span> <span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Int</span> <span class='hs-keyglyph'>-></span> <span class='hs-keyglyph'>[</span><span class='hs-varid'>a</span><span class='hs-keyglyph'>]</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span>
<a name="line-1283"></a><span class='hs-comment'>{-# INLINE fromListN #-}</span>
<a name="line-1284"></a><span class='hs-definition'>fromListN</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>fromListN</span>
<a name="line-1285"></a>
<a name="line-1286"></a><span class='hs-comment'>-- Conversions - Mutable vectors</span>
<a name="line-1287"></a><span class='hs-comment'>-- -----------------------------</span>
<a name="line-1288"></a>
<a name="line-1289"></a><a name="unsafeFreeze"></a><span class='hs-comment'>-- | /O(1)/ Unsafe convert a mutable vector to an immutable one without</span>
<a name="line-1290"></a><span class='hs-comment'>-- copying. The mutable vector may not be used after this operation.</span>
<a name="line-1291"></a><span class='hs-definition'>unsafeFreeze</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>PrimMonad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>MVector</span> <span class='hs-layout'>(</span><span class='hs-conid'>PrimState</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-1292"></a><span class='hs-comment'>{-# INLINE unsafeFreeze #-}</span>
<a name="line-1293"></a><span class='hs-definition'>unsafeFreeze</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeFreeze</span>
<a name="line-1294"></a>
<a name="line-1295"></a><a name="unsafeThaw"></a><span class='hs-comment'>-- | /O(1)/ Unsafely convert an immutable vector to a mutable one without</span>
<a name="line-1296"></a><span class='hs-comment'>-- copying. The immutable vector may not be used after this operation.</span>
<a name="line-1297"></a><span class='hs-definition'>unsafeThaw</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>PrimMonad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>MVector</span> <span class='hs-layout'>(</span><span class='hs-conid'>PrimState</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-1298"></a><span class='hs-comment'>{-# INLINE unsafeThaw #-}</span>
<a name="line-1299"></a><span class='hs-definition'>unsafeThaw</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeThaw</span>
<a name="line-1300"></a>
<a name="line-1301"></a><a name="thaw"></a><span class='hs-comment'>-- | /O(n)/ Yield a mutable copy of the immutable vector.</span>
<a name="line-1302"></a><span class='hs-definition'>thaw</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>PrimMonad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>MVector</span> <span class='hs-layout'>(</span><span class='hs-conid'>PrimState</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-1303"></a><span class='hs-comment'>{-# INLINE thaw #-}</span>
<a name="line-1304"></a><span class='hs-definition'>thaw</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>thaw</span>
<a name="line-1305"></a>
<a name="line-1306"></a><a name="freeze"></a><span class='hs-comment'>-- | /O(n)/ Yield an immutable copy of the mutable vector.</span>
<a name="line-1307"></a><span class='hs-definition'>freeze</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>PrimMonad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>MVector</span> <span class='hs-layout'>(</span><span class='hs-conid'>PrimState</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-layout'>(</span><span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span><span class='hs-layout'>)</span>
<a name="line-1308"></a><span class='hs-comment'>{-# INLINE freeze #-}</span>
<a name="line-1309"></a><span class='hs-definition'>freeze</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>freeze</span>
<a name="line-1310"></a>
<a name="line-1311"></a><a name="unsafeCopy"></a><span class='hs-comment'>-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must</span>
<a name="line-1312"></a><span class='hs-comment'>-- have the same length. This is not checked.</span>
<a name="line-1313"></a><span class='hs-definition'>unsafeCopy</span>
<a name="line-1314"></a> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>PrimMonad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>MVector</span> <span class='hs-layout'>(</span><span class='hs-conid'>PrimState</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-1315"></a><span class='hs-comment'>{-# INLINE unsafeCopy #-}</span>
<a name="line-1316"></a><span class='hs-definition'>unsafeCopy</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>unsafeCopy</span>
<a name="line-1317"></a>
<a name="line-1318"></a><a name="copy"></a><span class='hs-comment'>-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must</span>
<a name="line-1319"></a><span class='hs-comment'>-- have the same length.</span>
<a name="line-1320"></a><span class='hs-definition'>copy</span> <span class='hs-keyglyph'>::</span> <span class='hs-layout'>(</span><span class='hs-conid'>Prim</span> <span class='hs-varid'>a</span><span class='hs-layout'>,</span> <span class='hs-conid'>PrimMonad</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-keyglyph'>=></span> <span class='hs-conid'>MVector</span> <span class='hs-layout'>(</span><span class='hs-conid'>PrimState</span> <span class='hs-varid'>m</span><span class='hs-layout'>)</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-conid'>Vector</span> <span class='hs-varid'>a</span> <span class='hs-keyglyph'>-></span> <span class='hs-varid'>m</span> <span class='hs-conid'>()</span>
<a name="line-1321"></a><span class='hs-comment'>{-# INLINE copy #-}</span>
<a name="line-1322"></a><span class='hs-definition'>copy</span> <span class='hs-keyglyph'>=</span> <span class='hs-conid'>G</span><span class='hs-varop'>.</span><span class='hs-varid'>copy</span>
<a name="line-1323"></a>
<a name="line-1324"></a>
</pre></body>
</html>
