semigroups-0.16.1: Anything that associates

Copyright | (C) 2011-2014 Edward Kmett, (C) 2010 Tony Morris, Oliver Taylor, Eelis van der Weegen
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | provisional
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell98

Data.List.NonEmpty

Contents

- The type of non-empty streams
- Non-empty stream transformations
- Basic functions
- Building streams
- Extracting sublists
- Sublist predicates
- "Set" operations
- Indexing streams
- Zipping and unzipping streams
- Functions on streams of characters
- Converting to and from a list

Description

A NonEmpty list forms a monad as per list, but always contains at least one element.

Synopsis

- data NonEmpty a = a :| [a]
- map :: (a -> b) -> NonEmpty a -> NonEmpty b
- intersperse :: a -> NonEmpty a -> NonEmpty a
- scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b
- scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b
- scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
- sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
- sortOn :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
- length :: NonEmpty a -> Int
- head :: NonEmpty a -> a
- tail :: NonEmpty a -> [a]
- last :: NonEmpty a -> a
- init :: NonEmpty a -> [a]
- (<|) :: a -> NonEmpty a -> NonEmpty a
- cons :: a -> NonEmpty a -> NonEmpty a
- uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))
- unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
- sort :: Ord a => NonEmpty a -> NonEmpty a
- reverse :: NonEmpty a -> NonEmpty a
- inits :: Foldable f => f a -> NonEmpty [a]
- tails :: Foldable f => f a -> NonEmpty [a]
- iterate :: (a -> a) -> a -> NonEmpty a
- repeat :: a -> NonEmpty a
- cycle :: NonEmpty a -> NonEmpty a
- unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b
- insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a
- some1 :: Alternative f => f a -> f (NonEmpty a)
- take :: Int -> NonEmpty a -> [a]
- drop :: Int -> NonEmpty a -> [a]
- splitAt :: Int -> NonEmpty a -> ([a], [a])
- takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
- dropWhile :: (a -> Bool) -> NonEmpty a -> [a]
- span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- filter :: (a -> Bool) -> NonEmpty a -> [a]
- partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- group :: (Foldable f, Eq a) => f a -> [NonEmpty a]
- groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]
- group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
- groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
- isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool
- nub :: Eq a => NonEmpty a -> NonEmpty a
- nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
- (!!) :: NonEmpty a -> Int -> a
- zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
- zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
- unzip :: Functor f => f (a, b) -> (f a, f b)
- words :: NonEmpty Char -> NonEmpty String
- unwords :: NonEmpty String -> NonEmpty Char
- lines :: NonEmpty Char -> NonEmpty String
- unlines :: NonEmpty String -> NonEmpty Char
- fromList :: [a] -> NonEmpty a
- toList :: NonEmpty a -> [a]
- nonEmpty :: [a] -> Maybe (NonEmpty a)
- xor :: NonEmpty Bool -> Bool

# The type of non-empty streams

data NonEmpty a

Constructors

a :| [a] infixr 5 |

Instances

Monad NonEmpty |
Functor NonEmpty |
MonadFix NonEmpty |
Applicative NonEmpty |
Foldable NonEmpty |
Traversable NonEmpty |
MonadZip NonEmpty |
IsList (NonEmpty a) |
Eq a => Eq (NonEmpty a) |
Data a => Data (NonEmpty a) |
Ord a => Ord (NonEmpty a) |
Read a => Read (NonEmpty a) |
Show a => Show (NonEmpty a) |
Generic (NonEmpty a) |
NFData a => NFData (NonEmpty a) |
Hashable a => Hashable (NonEmpty a) |
Semigroup (NonEmpty a) |
Typeable (* -> *) NonEmpty |
type Rep (NonEmpty a) |
type Item (NonEmpty a) = a |

# Non-empty stream transformations

map :: (a -> b) -> NonEmpty a -> NonEmpty b

Map a function over a `NonEmpty` stream.

intersperse :: a -> NonEmpty a -> NonEmpty a

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

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

scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b

`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.

scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b

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

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

scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a

`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), ...]

scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a

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

transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)

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

sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a

