Sequence - BHC Documentation

empty :: Seq a { } #

The empty sequence. O(1)

singleton :: a -> Seq a { } #

A sequence with a single element. O(1)

<| :: a -> (Seq a) -> Seq a { } #

a :: { } #

|> :: (Seq a) -> a -> Seq a { } #

e :: { } #

a :: { } #

ys :: { } #

>< :: (Seq a) -> (Seq a) -> Seq a { } #

n2 :: { } #

fromList :: [a] -> Seq a { } #

Create a sequence from a list. O(n)

fromFunction :: Int -> (Int -> a) -> Seq a { } #

Create a sequence of given length from a function. O(n)

replicate :: Int -> a -> Seq a { } #

Create a sequence of n copies of an element. O(n)

replicateA :: (Applicative f) => Int -> (f a) -> f (Seq a) { } #

Applicative replicate

replicateM :: (Monad m) => Int -> (m a) -> m (Seq a) { } #

Monadic replicate

null :: (Seq a) -> Bool { } #

Is the sequence empty? O(1)

length :: (Seq a) -> Int { } #

The number of elements in the sequence. O(1)

viewl :: (Seq a) -> ViewL a { } #

View from the left. O(1) amortized

viewr :: (Seq a) -> ViewR a { } #

View from the right. O(1) amortized

lookup :: Int -> (Seq a) -> Maybe a { } #

Safe indexing. O(log(min(i, n-i)))

!? :: (Seq a) -> Int -> Maybe a { } #

Infix safe indexing

index :: (Seq a) -> Int -> a { } #

Unsafe indexing. O(log(min(i, n-i)))

adjust :: (a -> a) -> Int -> (Seq a) -> Seq a { } #

Adjust element at index. O(log(min(i, n-i)))

adjust' :: (a -> a) -> Int -> (Seq a) -> Seq a { } #

Strict adjust

update :: Int -> a -> (Seq a) -> Seq a { } #

take :: Int -> (Seq a) -> Seq a { } #

Take first n elements. O(log(min(n, size-n)))

drop :: Int -> (Seq a) -> Seq a { } #

Drop first n elements. O(log(min(n, size-n)))

splitAt :: Int -> (Seq a) -> (Seq a, Seq a) { } #

Split at index. O(log(min(i, n-i)))

insertAt :: Int -> a -> (Seq a) -> Seq a { } #

Insert element at index. O(log(min(i, n-i)))

deleteAt :: Int -> (Seq a) -> Seq a { } #

Delete element at index. O(log(min(i, n-i)))

elemIndexL :: (Eq a) => a -> (Seq a) -> Maybe Int { } #

Index of first occurrence from left

elemIndicesL :: (Eq a) => a -> (Seq a) -> [Int] { } #

All indices of element from left

elemIndexR :: (Eq a) => a -> (Seq a) -> Maybe Int { } #

Index of first occurrence from right

elemIndicesR :: (Eq a) => a -> (Seq a) -> [Int] { } #

All indices of element from right

findIndexL :: (a -> Bool) -> (Seq a) -> Maybe Int { } #

Find first index satisfying predicate from left

findIndicesL :: (a -> Bool) -> (Seq a) -> [Int] { } #

Find all indices satisfying predicate from left

findIndexR :: (a -> Bool) -> (Seq a) -> Maybe Int { } #

Find first index satisfying predicate from right

findIndicesR :: (a -> Bool) -> (Seq a) -> [Int] { } #

Find all indices satisfying predicate from right

reverse :: (Seq a) -> Seq a { } #

Reverse a sequence. O(n)

intersperse :: a -> (Seq a) -> Seq a { } #

Intersperse an element between elements. O(n)

scanl :: (a -> b -> a) -> a -> (Seq b) -> Seq a { } #

Left scan. O(n)

scanl1 :: (a -> a -> a) -> (Seq a) -> Seq a { } #

Left scan without starting value. O(n)

