Hoogle Search

Within LTS Haskell 24.32 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. getSorted :: SortedList a -> [a]

   massiv-test	Test.Massiv.Utils

   No documentation available.

2. getBFstLSorted' :: Ord a => b -> [(a, b)] -> a -> b

   mmsyn2-array	CaseBi.Arr

   If the list argument is sorted in the ascending order by the first element in every tuple, then to reduce computations instead of \def xs x -> getBFst' (def, listArray (0,length xs - 1) xs) x you can use this function.

3. listArrSortedByFst :: Ord a => [(a, b)] -> Array Int (a, b)

   mmsyn2-array	CaseBi.Arr

   Sorts the list of pairs by the first element in the tuples, then transforms them into an immutable array. Can be used only if the list contains no more than 2^31 - 1 elements though this is not checked, it is up to user to check this constraint before or provide its correctness by design.

4. NoCursorTimeout :: QueryOption

   mongoDB	Database.MongoDB.Query

   The server normally times out idle cursors after 10 minutes to prevent a memory leak in case a client forgets to close a cursor. Set this option to allow a cursor to live forever until it is closed.

5. rSort :: MapReduce -> Order

   mongoDB	Database.MongoDB.Query

   Default is [] meaning no sort

6. unstableSort :: Ord a => NESeq a -> NESeq a

   nonempty-containers	Data.Sequence.NonEmpty

   unstableSort sorts the specified NESeq by the natural ordering of its elements, but the sort is not stable. This algorithm is frequently faster and uses less memory than sort.

7. unstableSortBy :: (a -> a -> Ordering) -> NESeq a -> NESeq a

   nonempty-containers	Data.Sequence.NonEmpty

   A generalization of unstableSort, unstableSortBy takes an arbitrary comparator and sorts the specified sequence. The sort is not stable. This algorithm is frequently faster and uses less memory than sortBy.

8. unstableSortOn :: Ord b => (a -> b) -> NESeq a -> NESeq a

   nonempty-containers	Data.Sequence.NonEmpty

   unstableSortOn sorts the specified NESeq by comparing the results of a key function applied to each element. unstableSortOn f is equivalent to unstableSortBy (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 unstableSortOn might be to sort a NESeq of strings according to their length.

   unstableSortOn length (fromList ("alligator" :| ["monkey", "zebra"])) == fromList ("zebra" :| ["monkey", "alligator]")
   

   If, instead, unstableSortBy 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), unstableSortBy (compare `on` f) will be faster than unstableSortOn f.

9. patchThatChangesAndSortsMapWith :: (Ord k, Ord v) => (v -> v -> Ordering) -> Map k v -> Map k v -> PatchMapWithMove k v

   patch	Data.Patch.MapWithMove

   Create a PatchMapWithMove that, if applied to the first Map provided, will produce a Map with the same values as the second Map but with the values sorted with the given ordering function.

10. patchThatSortsMapWith :: Ord k => (v -> v -> Ordering) -> Map k v -> PatchMapWithMove k v

    patch	Data.Patch.MapWithMove

    Create a PatchMapWithMove that, if applied to the given Map, will sort its values using the given ordering function. The set keys of the Map is not changed.

Page 125 of many | Previous | Next