Containers

https://hackage.haskell.org/package/containers-0.8/docs/
Admin
Containers is a Haskell package providing efficient implementations of common container data...
Tokens:346,234
Snippets:2,483
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example of keys for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Shows how to get all keys from an IntMap in ascending order. Handles empty maps.

```haskell
keys (fromList [(5,"a"), (3,"b")]) == [3,5]
keys empty == []
```

--------------------------------

### Example maps for merge demonstration

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Merge-Lazy.html

These are example IntMaps used to illustrate the behavior of the `merge` function and its associated tactics.

```haskell
m1 = [(0, 'a'), (1, 'b'), (3, 'c'), (4, 'd')]
m2 = [(1, "one"), (2, "two"), (4, "three")]
```

--------------------------------

### Example IntMap data

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Merge-Lazy.html

Example IntMaps used to demonstrate the behavior of mergeA.

```haskell
m1 = [(0, 'a'), (1, 'b'), (3,'c'), (4, 'd')]
m2 = [(1, "one"), (2, "two"), (4, "three")]
```

--------------------------------

### Example of keysSet for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Shows how to obtain the set of all keys from an IntMap. Handles empty maps.

```haskell
keysSet (fromList [(5,"a"), (3,"b")]) == Data.IntSet.fromList [3,5]
keysSet empty == Data.IntSet.empty
```

--------------------------------

### split example

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntSet-Internal.html

Demonstrates how `split` divides a set into elements less than and greater than a given key.

```haskell
split 3 (fromList [1..5]) == (fromList [1,2], fromList [4,5])
```

--------------------------------

### Cartesian Product Example

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Set.html

An example demonstrating the Cartesian product of a set of integers and a set of characters.

```haskell
cartesianProduct (fromList [1,2]) (fromList ['a','b']) =
  fromList [(1,'a'), (1,'b'), (2,'a'), (2,'b')]
```

--------------------------------

### Power Set Calculation Example

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Set-Internal.html

Illustrates the calculation of a power set, which is the set of all possible subsets of a given set. The example shows the expected output for a set of three elements.

```haskell
t `member` powerSet s == t `isSubsetOf` s
```

```haskell
powerSet (fromList [1,2,3]) =
  fromList $ map fromList [[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]]
```

--------------------------------

### Example of elems for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Demonstrates retrieving all elements from an IntMap in ascending key order. Handles empty maps.

```haskell
elems (fromList [(5,"a"), (3,"b")]) == ["b","a"]
elems empty == []
```

--------------------------------

### Example of merge with mapMaybeMissing and zipWithMaybeMatched

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Merge-Lazy.html

Demonstrates the fundamental usage of `merge` by combining `mapMaybeMissing` for handling keys unique to each map and `zipWithMaybeMatched` for keys present in both. The example illustrates how `g1`, `g2`, and `f` are applied to determine the final merged map.

```haskell
merge (mapMaybeMissing g1)
             (mapMaybeMissing g2)
             (zipWithMaybeMatched f)
             m1 m2
```

--------------------------------

### Example of toList for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Demonstrates converting an IntMap to a list of key-value pairs. The order is ascending by key. Handles empty maps.

```haskell
toList (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
tolist empty == []
```

--------------------------------

### Disjoint Union Example

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Set.html

An example showing the disjoint union of a set of integers and a set of strings.

```haskell
disjointUnion (fromList [1,2]) (fromList ["hi", "bye"]) =
  fromList [Left 1, Left 2, Right "hi", Right "bye"]
```

--------------------------------

### Example of assocs for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Demonstrates converting an IntMap to a list of key-value pairs in ascending key order. This is an alias for `toAscList`.

```haskell
assocs (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
assocs empty == []
```

--------------------------------

### Example of foldlWithKey for IntMap keys

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Demonstrates using foldlWithKey to extract all keys from an IntMap into a list in reverse order.

```haskell
keys = reverse . foldlWithKey (\ks k x -> k:ks) []
```

--------------------------------

### Example of toAscList for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Shows how to convert an IntMap to a list of key-value pairs sorted in ascending key order. Handles empty maps.