scanr :: (a -> b -> b) -> b -> (Seq a) -> Seq b { } #

Right scan. O(n)

scanr1 :: (a -> a -> a) -> (Seq a) -> Seq a { } #

Right scan without starting value. O(n)

sort :: (Ord a) => (Seq a) -> Seq a { } #

Stable sort. O(n log n)

sortBy :: (a -> a -> Ordering) -> (Seq a) -> Seq a { } #

Stable sort with custom comparison. O(n log n)

sortOn :: (Ord b) => (a -> b) -> (Seq a) -> Seq a { } #

Stable sort on projection. O(n log n)

unstableSort :: (Ord a) => (Seq a) -> Seq a { } #

Unstable sort (potentially faster). O(n log n)

unstableSortBy :: (a -> a -> Ordering) -> (Seq a) -> Seq a { } #

Unstable sort with custom comparison. O(n log n)

unstableSortOn :: (Ord b) => (a -> b) -> (Seq a) -> Seq a { } #

Unstable sort on projection. O(n log n)

tails :: (Seq a) -> Seq (Seq a) { } #

All suffixes. O(n)

inits :: (Seq a) -> Seq (Seq a) { } #

All prefixes. O(n)

chunksOf :: Int -> (Seq a) -> Seq (Seq a) { } #

Split into chunks of given size. O(n)

takeWhileL :: (a -> Bool) -> (Seq a) -> Seq a { } #

Take elements from left while predicate holds. O(i)

takeWhileR :: (a -> Bool) -> (Seq a) -> Seq a { } #

Take elements from right while predicate holds. O(i)

dropWhileL :: (a -> Bool) -> (Seq a) -> Seq a { } #

Drop elements from left while predicate holds. O(i)

dropWhileR :: (a -> Bool) -> (Seq a) -> Seq a { } #

Drop elements from right while predicate holds. O(i)

spanl :: (a -> Bool) -> (Seq a) -> (Seq a, Seq a) { } #

Span from left. O(i)

spanr :: (a -> Bool) -> (Seq a) -> (Seq a, Seq a) { } #

Span from right. O(i)

breakl :: (a -> Bool) -> (Seq a) -> (Seq a, Seq a) { } #

Break from left. O(i)

breakr :: (a -> Bool) -> (Seq a) -> (Seq a, Seq a) { } #

Break from right. O(i)

partition :: (a -> Bool) -> (Seq a) -> (Seq a, Seq a) { } #

Partition by predicate. O(n)

filter :: (a -> Bool) -> (Seq a) -> Seq a { } #

Filter elements. O(n)

zip :: (Seq a) -> (Seq b) -> Seq (a, b) { } #

Zip two sequences. O(min(n, m))

zipWith :: (a -> b -> c) -> (Seq a) -> (Seq b) -> Seq c { } #

zip3 :: (Seq a) -> (Seq b) -> (Seq c) -> Seq (a, b, c) { } #

Zip three sequences. O(min(n, m, o))

zipWith3 :: (a -> b -> c -> d) -> (Seq a) -> (Seq b) -> (Seq c) -> Seq d { } #

zip4 :: (Seq a) -> (Seq b) -> (Seq c) -> (Seq d) -> Seq (a, b, c, d) { } #

Zip four sequences. O(min lengths)

zipWith4 :: (a -> b -> c -> d -> e) -> (Seq a) -> (Seq b) -> (Seq c) -> (Seq d) -> Seq e { } #

unzip :: (Seq (a, b)) -> (Seq a, Seq b) { } #

Unzip a sequence of pairs. O(n)

unzipWith :: (a -> (b, c)) -> (Seq a) -> (Seq b, Seq c) { } #

Unzip with function. O(n)

foldMapWithIndex :: (Monoid m) => (Int -> a -> m) -> (Seq a) -> m { } #

Fold with index. O(n)

