Hoogle Search
Within LTS Haskell 24.34 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty abase Data.List.NonEmpty sortWith for NonEmpty, behaves the same as:
sortBy . comparing
sortWith :: Ord b => (a -> b) -> [a] -> [a]base GHC.Exts The sortWith function sorts a list of elements using the user supplied function to project something out of each element In general if the user supplied function is expensive to compute then you should probably be using sortOn, as it only needs to compute it once for each element. sortWith, on the other hand must compute the mapping function for every comparison that it performs.
sortBy :: (a -> a -> Ordering) -> Seq a -> Seq acontainers Data.Sequence sortBy sorts the specified Seq according to the specified comparator. The sort is stable. If stability is not required, unstableSortBy can be slightly faster.
sortOn :: Ord b => (a -> b) -> Seq a -> Seq acontainers Data.Sequence sortOn sorts the specified Seq by comparing the results of a key function applied to each element. sortOn f is equivalent to sortBy (compare `on` f), but has the performance advantage of only evaluating f once for each element in the input list. This is called the decorate-sort-undecorate paradigm, or Schwartzian transform. An example of using sortOn might be to sort a Seq of strings according to their length:
sortOn length (fromList ["alligator", "monkey", "zebra"]) == fromList ["zebra", "monkey", "alligator"]
If, instead, sortBy had been used, length would be evaluated on every comparison, giving <math> evaluations, rather than <math>. If f is very cheap (for example a record selector, or fst), sortBy (compare `on` f) will be faster than sortOn f.sortBy :: (a -> a -> Ordering) -> Seq a -> Seq acontainers Data.Sequence.Internal.Sorting sortBy sorts the specified Seq according to the specified comparator. The sort is stable. If stability is not required, unstableSortBy can be slightly faster.
sortOn :: Ord b => (a -> b) -> Seq a -> Seq acontainers Data.Sequence.Internal.Sorting sortOn sorts the specified Seq by comparing the results of a key function applied to each element. sortOn f is equivalent to sortBy (compare `on` f), but has the performance advantage of only evaluating f once for each element in the input list. This is called the decorate-sort-undecorate paradigm, or Schwartzian transform. An example of using sortOn might be to sort a Seq of strings according to their length:
sortOn length (fromList ["alligator", "monkey", "zebra"]) == fromList ["zebra", "monkey", "alligator"]
If, instead, sortBy had been used, length would be evaluated on every comparison, giving <math> evaluations, rather than <math>. If f is very cheap (for example a record selector, or fst), sortBy (compare `on` f) will be faster than sortOn f.sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty aextra Data.List.NonEmpty.Extra Sort a NonEmpty on a user-supplied projection of its elements. See sortOn for more detailed information.
Examples
>>> sortOn fst $ (2, "world") :| [(4, "!"), (1, "Hello")] (1,"Hello") :| [(2,"world"),(4,"!")]
>>> sortOn length $ "jim" :| ["creed", "pam", "michael", "dwight", "kevin"] "jim" :| ["pam","creed","kevin","dwight","michael"]
Performance notes
This function minimises the projections performed, by materialising the projections in an intermediate list. For trivial projections, you should prefer using sortBy with comparing, for example:>>> sortBy (comparing fst) $ (3, 1) :| [(2, 2), (1, 3)] (1,3) :| [(2,2),(3,1)]
Or, for the exact same API as sortOn, you can use `sortBy . comparing`:>>> (sortBy . comparing) fst $ (3, 1) :| [(2, 2), (1, 3)] (1,3) :| [(2,2),(3,1)]
sortWith is an alias for `sortBy . comparing`.sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty abase-compat Data.List.NonEmpty.Compat sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty abase-compat Data.List.NonEmpty.Compat Sort a NonEmpty on a user-supplied projection of its elements. See sortOn for more detailed information.
Examples
>>> sortOn fst $ (2, "world") :| [(4, "!"), (1, "Hello")] (1,"Hello") :| [(2,"world"),(4,"!")]
>>> sortOn length $ "jim" :| ["creed", "pam", "michael", "dwight", "kevin"] "jim" :| ["pam","creed","kevin","dwight","michael"]
Performance notes
This function minimises the projections performed, by materialising the projections in an intermediate list. For trivial projections, you should prefer using sortBy with comparing, for example:>>> sortBy (comparing fst) $ (3, 1) :| [(2, 2), (1, 3)] (1,3) :| [(2,2),(3,1)]
Or, for the exact same API as sortOn, you can use `sortBy . comparing`:>>> (sortBy . comparing) fst $ (3, 1) :| [(2, 2), (1, 3)] (1,3) :| [(2,2),(3,1)]
sortWith is an alias for `sortBy . comparing`.sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty abase-compat Data.List.NonEmpty.Compat sortWith for NonEmpty, behaves the same as:
sortBy . comparing