```haskell
toAscList (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
```

--------------------------------

### Disjoint Set Examples

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Set-Internal.html

Demonstrates checking if two sets are disjoint (have no common elements). Includes examples with overlapping and non-overlapping sets, as well as empty sets. An alternative implementation using intersection is also shown.

```haskell
disjoint (fromList [2,4,6])   (fromList [1,3])     == True
disjoint (fromList [2,4,6,8]) (fromList [2,3,5,7]) == False
disjoint (fromList [1,2])     (fromList [1,2,3,4]) == False
disjoint (fromList [])        (fromList [])        == True
```

```haskell
xs `disjoint` ys = null (xs `intersection` ys)
```

--------------------------------

### Example of foldl for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Shows how to use foldl to reverse the elements of a map into a list. This is equivalent to `reverse . elems`.

```haskell
elems = reverse . foldl (flip (:)) []
```

--------------------------------

### Example of `merge` Usage

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Merge-Strict.html

Illustrates how `merge` works by aligning keys from two maps and applying different functions based on key presence.

```haskell
m1 = [(0, 'a'), (1, 'b'), (3, 'c'), (4, 'd')]
m2 = [(1, "one"), (2, "two"), (4, "three")]
```

```haskell
m1 = [(0, 'a'), (1, 'b'),               (3, 'c'), (4, 'd')]
m2 =           [(1, "one"), (2, "two"),           (4, "three")]
```

```haskell
maybes = [g1 0 'a', f 1 'b' "one", g2 2 "two", g1 3 'c', f 4 'd' "three"]
```

```haskell
keys =     0        1          2           3        4
results = [Nothing, Just True, Just False, Nothing, Just True]
```

```haskell
return value = [(1, True), (2, False), (4, True)]
```

--------------------------------

### Example of foldrWithKey for IntMap keys

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Illustrates using foldrWithKey to extract all keys from an IntMap into a list.

```haskell
keys map = foldrWithKey (\k x ks -> k:ks) [] map
```

--------------------------------

### Example of foldl with length calculation

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Demonstrates using foldl to calculate the total length of string values in an IntMap.

```haskell
let f len a = len + (length a)
foldl f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
```

--------------------------------

### splitRoot examples

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntSet-Internal.html

Illustrates the decomposition of a set into sub-sets based on the internal tree structure using `splitRoot`. The number of returned subsets may vary.

```haskell
splitRoot (fromList [1..120]) == [fromList [1..63],fromList [64..120]]
splitRoot empty == []
```

--------------------------------

### Example of foldr for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Demonstrates using foldr to extract elements into a list. This is equivalent to the `elems` function.

```haskell
elems map = foldr (:) [] map
```

--------------------------------

### Example of toDescList for IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Demonstrates converting an IntMap to a list of key-value pairs sorted in descending key order. Handles empty maps.

```haskell
toDescList (fromList [(5,"a"), (3,"b")]) == [(5,"a"), (3,"b")]
```

--------------------------------

### Example of foldrWithKey for string concatenation

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Shows how to use foldrWithKey to build a formatted string representation of the map's key-value pairs.

```haskell
let f k a result = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")"
foldrWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (5:a)(3:b)"
```

--------------------------------

### Example of foldlWithKey for string concatenation

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Shows how to use foldlWithKey to build a formatted string representation of the map's key-value pairs, with keys in ascending order.

```haskell
let f result k a = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")"
foldlWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (3:b)(5:a)"
```

--------------------------------

### take

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Lazy.html

O(logn). Take a given number of entries in key order, beginning with the smallest keys.

```APIDOC
## take

### Description
Take a given number of entries in key order, beginning with the smallest keys.

### Signature
`take :: Int -> Map k a -> Map k a`

### Example
```haskell
take n = fromDistinctAscList . take n . toAscList
```
```

--------------------------------

### Show (IntMap a)

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Show instance for IntMap.

```APIDOC
## Show (IntMap a)

### Description
Show instance for IntMap.
```

--------------------------------