foldlWithIndex :: (b -> Int -> a -> b) -> b -> (Seq a) -> b { } #

Left fold with index. O(n)

foldrWithIndex :: (Int -> a -> b -> b) -> b -> (Seq a) -> b { } #

Right fold with index. O(n)

traverseWithIndex :: (Applicative f) => (Int -> a -> f b) -> (Seq a) -> f (Seq b) { } #

Traverse with index. O(n)

mapWithIndex :: (Int -> a -> b) -> (Seq a) -> Seq b { } #

Map with index. O(n)

node2 :: a -> a -> Node a { } #

node3 :: a -> a -> a -> Node a { } #

sizeNode :: (Node a) -> Int { } #

nodeToDigit :: (Node a) -> Digit a { } #

consDigit :: a -> (Digit a) -> Digit a { } #

snocDigit :: (Digit a) -> a -> Digit a { } #

sizeDigit :: (Digit a) -> Int { } #

digitToList :: (Digit a) -> [a] { } #

deep :: (Digit a) -> (Seq (Node a)) -> (Digit a) -> Seq a { } #

sizeMiddle :: (Seq (Node a)) -> Int { } #

pullL :: (Seq (Node a)) -> (Digit a) -> Seq a { } #

pullR :: (Digit a) -> (Seq (Node a)) -> Seq a { } #

digitToSeq :: (Digit a) -> Seq a { } #

addDigits0 :: (Seq (Node a)) -> (Digit a) -> (Digit a) -> (Seq (Node a)) -> Seq (Node a) { } #

appendTree1 :: (Seq (Node a)) -> (Node a) -> (Seq (Node a)) -> Seq (Node a) { } #

addDigits1 :: (Seq (Node (Node a))) -> (Digit (Node a)) -> (Node a) -> (Digit (Node a)) -> (Seq (Node (Node a))) -> Seq (Node (Node a))

{ } #

nodes :: [a] -> Node a { } #

lookupTree :: Int -> (Seq a) -> Maybe a { } #

lookupDigit :: Int -> (Digit a) -> Maybe a { } #

lookupMiddle :: Int -> (Seq (Node a)) -> Maybe a { } #

lookupNode :: Int -> (Node a) -> Maybe a { } #

lookupDigitN :: Int -> (Digit (Node a)) -> Maybe a { } #

sizeDigitN :: (Digit (Node a)) -> Int { } #

adjustTree :: (a -> a) -> Int -> (Seq a) -> Seq a { } #

adjustDigit :: (a -> a) -> Int -> (Digit a) -> Digit a { } #

adjustMiddle :: (a -> a) -> Int -> (Seq (Node a)) -> Seq (Node a) { } #

adjustNode :: (a -> a) -> Int -> (Node a) -> Node a { } #

adjustDigitN :: (a -> a) -> Int -> (Digit (Node a)) -> Digit (Node a) { } #

splitTreeAt :: Int -> (Seq a) -> (Seq a, Seq a) { } #

splitDigitAt :: Int -> (Digit a) -> ([a], [a]) { } #

splitMiddleAt :: Int -> (Seq (Node a)) -> (Seq (Node a), Node a, Seq (Node a)) { } #

splitDigitNAt :: Int -> (Digit (Node a)) -> ([Node a], Node a, [Node a]) { } #

splitNode :: Int -> (Node a) -> ([a], [a]) { } #

splitNodeN :: Int -> (Node (Node a)) -> ([Node a], Node a, [Node a]) { } #

digitToSeq' :: [a] -> Seq a { } #

digitToSeqN :: [Node a] -> Seq (Node a) { } #

maybeDeep :: [a] -> (Seq (Node a)) -> (Digit a) -> Seq a { } #

maybeDeep' :: (Digit a) -> (Seq (Node a)) -> [a] -> Seq a { } #

maybeDeepN :: [Node a] -> (Seq (Node (Node a))) -> (Digit (Node a)) -> Seq (Node a) { } #

