Agda.Utils.List1

Checks if all the elements in the list are equal. Assumes that the Eq instance stands for an equivalence relation. O(n).

Breaks a list just after an element satisfying the predicate is found.

>>> breakAfter even [1,3,5,2,4,7,8](1 :| [3,5,2],[4,7,8])

Like catMaybes.

Concatenate one or more non-empty lists.

Like find.

List Data.List.foldr but with a base case for the singleton list.

Safe version of fromList.

More precise type for Agda.Utils.List.groupBy'.

A variant of groupBy which applies the predicate to consecutive pairs. O(n).

Group consecutive items that share the same first component.

Group consecutive items that share the same first component.

groupOn f = groupBy ((==) `on` f) . sortBy (compare `on` f). O(n log n).

Return the last element and the rest.

Last two elements (safe). O(n).

Like lefts.

Focus on the first element of a non-empty list. O(1).

Focus on the last element of a non-empty list. O(n).

Lift a function on non-empty lists to a function on lists.

This is in essence fmap for Maybe, if we take [a] = Maybe (List1 a).

Like mapMaybe.

Non-efficient, monadic nub. O(n²).

Like partitionEithers.

Like rights.

Build a list with one element.

More precise type for snoc.

Lossless toList, opposite of nonEmpty.

Like union. Duplicates in the first list are not removed. O(nm).

The more general type Null m => [a] -> (List1 a -> m) -> m often causes type inference to fail, as we do not in general have instance Applicative m => Null (m ()).

Like Data.List.unwords.

Like unzipWith.

Update the first element of a non-empty list. O(1).

Update the last element of a non-empty list. O(n).

Split a list into sublists. Generalisation of the prelude function words. Same as Data.List.Split.wordsBy and Data.List.Extra.wordsBy, but with the non-emptyness guarantee on the chunks. O(n).

words xs == wordsBy isSpace xs

Like zipWithM.

Like zipWithM.

xs !! n returns the element of the stream xs at index n. Note that the head of the stream has index 0.

Beware: a negative or out-of-bounds index will cause an error.

Prepend an element to the stream.

A monomorphic version of <> for NonEmpty.

>>> append (1 :| []) (2 :| [3])1 :| [2,3]

Attach a list at the end of a NonEmpty.

>>> appendList (1 :| [2,3]) []1 :| [2,3]

>>> appendList (1 :| [2,3]) [4,5]1 :| [2,3,4,5]

The break p function is equivalent to span (not . p).

Use compareLength xs n as a safer and faster alternative to compare (length xs) n. Similarly, it's better to write compareLength xs 10 == LT instead of length xs < 10.

While length would force and traverse the entire spine of xs (which could even diverge if xs is infinite), compareLength traverses at most n elements to determine its result.

>>> compareLength ('a' :| []) 1EQ>>> compareLength ('a' :| ['b']) 3LT>>> compareLength (0 :| [1..]) 100GT>>> compareLength undefined 0GT>>> compareLength ('a' :| 'b' : undefined) 1GT

Synonym for <|.

cycle xs returns the infinite repetition of xs:

cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]

drop n xs drops the first n elements off the front of the sequence xs.

dropWhile p xs returns the suffix remaining after takeWhile p xs.

filter p xs removes any elements from xs that do not satisfy p.

The group function takes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements, and consecutive equal elements of the input end up in the same stream of the output list. For example, in list notation:

>>> group "Mississippi"['M' :| "",'i' :| "",'s' :| "s",'i' :| "",'s' :| "s",'i' :| "",'p' :| "p",'i' :| ""]

group1 operates like group, but uses the knowledge that its input is non-empty to produce guaranteed non-empty output.

groupAllWith operates like groupWith, but sorts the list first so that each equivalence class has, at most, one list in the output

groupAllWith1 is to groupWith1 as groupAllWith is to groupWith

groupBy operates like group, but uses the provided equality predicate instead of ==.

groupBy1 is to group1 as groupBy is to group.

groupWith operates like group, but uses the provided projection when comparing for equality

groupWith1 is to group1 as groupWith is to group

Extract the first element of the stream.

Extract everything except the last element of the stream.

The inits function takes a stream xs and returns all the finite prefixes of xs, starting with the shortest. The result is NonEmpty because the result always contains the empty list as the first element.

inits [1,2,3] == [] :| [[1], [1,2], [1,2,3]]
inits [1] == [] :| [[1]]
inits [] == [] :| []

The inits1 function takes a NonEmpty stream xs and returns all the NonEmpty finite prefixes of xs, starting with the shortest.