### Get the length of a sequence

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence-Internal.html

Use `length` to get the number of elements in a sequence. This operation has O(1) complexity.

```haskell
length :: Seq a -> Int
```

--------------------------------

### Show Instance

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Internal.html

Provides Show capabilities for Map k a, allowing conversion to string representation. Requires keys and values to be showable.

```APIDOC
## Show (Map k a)

### Description
Provides Show capabilities for Map k a, allowing conversion to string representation.

### Requirements
- `Show k`
- `Show a`

### Methods
- `showsPrec :: Int -> Map k a -> ShowS`
- `show :: Map k a -> String`
- `showList :: [Map k a] -> ShowS`
```

--------------------------------

### Show a => Show (IntMap a)

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Internal.html

Instance for showing IntMaps as strings.

```APIDOC
## Show a => Show (IntMap a)

### Methods
- `show :: IntMap a -> String`
```

--------------------------------

### Show IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict.html

Provides Show instance for IntMap.

```APIDOC
## Show a => Show (IntMap a)

### Description
Provides Show instance for IntMap.
```

--------------------------------

### reachable

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Graph.html

Checks if a vertex is reachable from a starting vertex in a graph.

```APIDOC
## reachable

### Description
Returns `True` if the second vertex is reachable from the first.

### Examples
```haskell
reachable (buildG (0,0) []) 0 == [0]
reachable (buildG (0,2) [(0,1), (1,2)]) 0 == [0,1,2]
```
```

--------------------------------

### Get the set of all keys

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Lazy.html

Returns the set of all keys present in the map.

```haskell
keysSet (fromList [(5,"a"), (3,"b")]) == Data.Set.fromList [3,5]
keysSet empty == Data.Set.empty
```

--------------------------------

### Sized Instance for Elem

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence-Internal.html

Defines how to get the size of an Elem structure.

```APIDOC
## Sized Instance for Elem

### Description
Defines how to get the size of an Elem structure.

### Methods
- `size :: Elem a -> Int`
```

--------------------------------

### reachable

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Graph.html

Finds all vertices that are reachable from a specified starting vertex in the graph.

```APIDOC
## reachable

### Description
Returns the list of vertices reachable from a given vertex.

### Type Signature
`reachable :: Graph -> Vertex -> [Vertex]`

### Parameters
- `graph`: The input `Graph`.
- `startVertex`: The `Vertex` from which to find reachable vertices.

### Returns
A list of `Vertex` identifiers reachable from the `startVertex`.
```

--------------------------------

### mergeA Example Usage

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Merge-Lazy.html

Demonstrates the alignment and processing of map entries using `mergeA` with custom tactics. Shows how missing and matched keys are handled to produce a merged map.

```haskell
mergeA (traverseMaybeMissing g1)
              (traverseMaybeMissing g2)
              (zipWithMaybeAMatched f)
              m1 m2
```

```haskell
m1 = [(0, 'a'), (1, 'b'), (3, 'c'), (4, 'd')]

```

```haskell
m2 = [(1, "one"), (2, "two"), (4, "three")]

```

```haskell
m1 = [(0, 'a'), (1, 'b'),               (3, 'c'), (4, 'd')]

```

```haskell
m2 =           [(1, "one"), (2, "two"),           (4, "three")]

```

```haskell
actions = [g1 0 'a', f 1 'b' "one", g2 2 "two", g1 3 'c', f 4 'd' "three"]

```

```haskell
keys =     0        1          2           3        4
results = [Nothing, Just True, Just False, Nothing, Just True]

```

```haskell
return value = [(1, True), (2, False), (4, True)]

```

--------------------------------

### Show1 IntMap

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Instance for showing IntMaps.

```APIDOC
## Show1 IntMap

### Description
Instance for showing IntMaps.

### Methods
- `liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> IntMap a -> ShowS`
- `liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [IntMap a] -> ShowS`
```

--------------------------------

### Get Edges of a Graph

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Graph.html

Returns the list of all edges in a graph. Applicable to graphs created with `buildG`.

```haskell
edges (buildG (0,-1) []) == []
```

