| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Data.Discrimination
- class Decidable f => Discriminating f where
- newtype Group a = Group {}
- class Grouping a where
- class Grouping1 f where
- nub :: Grouping a => [a] -> [a]
- nubWith :: Grouping b => (a -> b) -> [a] -> [a]
- group :: Grouping a => [a] -> [[a]]
- groupWith :: Grouping b => (a -> b) -> [a] -> [[a]]
- runGroup :: Group a -> [(a, b)] -> [[b]]
- groupingEq :: Grouping a => a -> a -> Bool
- newtype Sort a = Sort {
- runSort :: forall b. [(a, b)] -> [[b]]
- class Grouping a => Sorting a where
- class Grouping1 f => Sorting1 f where
- desc :: Sort a -> Sort a
- sort :: Sorting a => [a] -> [a]
- sortWith :: Sorting b => (a -> b) -> [a] -> [a]
- sortingBag :: Foldable f => Sort k -> Sort (f k)
- sortingSet :: Foldable f => Sort k -> Sort (f k)
- sortingCompare :: Sorting a => a -> a -> Ordering
- toMap :: Sorting k => [(k, v)] -> Map k v
- toMapWith :: Sorting k => (v -> v -> v) -> [(k, v)] -> Map k v
- toMapWithKey :: Sorting k => (k -> v -> v -> v) -> [(k, v)] -> Map k v
- toIntMap :: [(Int, v)] -> IntMap v
- toIntMapWith :: (v -> v -> v) -> [(Int, v)] -> IntMap v
- toIntMapWithKey :: (Int -> v -> v -> v) -> [(Int, v)] -> IntMap v
- toSet :: Sorting k => [k] -> Set k
- toIntSet :: [Int] -> IntSet
- joining :: Discriminating f => f d -> ([a] -> [b] -> c) -> (a -> d) -> (b -> d) -> [a] -> [b] -> [c]
- inner :: Discriminating f => f d -> (a -> b -> c) -> (a -> d) -> (b -> d) -> [a] -> [b] -> [[c]]
- outer :: Discriminating f => f d -> (a -> b -> c) -> (a -> c) -> (b -> c) -> (a -> d) -> (b -> d) -> [a] -> [b] -> [[c]]
- leftOuter :: Discriminating f => f d -> (a -> b -> c) -> (a -> c) -> (a -> d) -> (b -> d) -> [a] -> [b] -> [[c]]
- rightOuter :: Discriminating f => f d -> (a -> b -> c) -> (b -> c) -> (a -> d) -> (b -> d) -> [a] -> [b] -> [[c]]
Discrimination
Unordered
Productive Stable Unordered Discriminator
Constructors
| Group | |
class Grouping a where Source #
Eq equipped with a compatible stable unordered discriminator.
Methods
Instances
| Grouping Bool Source # | |
| Grouping Char Source # | |
| Grouping Int Source # | |
| Grouping Int8 Source # | |
| Grouping Int16 Source # | |
| Grouping Int32 Source # | |
| Grouping Int64 Source # | |
| Grouping Word Source # | |
| Grouping Word8 Source # | |
| Grouping Word16 Source # | |
| Grouping Word32 Source # | |
| Grouping Word64 Source # | |
| Grouping Void Source # | |
| Grouping a => Grouping [a] Source # | |
| Grouping a => Grouping (Maybe a) Source # | |
| Grouping a => Grouping (Ratio a) Source # | |
| Grouping a => Grouping (Complex a) Source # | |
| (Grouping a, Grouping b) => Grouping (Either a b) Source # | |
| (Grouping a, Grouping b) => Grouping (a, b) Source # | |
| (Grouping a, Grouping b, Grouping c) => Grouping (a, b, c) Source # | |
| (Grouping a, Grouping b, Grouping c, Grouping d) => Grouping (a, b, c, d) Source # | |
| (Grouping1 f, Grouping1 g, Grouping a) => Grouping (Compose * * f g a) Source # | |
class Grouping1 f where Source #
Methods
grouping1 :: Group a -> Group (f a) Source #
grouping1 :: Deciding1 Grouping f => Group a -> Group (f a) Source #
Instances
| Grouping1 [] Source # | |
| Grouping1 Maybe Source # | |
| Grouping1 Complex Source # | |
| Grouping a => Grouping1 (Either a) Source # | |
| Grouping a => Grouping1 ((,) a) Source # | |
| (Grouping a, Grouping b) => Grouping1 ((,,) a b) Source # | |
| (Grouping a, Grouping b, Grouping c) => Grouping1 ((,,,) a b c) Source # | |
| (Grouping1 f, Grouping1 g) => Grouping1 (Compose * * f g) Source # | |
groupWith :: Grouping b => (a -> b) -> [a] -> [[a]] Source #
O(n). This is a replacement for groupWith using discrimination.
The result equivalence classes are not sorted, but the grouping is stable.
Ordered
Stable Ordered Discriminator
class Grouping a => Sorting a where Source #
Ord equipped with a compatible stable, ordered discriminator.
Methods
Instances
| Sorting Bool Source # | |
| Sorting Char Source # | |
| Sorting Int Source # | |
| Sorting Int8 Source # | |
| Sorting Int16 Source # | |
| Sorting Int32 Source # | |
| Sorting Int64 Source # | |
| Sorting Word Source # | |
| Sorting Word8 Source # | |
| Sorting Word16 Source # | |
| Sorting Word32 Source # | |
| Sorting Word64 Source # | |
| Sorting Void Source # | |
| Sorting a => Sorting [a] Source # | |
| Sorting a => Sorting (Maybe a) Source # | |
| (Sorting a, Sorting b) => Sorting (Either a b) Source # | |
| (Sorting a, Sorting b) => Sorting (a, b) Source # | |
| (Sorting a, Sorting b, Sorting c) => Sorting (a, b, c) Source # | |
| (Sorting a, Sorting b, Sorting c, Sorting d) => Sorting (a, b, c, d) Source # | |
| (Sorting1 f, Sorting1 g, Sorting a) => Sorting (Compose * * f g a) Source # | |
sortingBag :: Foldable f => Sort k -> Sort (f k) Source #
Construct a stable ordered discriminator that sorts a list as multisets of elements from another stable ordered discriminator.
The resulting discriminator only cares about the set of keys and their multiplicity, and is sorted as if we'd sorted each key in turn before comparing.
sortingSet :: Foldable f => Sort k -> Sort (f k) Source #
Construct a stable ordered discriminator that sorts a list as sets of elements from another stable ordered discriminator.
The resulting discriminator only cares about the set of keys, and is sorted as if we'd sorted each key in turn before comparing.
sortingCompare :: Sorting a => a -> a -> Ordering Source #
Container Construction
toMapWith :: Sorting k => (v -> v -> v) -> [(k, v)] -> Map k v Source #
O(n). Construct a Map, combining values.
This is an asymptotically faster version of fromListWith, which exploits ordered discrimination.
(Note: values combine in anti-stable order for compatibility with fromListWith)
>>>toMapWith (++) [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5 :: Int,"c")]fromList [(3, "ab"), (5, "cba")]
>>>toMapWith (++) [] == emptyTrue
toMapWithKey :: Sorting k => (k -> v -> v -> v) -> [(k, v)] -> Map k v Source #
O(n). Construct a Map, combining values with access to the key.
This is an asymptotically faster version of fromListWithKey, which exploits ordered discrimination.
(Note: the values combine in anti-stable order for compatibility with fromListWithKey)
>>>let f key new_value old_value = show key ++ ":" ++ new_value ++ "|" ++ old_value>>>toMapWithKey f [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5 :: Int,"c")]fromList [(3, "3:a|b"), (5, "5:c|5:b|a")]
>>>toMapWithKey f [] == emptyTrue
toIntMap :: [(Int, v)] -> IntMap v Source #
O(n). Construct an IntMap.
>>>toIntMap [] == emptyTrue
>>>toIntMap [(5,"a"), (3,"b"), (5, "c")]fromList [(5,"c"), (3,"b")]
>>>toIntMap [(5,"c"), (3,"b"), (5, "a")]fromList [(5,"a"), (3,"b")]
toIntMapWith :: (v -> v -> v) -> [(Int, v)] -> IntMap v Source #
O(n). Construct an IntMap, combining values.
This is an asymptotically faster version of fromListWith, which exploits ordered discrimination.
(Note: values combine in anti-stable order for compatibility with fromListWith)
>>>toIntMapWith (++) [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5,"c")]fromList [(3, "ab"), (5, "cba")]
>>>toIntMapWith (++) [] == emptyTrue
toIntMapWithKey :: (Int -> v -> v -> v) -> [(Int, v)] -> IntMap v Source #
O(n). Construct a Map, combining values with access to the key.
This is an asymptotically faster version of fromListWithKey, which exploits ordered discrimination.
(Note: the values combine in anti-stable order for compatibility with fromListWithKey)
>>>let f key new_value old_value = show key ++ ":" ++ new_value ++ "|" ++ old_value>>>toIntMapWithKey f [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5,"c")]fromList [(3, "3:a|b"), (5, "5:c|5:b|a")]
>>>toIntMapWithKey f [] == emptyTrue
Joins
Arguments
| :: Discriminating f | |
| => f d | the discriminator to use |
| -> ([a] -> [b] -> c) | how to join two tables |
| -> (a -> d) | selector for the left table |
| -> (b -> d) | selector for the right table |
| -> [a] | left table |
| -> [b] | right table |
| -> [c] |
O(n). Perform a full outer join while explicit merging of the two result tables a table at a time.
The results are grouped by the discriminator.
Arguments
| :: Discriminating f | |
| => f d | the discriminator to use |
| -> (a -> b -> c) | how to join two rows |
| -> (a -> d) | selector for the left table |
| -> (b -> d) | selector for the right table |
| -> [a] | left table |
| -> [b] | right table |
| -> [[c]] |
O(n). Perform an inner join, with operations defined one row at a time.
The results are grouped by the discriminator.
This takes operation time linear in both the input and result sets.
Arguments
| :: Discriminating f | |
| => f d | the discriminator to use |
| -> (a -> b -> c) | how to join two rows |
| -> (a -> c) | row present on the left, missing on the right |
| -> (b -> c) | row present on the right, missing on the left |
| -> (a -> d) | selector for the left table |
| -> (b -> d) | selector for the right table |
| -> [a] | left table |
| -> [b] | right table |
| -> [[c]] |
O(n). Perform a full outer join with operations defined one row at a time.
The results are grouped by the discriminator.
This takes operation time linear in both the input and result sets.
Arguments
| :: Discriminating f | |
| => f d | the discriminator to use |
| -> (a -> b -> c) | how to join two rows |
| -> (a -> c) | row present on the left, missing on the right |
| -> (a -> d) | selector for the left table |
| -> (b -> d) | selector for the right table |
| -> [a] | left table |
| -> [b] | right table |
| -> [[c]] |
O(n). Perform a left outer join with operations defined one row at a time.
The results are grouped by the discriminator.
This takes operation time linear in both the input and result sets.
Arguments
| :: Discriminating f | |
| => f d | the discriminator to use |
| -> (a -> b -> c) | how to join two rows |
| -> (b -> c) | row present on the right, missing on the left |
| -> (a -> d) | selector for the left table |
| -> (b -> d) | selector for the right table |
| -> [a] | left table |
| -> [b] | right table |
| -> [[c]] |
O(n). Perform a right outer join with operations defined one row at a time.
The results are grouped by the discriminator.
This takes operation time linear in both the input and result sets.