!o`G      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    Safe=      SafeI- !"#$%&'()*+,-./0123456789:;<=>?@ABC-,+*)('&%$#"! -./0123456789:;<=>?@ABCUnsafe 456FHISXjGcompact-sequencesUnsafely convert a  of size n to an D n . This is genuinely unsafe: if na is greater than the true array size, then some operation will eventually violate memory safety.Mcompact-sequencesAppend two arrays of the same size. We take the size of the argument arrays so we can build the result array before loading the first argument array into cache. Is this the right approach? Not sure. We *certainly* don't want to just use  , because DEFGHIJKLMNOPQRDEFGHIJKLMNOPQR  TrustworthyF< DFHIJKMPR DFIJHKMPRNone %1456>FXg"9VZYXW[^]\_ba`cdefgihjlkm~}|{zyxwvutsrqpon9m~}|{zyxwvutsrqponjlkgihefcd_ba`[^]\VZYXW Trustworthy%456>FHVX_g* compact-sequencesA deque.compact-sequences4A bidirectional pattern synonym for the empty deque.compact-sequencesFA bidirectional pattern synonym for manipulating the rear of a deque.compact-sequencesGA bidirectional pattern synonym for manipulating the front of a deque.compact-sequencesThe empty deque.compact-sequences+Enqueue an element at the front of a deque.compact-sequences*Enqueue an element at the rear of a deque.compact-sequencesAn infix synonym for .compact-sequencesAn infix synonym for .compact-sequences-Dequeue an element from the front of a deque.compact-sequences,Dequeue an element from the rear of a deque.compact-sequences O(n \log n) . Convert a list to a 7, with the head of the list at the front of the deque.compact-sequences O(n) (. Convert a list of the given size to a 7, with the head of the list at the front of the deque.5544 Safe+ None %1456FX_g5compact-sequencesUncons from a node and snoc onto it. Ensure that if the operation is expensive then it leaves the node in a safe configuration. Why do we need this? Suppose we have Two m Two8If we snoc onto this, the operation cascades, and we get Two m ZeroThen when we view, we get One m Zerowhich is not safe.'Instead, we need to view first, getting One m Two0immediately, then snoc on, cascading and getting Three m Zerowhich is safe.If instead we have One m Onehwe have to do the opposite: snoc then view. We might as well just write a dedicated shifting operation.&& Trustworthy%456>FHVXgK compact-sequencesA queue.compact-sequences4A bidirectional pattern synonym for the empty queue.compact-sequencesCA unidirectional pattern synonym for viewing the front of a queue.compact-sequencesThe empty queue.compact-sequences*Enqueue an element at the rear of a queue.compact-sequencesAn infix synonym for .compact-sequences-Dequeue an element from the front of a queue.compact-sequencesXTake up to the given number of elements from the front of a queue to form a new queue.  O(\min (k, n))  , where  k  is the integer argument and  n  is the size of the queue.compact-sequences O(\min(m, n))  . Compare an  to the length of a . *compareLength n xs = compare n (length xs)compact-sequences O(n \log n) . Convert a list to a 7, with the head of the list at the front of the queue.compact-sequences O(n) (. Convert a list of the given size to a 7, with the head of the list at the front of the queue.compact-sequences O(n) (. Convert a list of the given size to a ?, with the head of the list at the front of the queue. Unlike , the conversion is performed incrementally. This is generally beneficial if the list is represented compactly (e.g., an enumeration) or when it's otherwise not important to consume the entire list immediately. 544 SafeL Safe /456HVXM  Trustworthy %456HVg_ compact-sequencesA stack.compact-sequences4A bidirectional pattern synonym for the empty stack.compact-sequencesGA bidirectional pattern synonym for working with the front of a stack.compact-sequencesThe empty stack.compact-sequences*Push an element onto the front of a stack. O(\log n) compact-sequences(Pop an element off the front of a stack.Accessing the first element is  O(1) . Accessing the rest is  O(\log n) .compact-sequencesAn infix synonym for .compact-sequences O(\min(m, n))  . Compare an  to the length of a . *compareLength n xs = compare n (length xs)compact-sequencesXTake up to the given number of elements from the front of a stack to form a new stack.  O(\min (k, n))  , where  k  is the integer argument and  n  is the size of the stack.compact-sequences O(n \log n) Y. Convert a list to a stack, with the first element of the list as the top of the stack. compact-sequences O(n) i. Convert a list of known length to a stack, with the first element of the list as the top of the stack.   555 Safe_    !"#$%%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQQRSTUVWXYZ[\]^_`abcdefghijklmknnoopqrstuvwxyz{|}~vvw^hww^wcde   w  ^ 0compact-sequences-0.2.0.0-9YXDgrMUpOpIo4CZoVL69s%Data.CompactSequence.Internal.Numbers"Data.CompactSequence.Internal.Size#Data.CompactSequence.Internal.Array#Data.CompactSequence.Deque.Internal*Data.CompactSequence.Deque.Simple.Internal#Data.CompactSequence.Queue.Internal*Data.CompactSequence.Queue.Simple.Internal#Data.CompactSequence.Stack.Internal*Data.CompactSequence.Stack.Simple.Internal(Data.CompactSequence.Internal.Array.Safe!Data.CompactSequence.Deque.Simple!Data.CompactSequence.Queue.Simple!Data.CompactSequence.Stack.SimpleBin45Four45Five45End45OneEnd45TwoEnd45 ThreeEnd45Bin23Two23Three23End23OneEnd23DyadicDOneDTwoDEndtoDyadictoBin23toBin45 $fEqDyadic $fShowDyadic $fEqBin23 $fShowBin23SizeSz19Sz18Sz17Sz16Sz15Sz14Sz13Sz12Sz11Sz10Sz9Sz8Sz7Sz6Sz5Sz4Sz3Sz2Sz1TwicegetSizetwicehalfonesz1sz2sz3sz4sz5sz6sz7sz8sz9sz10sz11sz12sz13sz14sz15sz16sz17sz18sz19Array singletonunsafeSmallArrayToArrayarrayToSmallArray getSingleton# getSingletonA splitArraysplitSmallArray#appendappendSmallArrayscreateSmallArrayarraySplitListNsmallArraySplitListNfromList$fFunctorArray$fFoldableArray$fTraversableArrayDigitOneTwoThreeFourDeque_Empty_Shallow_Deep_UCUS EmptyUCUSOneUCUSShiftedRShiftedLViewREmptyRSnocRViewLEmptyLConsLDequeEmptyShallowDeep11Deep12Deep13Deep14Deep21Deep22Deep23Deep24Deep31Deep32Deep33Deep34Deep41Deep42Deep43Deep44DeepemptyconsAsnocAviewLAviewRAshiftLAshriftLshiftRAshriftR consSnocA unconsUnsnocA matchDeep fromListNM fromListNS $fOrdDeque $fEqDeque$fFunctorDeque$fFoldableDeque$fTraversableDeque:>:<conssnoc|><|unconsunsnoc fromListN $fMonoidDeque$fSemigroupDeque $fIsListDeque $fShowDequeShiftedAViewA2EmptyA2ConsA2ViewAEmptyAConsAQueue_Node_QueueNode10Node11Node12Node20Node21Node22Node30Node31Node32RDRD0RD1RD2FDFD1FD2FD3Node matchNode singletonAviewAshiftAshrift $fOrdQueue $fEqQueue $fShowQueue$fFunctorQueue$fFoldableQueue$fTraversableQueuetakefromListNIncremental $fMonoidQueue$fSemigroupQueue $fIsListQueueStackunconsA$fFoldableStack $fShowStack $fOrdStack $fEqStack$fFunctorStack$fTraversableStackunStack compareLength $fIsListStack $fMonoidStack$fSemigroupStack(primitive-0.7.1.0-6Ng9GYhvLyE4pBQRYaGxSxData.Primitive.SmallArray SmallArraybaseGHC.Base<>ghc-prim GHC.TypesInt