```haskell
edges (buildG (0,2) [(0,1),(1,2)]) == [(0,1),(1,2)]
```

--------------------------------

### Show Instance

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Strict.html

The Show instance for Map requires Show instances for both key and value types.

```APIDOC
## Show (Map k a)

### Description
Provides functions for converting Map values to strings. Requires `Show k` and `Show a`.

### Methods
- `showsPrec :: Int -> Map k a -> ShowS`
- `show :: Map k a -> String`
- `showList :: [Map k a] -> ShowS`
```

--------------------------------

### Lift a => Lift (IntMap a)

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Instance for lifting IntMap.

```APIDOC
## Lift a => Lift (IntMap a)

### Description
Instance for lifting IntMap.

### Methods
- `lift :: Quote m => IntMap a -> m Exp`
- `liftTyped :: forall (m :: Type -> Type). Quote m => IntMap a -> Code m (IntMap a)`
```

--------------------------------

### Is Proper Subset Of Example

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Set-Internal.html

Checks if a set is a proper subset of another, meaning it is a subset but not equal to the other set.

```haskell
s1 `isProperSubsetOf` s2 = s1 `isSubsetOf` s2 && s1 /= s2
```

--------------------------------

### Strict foldlWithKey

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Internal.html

A strict version of foldlWithKey that evaluates each application of the operator before proceeding. Strict in the starting value.

```haskell
foldlWithKey' :: (a -> k -> b -> a) -> a -> Map k b -> a Source #
```

--------------------------------

### Example usage of mergeA

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Merge-Strict.html

Demonstrates how mergeA aligns and processes entries from two IntMaps based on provided tactics for missing and matched keys. The results are collected into a new IntMap.

```haskell
mergeA (traverseMaybeMissing g1)
              (traverseMaybeMissing g2)
              (zipWithMaybeAMatched f)
              m1 m2
```

```haskell
m1 = [(0, 'a'), (1, 'b'), (3,'c'), (4, 'd')]
m2 = [(1, "one"), (2, "two"), (4, "three")]
```

```haskell
m1 = [(0, 'a'), (1, 'b'),               (3, 'c'), (4, 'd')]
m2 =           [(1, "one"), (2, "two"),           (4, "three")]
```

```haskell
actions = [g1 0 'a', f 1 'b' "one", g2 2 "two", g1 3 'c', f 4 'd' "three"]
```

```haskell
keys =     0        1          2           3        4
results = [Nothing, Just True, Just False, Nothing, Just True]
```

```haskell
return value = [(1, True), (2, False), (4, True)]
```

--------------------------------

### Strict foldrWithKey

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Internal.html

A strict version of foldrWithKey that evaluates each application of the operator before proceeding. Strict in the starting value.

```haskell
foldrWithKey' :: (k -> a -> b -> b) -> b -> Map k a -> b Source #
```

--------------------------------

### Show1 Instance for Seq

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence-Internal.html

Provides showing capabilities for Seq.

```APIDOC
## Show1 Seq

### Description
Provides showing capabilities for `Seq`.

### Methods
- `liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Seq a -> ShowS`
- `liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Seq a] -> ShowS`

### Since
0.5.9
```

--------------------------------

### Strict foldl

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Internal.html

A strict version of foldl that evaluates each application of the operator before proceeding. Strict in the starting value.

```haskell
foldl' :: (a -> b -> a) -> a -> Map k b -> a Source #
```

--------------------------------

### Strict foldr

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Internal.html

A strict version of foldr that evaluates each application of the operator before proceeding. Strict in the starting value.

```haskell
foldr' :: (a -> b -> b) -> b -> Map k a -> b Source #
```

--------------------------------

### Right Scan with Initial Value

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence-Internal.html

Generates a sequence of cumulative results from the right, starting with an initial value.

```haskell
scanr :: (a -> b -> b) -> b -> Seq a -> Seq b
```

--------------------------------

### Importing Data.Map Qualified

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map.html

Demonstrates the recommended way to import the Data.Map module to avoid name clashes with Prelude functions.