maybeDeepN' :: (Digit (Node a)) -> (Seq (Node (Node a))) -> [Node a] -> Seq (Node a) { } #

mapSeq :: (a -> b) -> (Seq a) -> Seq b { } #

findInDigit :: (a -> Bool) -> Int -> (Digit a) -> Maybe Int { } #

findInDigitR :: (a -> Bool) -> Int -> (Digit a) -> Maybe Int { } #

findInMiddle :: (a -> Bool) -> Int -> (Seq (Node a)) -> Maybe Int { } #

findInMiddleR :: (a -> Bool) -> Int -> (Seq (Node a)) -> Maybe Int { } #

findInNode :: (a -> Bool) -> Int -> (Node a) -> Maybe Int { } #

findInNodeR :: (a -> Bool) -> Int -> (Node a) -> Maybe Int { } #

findInDigitN :: (a -> Bool) -> Int -> (Digit (Node a)) -> Maybe Int { } #

findInDigitNR :: (a -> Bool) -> Int -> (Digit (Node a)) -> Maybe Int { } #

foldMapDigitWithIndex :: (Monoid m) => (Int -> a -> m) -> Int -> (Digit a) -> m { } #

foldMapMiddleWithIndex :: (Monoid m) => (Int -> a -> m) -> Int -> (Seq (Node a)) -> m { } #

foldMapNodeWithIndex :: (Monoid m) => (Int -> a -> m) -> Int -> (Node a) -> m { } #

foldMapDigitNWithIndex :: (Monoid m) => (Int -> a -> m) -> Int -> (Digit (Node a)) -> m { } #

foldlDigitWithIndex :: (b -> Int -> a -> b) -> b -> Int -> (Digit a) -> b { } #

foldlMiddleWithIndex :: (b -> Int -> a -> b) -> b -> Int -> (Seq (Node a)) -> b { } #

foldlNodeWithIndex :: (b -> Int -> a -> b) -> b -> Int -> (Node a) -> b { } #

foldlDigitNWithIndex :: (b -> Int -> a -> b) -> b -> Int -> (Digit (Node a)) -> b { } #

foldrDigitWithIndex :: (Int -> a -> b -> b) -> b -> Int -> (Digit a) -> b { } #

foldrMiddleWithIndex :: (Int -> a -> b -> b) -> b -> Int -> (Seq (Node a)) -> b { } #

foldrNodeWithIndex :: (Int -> a -> b -> b) -> b -> Int -> (Node a) -> b { } #

foldrDigitNWithIndex :: (Int -> a -> b -> b) -> b -> Int -> (Digit (Node a)) -> b { } #

traverseDigitWithIndex :: (Applicative f) => (Int -> a -> f b) -> Int -> (Digit a) -> f (Digit b) { } #

traverseMiddleWithIndex :: (Applicative f) => (Int -> a -> f b) -> Int -> (Seq (Node a)) -> f (Seq (Node b)) { } #

traverseNodeWithIndex :: (Applicative f) => (Int -> a -> f b) -> Int -> (Node a) -> f (Node b) { } #

traverseDigitNWithIndex :: (Applicative f) => (Int -> a -> f b) -> Int -> (Digit (Node a)) -> f (Digit (Node b)) { } #

mapDigitWithIndex :: (Int -> a -> b) -> Int -> (Digit a) -> Digit b { } #

mapMiddleWithIndex :: (Int -> a -> b) -> Int -> (Seq (Node a)) -> Seq (Node b) { } #

mapNodeWithIndex :: (Int -> a -> b) -> Int -> (Node a) -> Node b { } #

mapDigitNWithIndex :: (Int -> a -> b) -> Int -> (Digit (Node a)) -> Digit (Node b) { } #

mergeSort :: (a -> a -> Ordering) -> [a] -> [a] { } #

merge :: (a -> a -> Ordering) -> [a] -> [a] -> [a] { } #