Given an input list, computes all lists in which just one element is missing.

>>> mapM_ print $ leaveOutOne [1..5]
(1,[2,3,4,5])
(2,[1,3,4,5])
(3,[1,2,4,5])
(4,[1,2,3,5])
(5,[1,2,3,4])
>>> leaveOutOne []
[]
>>> leaveOutOne [1]
[(1,[])]

Safe variant of Prelude.minimum.

>>> minimum1 [] :: Maybe ()
Nothing
>>> minimum1 [1,2,3]
Just 1

Safe variant of Prelude.maximum.

>>> maximum1 [] :: Maybe ()
Nothing
>>> maximum1 [1,2,3]
Just 3

Total variant of Data.List.minimumBy.

>>> minimum1By (comparing abs) [] :: Maybe Int
Nothing
>>> minimum1By (comparing abs) [1,-2,3]
Just 1

Computes all minima by comparing some property.

>>> minimaOn (max 2) [1,2,3,4,5,-1]
[-1,2,1]

Computes all minima.

>>> minimaBy (comparing abs) [1,2,3,2,1,-1]
[-1,1,1]

extracts all minima from the list. The result consists of the list of minima, and all remaining points. Both lists are returned in the order in which they occur in the input.

>>> extractMinimaBy compare [1,2,3,0,1,2,3,0,1,2,0,2]
[0,0,0] :+ [2,3,1,2,3,1,2,1,2]

Given a function f, partitions the list into three lists (lts,eqs,gts) such that:

• f x == LT for all x in lts
• f x == EQ for all x in eqs
• f x == gt for all x in gts

>>> partition3 (compare 4) [0,1,2,2,3,4,5,5,6,6,7,7,7,7,7,8]
([5,5,6,6,7,7,7,7,7,8],[4],[0,1,2,2,3])

A version of groupBy that uses the given Ordering to group consecutive Equal items

>>> groupBy' compare [0,1,2,2,3,4,5,5,6,6,7,7,7,7,7,8]
[0 :| [],1 :| [],2 :| [2],3 :| [],4 :| [],5 :| [5],6 :| [6],7 :| [7,7,7,7],8 :| []]