```haskell
import Data.Map (Map)
import qualified Data.Map as Map
```

--------------------------------

### Left Scan with Initial Value

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence-Internal.html

Generates a sequence of cumulative results from the left, starting with an initial value.

```haskell
scanl :: (a -> b -> a) -> a -> Seq b -> Seq a
```

--------------------------------

### dff

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Graph.html

Computes a depth-first forest for the entire graph by performing DFS starting from each vertex in an unspecified order.

```APIDOC
## dff

### Description
A spanning forest of the graph, obtained from a depth-first search of the graph starting from each vertex in an unspecified order.

### Type Signature
`dff :: Graph -> [Tree Vertex]`

### Parameters
- `graph`: The input `Graph`.

### Returns
A list of `Tree Vertex]`, representing the depth-first forest of the entire graph.
```

--------------------------------

### Show1 Instance

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Strict-Internal.html

Provides methods for showing Maps with custom show functions for values. Available since version 0.5.9.

```APIDOC
## Show1 (Map k)

### Description
Allows for custom string representation of Maps with custom value showing.

### Methods
- `liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Map k a -> ShowS`
- `liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Map k a] -> ShowS`
```

--------------------------------

### Show Instance for Seq a

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence.html

Provides the Show instance for Seq a, enabling sequences to be converted to strings.

```APIDOC
## Show a => Show (Seq a)

### Description
Provides the Show instance for Seq a, enabling sequences to be converted to strings.

### Methods
- `showsPrec :: Int -> Seq a -> ShowS`
- `show :: Seq a -> String`
- `showList :: [Seq a] -> ShowS`
```

--------------------------------

### IntSet Instances

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntSet-Internal.html

Details the instances for IntSet, including GHC.Generics, Monoid, Semigroup, IsList, Read, Show, NFData, Eq, Ord, and Lift.

```APIDOC
## Instances

### GHC.Generics
Provides methods for generic programming: `gfoldl`, `gunfold`, `toConstr`, `dataTypeOf`, `dataCast1`, `dataCast2`, `gmapT`, `gmapQl`, `gmapQr`, `gmapQ`, `gmapQi`, `gmapM`, `gmapMp`, `gmapMo`.

### Monoid
- `mempty` is `empty`.
- `mappend` concatenates two IntSets.
- `mconcat` concatenates a list of IntSets.

### Semigroup
- `(<>)` is equivalent to `union` (since version 0.5.7).
- `sconcat` concatenates a non-empty list of IntSets.
- `stimes` repeats an IntSet a specified number of times.

### IsList
(Since version 0.5.6.2)
- `type Item IntSet = Key`
- `fromList` creates an IntSet from a list of items.
- `fromListN` creates an IntSet from a list of items with a specified size hint.
- `toList` converts an IntSet to a list of items.

### Read
Provides methods for reading IntSets: `readsPrec`, `readList`, `readPrec`, `readListPrec`.

### Show
Provides methods for showing IntSets: `showsPrec`, `show`, `showList`.

### NFData
- `rnf` evaluates an IntSet to normal form.

### Eq
- `(==)` checks for equality between two IntSets.
- `(/=)` checks for inequality between two IntSets.

### Ord
- `compare` compares two IntSets.
- Supports comparison operators: `<`, `<=`, `>`, `>=`.
- `max` returns the maximum of two IntSets.
- `min` returns the minimum of two IntSets.

### Lift
(Since version 0.6.6)
- `lift` lifts an IntSet into a `Quote` context.
- `liftTyped` lifts an IntSet into a typed `Code` context.
```

--------------------------------

### Example of foldr with length calculation

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Illustrates using foldr to calculate the total length of string values in an IntMap.

```haskell
let f a len = len + (length a)
foldr f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
```

--------------------------------

### Get Vertices of a Graph

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Graph.html

Retrieves all vertices present in a graph. Works for both empty and non-empty graphs built with `buildG`.

```haskell
vertices (buildG (0,-1) []) == []
```

```haskell
vertices (buildG (0,2) [(0,1),(1,2)]) == [0,1,2]
```

