úÎSµR4     None :DORT&Splits bytestrings after each pattern patH. Tries to minimize the number of intermediate bytestring constructors.The following function ske expects a string str and a pattern pat< and then returns a tuple with the splitted bytestrings in fst and the return value in snd.The inner parser parse uses zoomp to draw the full inner producer, which should contain just one bytestring, namely one of the split off ones. parseY doesn't do anything with the inner producer, except returning the contained bytestring.parse returns Right $ concat xs on a correct parse, and Left []$ once the input has been exhausted. ÿ¯ske :: ByteString -> ByteString -> ([ByteString],[ByteString],[ByteString]) ske pat str | BS.null pat || BS.null str = ([],[],[]) ske pat str = let parse = do xs <- zoom (splitKeepEnd pat) PP.drawAll case xs of [] -> return $ Left [] xs -> return $ Right $ BS.concat xs (a,(b,p)) = runIdentity . P.toListM' $ PP.parsed parse $ PP.yield str in (a,b, fst . runIdentity . P.toListM' $ p) ASplit a string into substrings, where each substring starts with pat+ and continues until just before the next pat$ (or until there is no more input).5Any prefix that does not start with the substring is kept!/Since each substring is supposed to start with pat`, there is a small problem. What about a header that prefixes the string we are interested in?/Generic splitting function. Takes a bytestring [a,b,c] (where a,b,c; are substrings of the bytestring!) and performs the split.splitter functionpattern to split on.lens into the individual split off bytestringsNone :DORTDEvaluates chunks of pipes elements in parallel with a pure function.ÏEvaluates chunks of pipes elements in parallel with a pure function. Before and after each parallel step, a monadic function is run. This allows generation of certain statistics or information during runs.*number of elements to evaluate in parallelwith which strategy!function to be mapped in parallel*number of elements to evaluate in parallelwith which strategy pure function to run in parallelfunction to run beforefunction to run afterSafe :DORTTriangular numbers. https://oeis.org/A000217&Size of an upper triangle starting at i and ending at j+. "(0,N)" what be the normal thing to use. ÀSubword indexing. Given the longest subword and the current subword, calculate a linear index "[0,..]". "(l,n)" in this case means "l"ower bound, length "n". And "(i,j)" is the normal index. ¢0 1 2 3 <- j = ... 0 1 2 3 i=0 _ 4 5 6 i=1 _ _ 7 8 i=2 9 i=3 i=2, j=3 -> (4+1) * i - tri i + j _ _ _ the triangular number to subtract. Linear index to paired.We have indices in [0,N], and linear index k. (N+1)*i - (i*(i+1)/2) + j == K     None :DORT Turns a stream into a vector.&TODO insert index checks? Generalized  flag devel    Safe :DORT 5If the size of the input is known before-hand or not.2Select only a subset of the possible enumerations.Enumerate all elements#Enumerate from a value and at most N elements7Shall we combine elements on the main diagonal as well? If we choose NoDiagS, we deal with upper triangular matrices that are effectively one element smaller.      None :DORTAGeneralized upper triangular elements. Given a list of elements  [e_1,...,e_k], we want to return pairs  (e_i,e_j)+ such that we have all ordered pairs with i<j (if NoDiagonal elements), or i<=j (if OnDiagonal elements).upperTri will force the spine of t a) but is consumed linearly with a strict Data.Foldable.foldl'. Internally we keep a  Data.IntMap of the retained elements.This is important if the  Enumerate type is set to  FromN k n. We start at the kth element, and produce n elements. TODO compare IntMap and HashMap.TODO inRange is broken.If the size of t a, is known beforehand, give the appropriate  KnownSize n, otherwise give  UnknownSize. Using  UnknownSize# will force the complete spine of t a.BThe enumeration will include the pairs on the main diagonal with OnDiag , meaning (i,i) will be included for all i. Otherwise, NoDiag will exclude these elements.Either enumerate All elements or enumerate the s elements starting at k with  FromN k s..The foldable data structure to enumerate over."If there is any error then return  Left errorMsg. Otherwise we have Right (imap, numElems, list). The imapS structure holds the subset of elements with which we actually generate elements. numElems\ is the total number of elements that will be generated. This is calculated without touch list . Finally, list/ is the lazy list of elements to be generated.None :DORTUpper triangular elements.Outer pairing of all as with all bs8. This one is quasi-trivial, but here for completeness. Safe :DORT      !"#$%%DPutils-0.0.1.0-4TMbpeKaoxSEE5v6N8qdzPipes.Split.ByteStringPipes.ParallelMath.TriangularNumbersData.Vector.Generic.UnstreamData.Paired.CommonData.Paired.FoldableData.Paired.VectorData.Char.UtilLens' splitKeepEndsplitKeepStart splitGenericreferenceByteStringTokenizerpipePar pipeParBAtriangularNumberlinearizeUppertritoLinear fromLinearstreamToVectorMSizeHint UnknownSize KnownSize EnumerateAllFromNOnDiagNoDiag $fEqOnDiag $fEqEnumerate $fEqSizeHintupperTri upperTriVG rectangularVGc2w8w82c