`sortBy` for `NonEmpty`, behaves the same as `sortBy`

sortOn :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a

`sortOn` for `NonEmpty`, behaves the same as:

    sortBy . comparing

# Basic functions

length :: NonEmpty a -> Int

head :: NonEmpty a -> a

Extract the first element of the stream.

tail :: NonEmpty a -> [a]

Extract the possibly-empty tail of the stream.

last :: NonEmpty a -> a

Extract the last element of the stream.

init :: NonEmpty a -> [a]

Extract everything except the last element of the stream.

(<|) :: a -> NonEmpty a -> NonEmpty a infixr 5

Prepend an element to the stream.

cons :: a -> NonEmpty a -> NonEmpty a

Synonym for `<|`.

uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))

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

unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b

sort :: Ord a => NonEmpty a -> NonEmpty a

Sort a stream.

reverse :: NonEmpty a -> NonEmpty a

`reverse` a finite NonEmpty stream.

inits :: Foldable f => f a -> NonEmpty [a]

The `inits` function takes a stream `xs` and returns all the finite prefixes of `xs`.

tails :: Foldable f => f a -> NonEmpty [a]

The `tails` function takes a stream `xs` and returns all the suffixes of `xs`.

# Building streams

iterate :: (a -> a) -> a -> NonEmpty a

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

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

repeat :: a -> NonEmpty a

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

cycle :: NonEmpty a -> NonEmpty a

``cycle` xs` returns the infinite repetition of `xs`:

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

unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b

`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.

insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a

``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.

some1 :: Alternative f => f a -> f (NonEmpty a)

``some1` x` sequences `x` one or more times.

# Extracting sublists

take :: Int -> NonEmpty a -> [a]

``take` n xs` returns the first `n` elements of `xs`.

drop :: Int -> NonEmpty a -> [a]

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

splitAt :: Int -> NonEmpty a -> ([a], [a])

``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

takeWhile :: (a -> Bool) -> NonEmpty a -> [a]

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

dropWhile :: (a -> Bool) -> NonEmpty a -> [a]

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

span :: (a -> Bool) -> NonEmpty a -> ([a], [a])

``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

break :: (a -> Bool) -> NonEmpty a -> ([a], [a])

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

filter :: (a -> Bool) -> NonEmpty a -> [a]

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

partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])

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)

group :: (Foldable f, Eq a) => f a -> [NonEmpty a]

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. For example, in list notation:

    'group' $ 'cycle' "Mississippi" = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...

groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]

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

group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)

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

groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)

`groupBy1` is to `group1` as `groupBy` is to `group`.

# Sublist predicates

isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool

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

# "Set" operations

nub :: Eq a => NonEmpty a -> NonEmpty a

The `nub` function removes duplicate elements from a list. In particular, it keeps only the first occurence 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.

nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a

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

# Indexing streams

(!!) :: NonEmpty a -> Int -> a

`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.

# Zipping and unzipping streams

zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)

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

zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

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

unzip :: Functor f => f (a, b) -> (f a, f b)

The `unzip` function is the inverse of the `zip` function.

# Functions on streams of characters

words :: NonEmpty Char -> NonEmpty String

The `words` function breaks a stream of characters into a stream of words, which were delimited by white space.

Beware: if the input contains no words (i.e. is entirely whitespace), this will cause an error.

unwords :: NonEmpty String -> NonEmpty Char

The `unwords` function is an inverse operation to `words`. It joins words with separating spaces.

Beware: the input `("" :| [])` will cause an error.

lines :: NonEmpty Char -> NonEmpty String

The `lines` function breaks a stream of characters into a stream of strings at newline characters. The resulting strings do not contain newlines.

unlines :: NonEmpty String -> NonEmpty Char

The `unlines` function is an inverse operation to `lines`. It joins lines, after appending a terminating newline to each.

# Converting to and from a list

fromList :: [a] -> NonEmpty a

Converts a normal list to a `NonEmpty` stream.

Raises an error if given an empty list.

toList :: NonEmpty a -> [a]

Convert a stream to a normal list efficiently.

nonEmpty :: [a] -> Maybe (NonEmpty a)

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

xor :: NonEmpty Bool -> Bool