--------------------------------

### take

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence.html

Returns the first `i` elements of a sequence. Handles negative `i` and sequences shorter than `i`.

```APIDOC
## take

### Description
O(log(min(i,n−i))). The first `i` elements of a sequence. If `i` is negative, ``take` i s` yields the empty sequence. If the sequence contains fewer than `i` elements, the whole sequence is returned.

### Parameters
#### Path Parameters
- **i** (Int) - The number of elements to take.
- **s** (Seq a) - The sequence to take elements from.

### Response
#### Success Response (Seq a)
- **Seq a** - A new sequence containing the first `i` elements.
```

--------------------------------

### Right Scan without Initial Value

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence-Internal.html

Similar to scanr, but uses the last element of the sequence as the starting value.

```haskell
scanr1 :: (a -> a -> a) -> Seq a -> Seq a
```

--------------------------------

### Show Instance for Tree a

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Graph.html

Enables showing Tree a values as strings.

```APIDOC
## Show (Tree a)

### Description
Allows Tree a values to be converted to strings.

### Methods
- **showsPrec** :: Int -> Tree a -> ShowS
- **show** :: Tree a -> String
- **showList** :: [Tree a] -> ShowS
```

--------------------------------

### Importing Data.IntMap.Strict Qualified

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict.html

Demonstrates the recommended way to import the module to prevent name collisions with Prelude functions.

```Haskell
import Data.IntMap.Strict (IntMap)
import qualified Data.IntMap.Strict as IntMap
```

--------------------------------

### Example Usage of nubIntOn for Characters (Haskell)

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Containers-ListUtils.html

Demonstrates using nubIntOn with fromEnum to efficiently remove duplicate characters from a list.

```haskell
nubIntOn fromEnum xs
```

--------------------------------

### Get the set of all elements wrapped in Arg

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Lazy.html

Returns the set of all map elements contained within `Arg` data constructors.

```haskell
argSet (fromList [(5,"a"), (3,"b")]) == Data.Set.fromList [Arg 3 "b",Arg 5 "a"]
argSet empty == Data.Set.empty
```

--------------------------------

### take

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Strict.html

Takes a specified number of entries from the beginning of the map (smallest keys).

```APIDOC
## take :: Int -> Map k a -> Map k a

### Description
Takes a given number of entries in key order, beginning with the smallest keys.

### Parameters
#### Path Parameters
- **Int** - The number of entries to take.
- **Map k a** - The map to take entries from.

### Response
#### Success Response (Map k a)
- **Map k a** - A new map containing the first `n` entries.

### Example
```
take n = fromDistinctAscList . take n . toAscList
```
```

--------------------------------

### Show Instance

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Lazy.html

Provides functionality to convert a Map to its string representation.

```APIDOC
## Show (Map k a)

### Description
Provides functionality to convert a Map to its string representation.

### Constraints
- `Show k`
- `Show a`

### Methods
- `showsPrec :: Int -> Map k a -> ShowS`
- `show :: Map k a -> String`
- `showList :: [Map k a] -> ShowS`
```

--------------------------------

### Get Map Size using `size`

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Returns the total number of key-value pairs in the map. Note the O(n) complexity.

```Haskell
size empty                                   == 0
size (singleton 1 'a')                       == 1
size (fromList([(1,'a'), (2,'c'), (3,'b')])) == 3
```

--------------------------------

### Strict foldlWithKey'

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Lazy.html

A strict version of foldlWithKey. Each application of the operator is evaluated before being used in the next step. Strict in the starting value.

```haskell
foldlWithKey' :: (a -> Key -> b -> a) -> a -> IntMap b -> a
```

--------------------------------

### fromAscListWith

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Lazy.html

Builds an IntMap from an ascending list of key-value pairs with a combining function for equal keys. Complexity is O(n).