inits1 (1 :| [2,3]) == (1 :| []) :| [1 :| [2], 1 :| [2,3]]
inits1 (1 :| []) == (1 :| []) :| []

insert x xs inserts x into the last position in xs where it is still less than or equal to the next element. In particular, if the list is sorted beforehand, the result will also be sorted.

'intersperse x xs' alternates elements of the list with copies of x.

intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]

The isPrefixOf function returns True if the first argument is a prefix of the second.

iterate f x produces the infinite sequence of repeated applications of f to x.

iterate f x = x :| [f x, f (f x), ..]

Extract the last element of the stream.

Number of elements in NonEmpty list.

nonEmpty efficiently turns a normal list into a NonEmpty stream, producing Nothing if the input is empty.

The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means 'essence'.) It is a special case of nubBy, which allows the programmer to supply their own inequality test.

The nubBy function behaves just like nub, except it uses a user-supplied equality predicate instead of the overloaded == function.

The partition function takes a predicate p and a stream xs, and returns a pair of lists. The first list corresponds to the elements of xs for which p holds; the second corresponds to the elements of xs for which p does not hold.

'partition' p xs = ('filter' p xs, 'filter' (not . p) xs)

The permutations function returns the list of all permutations of the argument.

permutations1 operates like permutations, but uses the knowledge that its input is non-empty to produce output where every element is non-empty.

permutations1 = fmap fromList . permutations . toList

Attach a list at the beginning of a NonEmpty.

>>> prependList [] (1 :| [2,3])1 :| [2,3]

>>> prependList [negate 1, 0] (1 :| [2, 3])-1 :| [0,1,2,3]

repeat x returns a constant stream, where all elements are equal to x.

reverse a finite NonEmpty stream.

scanl is similar to foldl, but returns a stream of successive reduced values from the left:

scanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...]

Note that

last (scanl f z xs) == foldl f z xs.

scanl1 is a variant of scanl that has no starting value argument:

scanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...]

scanr is the right-to-left dual of scanl. Note that

head (scanr f z xs) == foldr f z xs.

scanr1 is a variant of scanr that has no starting value argument.

Construct a NonEmpty list from a single element.

some1 x sequences x one or more times.

Sort a stream.

sortBy for NonEmpty, behaves the same as sortBy

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 List.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 for NonEmpty, behaves the same as:

sortBy . comparing

span p xs returns the longest prefix of xs that satisfies p, together with the remainder of the stream.

'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)
xs == ys ++ zs where (ys, zs) = 'span' p xs

splitAt n xs returns a pair consisting of the prefix of xs of length n and the remaining stream immediately following this prefix.

'splitAt' n xs == ('take' n xs, 'drop' n xs)
xs == ys ++ zs where (ys, zs) = 'splitAt' n xs

Extract the possibly-empty tail of the stream.

The tails function takes a stream xs and returns all the suffixes of xs, starting with the longest. The result is NonEmpty because the result always contains the empty list as the last element.

tails [1,2,3] == [1,2,3] :| [[2,3], [3], []]
tails [1] == [1] :| [[]]
tails [] == [] :| []

The tails1 function takes a NonEmpty stream xs and returns all the non-empty suffixes of xs, starting with the longest.

tails1 (1 :| [2,3]) == (1 :| [2,3]) :| [2 :| [3], 3 :| []]
tails1 (1 :| []) == (1 :| []) :| []

take n xs returns the first n elements of xs.

takeWhile p xs returns the longest prefix of the stream xs for which the predicate p holds.

transpose for NonEmpty, behaves the same as transpose The rows/columns need not be the same length, in which case > transpose . transpose /= id

uncons produces the first element of the stream, and a stream of the remaining elements, if any.

unfold produces a new stream by repeatedly applying the unfolding function to the seed value to produce an element of type b and a new seed value. When the unfolding function returns Nothing instead of a new seed value, the stream ends.

The unfoldr function is analogous to Data.List's unfoldr operation.

Compute n-ary logic exclusive OR operation on NonEmpty list.

The zip function takes two streams and returns a stream of corresponding pairs.

The zipWith function generalizes zip. Rather than tupling the elements, the elements are combined using the function passed as the first argument.

Map a function over a NonEmpty stream.

Non-empty (and non-strict) list type.

The IsList class and its methods are intended to be used in conjunction with the OverloadedLists extension.

The Item type function returns the type of items of the structure l.

Generalization of Data.List.unzip.

Examples

>>> unzip (Just ("Hello", "World"))(Just "Hello",Just "World")

>>> unzip [("I", "love"), ("really", "haskell")](["I","really"],["love","haskell"])