A convenient infix flipped version of fromMaybe: Just a ? b = a, and Nothing ? b = b. It can also be chained, as in x ? y ? z ? def, which takes the value inside the first Just, defaulting to def as a last resort.

Ensure the smaller value in a pair is the first element.

Find the maximum of two values, comparing them according to a custom projection function.

Find the maximum of a list of numbers, defaulting to 0 if the list is empty.

Take the successor of an Enum type, wrapping around when it reaches the end.

Members of the Bounded class are guaranteed to have at least one element.

We know by the syntax rules of Haskell that constructor names must consist of one or more symbols!

Guaranteed to yield an element of the list.

This is true even if the supplied index is negative, since mod always satisfies 0 <= a mod b < b when b is positive (see https://github.com/swarm-game/swarm/pull/1181#discussion_r1151177735).

Drop repeated elements that are adjacent to each other.

>>> uniq []
[]
>>> uniq [1..5]
[1,2,3,4,5]
>>> uniq (replicate 10 'a')
"a"
>>> uniq "abbbccd"
"abcd"

Place the second element of the tuples into bins by the value of the first element.

Count occurrences of a value

Find a duplicate element within the list, if any exists.

Convert a Maybe computation to MaybeT.

TODO (#1151): Use implementation from "transformers" package v0.6.0.0

Like unsnoc, but for NonEmpty so without the Maybe

Taken from Cabal-syntax Distribution.Utils.Generic.

Example: >>> import Data.List.NonEmpty (NonEmpty ((:|))) >>> unsnocNE (1 :| [2, 3]) ([1,2],3)

>>> unsnocNE (1 :| [])
([],1)

Safely attempt to read a file.

Safely attempt to (efficiently) read a file.

Recursively acquire all files in the given directory with the given extension, and their contents.

Predicate to test for characters which can be part of a valid identifier: alphanumeric, underscore, or single quote.

>>> isIdentChar 'A' && isIdentChar 'b' && isIdentChar '9'
True
>>> isIdentChar '_' && isIdentChar '\''
True
>>> isIdentChar '$' || isIdentChar '.' || isIdentChar ' '
False

replaceLast r t replaces the last word of t with r.

>>> :set -XOverloadedStrings
>>> replaceLast "foo" "bar baz quux"
"bar baz foo"
>>> replaceLast "move" "(make"
"(move"

Fail with a Text-based message, made out of phrases to be joined by spaces.

Show a value, but as Text.

Show a value in all lowercase, but as Text.

Reflow text by removing newlines and condensing whitespace.

Surround some text in double quotes.

Surround some text in single quotes.

Surround some text in backticks.

Surround some text in parentheses.

Surround some text in square brackets.

Make a list of things with commas and the word "and".

Prepend a noun with the proper indefinite article ("a" or "an").

Prepend a noun with the proper indefinite article, and surround the noun in single quotes.

Combine the subject word with the simple present tense of the verb.

Only some irregular verbs are handled, but it should be enough to scrap some error message boilerplate and have fun!

>>> :set -XOverloadedStrings
>>> singularSubjectVerb "I" "be"
"I am"
>>> singularSubjectVerb "he" "can"
"he can"
>>> singularSubjectVerb "The target robot" "do"
"The target robot does"

Pluralize a noun.

Either pluralize a noun or not, depending on the value of the number.

Require that a Boolean value is True, or throw an exception.

Require that a Maybe value is Just, or throw an exception.

Require that an Either value is Right, or throw an exception based on the value in the Left.

Require that a Validation value is Success, or throw an exception based on the value in the Failure.

Remove any sets which are supersets of other sets. In other words, (1) no two sets in the output are in a subset relationship (2) every element in the input is a superset of some element in the output.

>>> import qualified Data.Set as S
>>> rss = map S.toList . S.toList . removeSupersets . S.fromList . map S.fromList

>>> rss [[1,2,3], [1]]
[[1]]

>>> rss [[1,2,3], [2,4], [2,3]]
[[2,3],[2,4]]

>>> rss [[], [1], [2,3]]
[[]]

>>> rss [[1,2], [1,3], [2,3]]
[[1,2],[1,3],[2,3]]

Given a list of nonempty sets, find a hitting set, that is, a set which has at least one element in common with each set in the list. It is not guaranteed to be the smallest possible such set, because that is NP-hard. Instead, we use a greedy algorithm that will give us a reasonably small hitting set: first, choose all elements in singleton sets, since those must necessarily be chosen. Now take any sets which are still not hit, and find an element which occurs in the largest possible number of remaining sets. Add this element to the set of chosen elements, and filter out all the sets it hits. Repeat, choosing a new element to hit the largest number of unhit sets at each step, until all sets are hit. This algorithm produces a hitting set which might be larger than optimal by a factor of lg(m), where m is the number of sets in the input.

>>> import qualified Data.Set as S
>>> shs = smallHittingSet . map S.fromList

>>> shs ["a"]
fromList "a"

>>> shs ["ab", "b"]
fromList "b"

>>> shs ["ab", "bc"]
fromList "b"

>>> shs ["acd", "c", "aef", "a"]
fromList "ac"

>>> shs ["abc", "abd", "acd", "bcd"]
fromList "cd"

Here is an example of an input for which smallHittingSet does not produce a minimal hitting set. "bc" is also a hitting set and is smaller. b, c, and d all occur in exactly two sets, but d is unluckily chosen first, leaving "be" and "ac" unhit and necessitating choosing one more element from each.

>>> shs ["bd", "be", "ac", "cd"]
fromList "cde"