```APIDOC
## fromAscListWith

### Description
O(n) operation to build a map from a list of key/value pairs where the keys are in ascending order, with a combining function on equal keys.

### Signature
fromAscListWith :: (a -> a -> a) -> [(Key, a)] -> IntMap a

### Warning
This function assumes the keys are in non-decreasing order. The precondition is not checked. Use `fromListWith` if the precondition may not hold.

### Examples
```
fromAscListWith (++) [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "ba")]
```

### Performance Note
See the performance note on `fromListWith`.
```

--------------------------------

### Strict foldrWithKey'

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Lazy.html

A strict version of foldrWithKey. Each application of the operator is evaluated before being used in the next step. Strict in the starting value.

```haskell
foldrWithKey' :: (Key -> a -> b -> b) -> b -> IntMap a -> b
```

--------------------------------

### Show2 Instance

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Strict-Internal.html

Provides methods for showing two Maps with custom show functions for their elements. Available since version 0.5.9.

```APIDOC
## Show2 Map

### Description
Allows for custom string representation of two Maps.

### Methods
- `liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Map a b -> ShowS`
- `liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Map a b] -> ShowS`
```

--------------------------------

### Strict foldl'

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Lazy.html

A strict version of foldl. Each application of the operator is evaluated before being used in the next step. Strict in the starting value.

```haskell
foldl' :: (a -> b -> a) -> a -> IntMap b -> a
```

--------------------------------

### Strict foldr'

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Lazy.html

A strict version of foldr. Each application of the operator is evaluated before being used in the next step. Strict in the starting value.

```haskell
foldr' :: (a -> b -> b) -> b -> IntMap a -> b
```

--------------------------------

### adjust'

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Sequence.html

Updates the element at the specified position, forcing the new value before installation. Returns the original sequence if the position is out of range.

```APIDOC
## adjust'

### Description
O(log(min(i,n−i))). Update the element at the specified position. If the position is out of range, the original sequence is returned. The new value is forced before it is installed in the sequence.

### Parameters
#### Path Parameters
- **f** (a -> a) - The function to apply to the element.
- **i** (Int) - The index of the element to update.
- **xs** (Seq a) - The sequence to update.

### Response
#### Success Response (Seq a)
- **Seq a** - The sequence with the element at the specified index updated.
```

--------------------------------

### Show1 Instance for Map k

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-Map-Internal.html

Details the Show1 instance for Map k, providing methods for showing Maps with the same key type but different value types.

```APIDOC
## Show k => Show1 (Map k)

### Description
Provides methods for showing Maps with the same key type but potentially different value types.

### Methods
- `liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Map k a -> ShowS`
- `liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Map k a] -> ShowS`
```

--------------------------------

### Data a => Data (IntMap a)

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Strict-Internal.html

Data instance for IntMap.

```APIDOC
## Data a => Data (IntMap a)

### Description
Data instance for IntMap.

### Methods
- `gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntMap a -> c (IntMap a)`
- `gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IntMap a)`
- `toConstr :: IntMap a -> Constr`
- `dataTypeOf :: IntMap a -> DataType`
- `dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IntMap a))`
- `dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IntMap a))`
- `gmapT :: (forall b. Data b => b -> b) -> IntMap a -> IntMap a`
- `gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r`
- `gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r`
- `gmapQ :: (forall d. Data d => d -> u) -> IntMap a -> [u]`
- `gmapQi :: Int -> (forall d. Data d => d -> u) -> IntMap a -> u`
- `gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a)`
- `gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a)`
- `gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a)`
```

--------------------------------

### fromAscList

Source: https://hackage.haskell.org/package/containers-0.8/docs/Data-IntMap-Lazy.html

Creates an IntMap from a list of key-value pairs sorted in ascending order. Complexity is O(n).

```APIDOC
## fromAscList

### Description
O(n) operation to build a map from a list of key/value pairs where the keys are in ascending order.

### Signature
fromAscList :: [(Key, a)] -> IntMap a

### Warning
This function assumes the keys are in non-decreasing order. The precondition is not checked. Use `fromList` if the precondition may not hold.

### Examples
```
fromAscList [(3,"b"), (5,"a")]          == fromList [(3, "b"), (5, "a")]
fromAscList [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "b")]
```
```
Tokens:
Raw