-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Anything that associates
--
-- In mathematics, a semigroup is an algebraic structure consisting of a
-- set together with an associative binary operation. A semigroup
-- generalizes a monoid in that there might not exist an identity
-- element. It also (originally) generalized a group (a monoid with all
-- inverses) to a type where every element did not have to have an
-- inverse, thus the name semigroup.
@package semigroups
@version 0.13
-- | A NonEmpty list forms a monad as per list, but always contains at
-- least one element.
module Data.List.NonEmpty
data NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
-- | Map a function over a NonEmpty stream.
map :: (a -> b) -> NonEmpty a -> NonEmpty b
-- | 'intersperse x xs' alternates elements of the list with copies of
-- x.
--
--
-- intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]
--
intersperse :: a -> NonEmpty a -> NonEmpty a
-- | 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.
--
scanl :: Foldable f => (b -> a -> 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.
--
scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b
-- | 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), ...]
--
scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
-- | scanr1 is a variant of scanr that has no starting value
-- argument.
scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
-- | sortBy for NonEmpty, behaves the same as sortBy
sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
-- | sortOn for NonEmpty, behaves the same as:
--
--
-- sortBy . comparing
--
sortOn :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
length :: NonEmpty a -> Int
-- | Extract the first element of the stream.
head :: NonEmpty a -> a
-- | Extract the possibly-empty tail of the stream.
tail :: NonEmpty a -> [a]
-- | Extract the last element of the stream.
last :: NonEmpty a -> a
-- | Extract everything except the last element of the stream.
init :: NonEmpty a -> [a]
-- | Prepend an element to the stream.
(<|) :: a -> NonEmpty a -> NonEmpty a
-- | Synonym for <|.
cons :: a -> NonEmpty a -> NonEmpty a
-- | uncons produces the first element of the stream, and a stream
-- of the remaining elements, if any.
uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))
unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
-- | Sort a stream.
sort :: Ord a => NonEmpty a -> NonEmpty a
-- | reverse a finite NonEmpty stream.
reverse :: NonEmpty a -> NonEmpty a
-- | The inits function takes a stream xs and returns all
-- the finite prefixes of xs.
inits :: Foldable f => f a -> NonEmpty [a]
-- | The tails function takes a stream xs and returns all
-- the suffixes of xs.
tails :: Foldable f => f 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), ..]
--
iterate :: (a -> a) -> a -> NonEmpty a
-- | repeat x returns a constant stream, where all elements
-- are equal to x.
repeat :: a -> NonEmpty a
-- | cycle xs returns the infinite repetition of
-- xs:
--
--
-- cycle [1,2,3] = 1 :| [2,3,1,2,3,...]
--
cycle :: NonEmpty a -> NonEmpty a
-- | 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.
unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b
-- | 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.
insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a
-- | some1 x sequences x one or more times.
some1 :: Alternative f => f a -> f (NonEmpty a)
-- | take n xs returns the first n elements of
-- xs.
take :: Int -> NonEmpty a -> [a]
-- | drop n xs drops the first n elements off the
-- front of the sequence xs.
drop :: Int -> NonEmpty 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
--
splitAt :: Int -> NonEmpty a -> ([a], [a])
-- | takeWhile p xs returns the longest prefix of the
-- stream xs for which the predicate p holds.
takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
-- | dropWhile p xs returns the suffix remaining after
-- takeWhile p xs.
dropWhile :: (a -> Bool) -> NonEmpty 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
--
span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
-- | The break p function is equivalent to span
-- (not . p).
break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
-- | filter p xs removes any elements from xs that
-- do not satisfy p.
filter :: (a -> Bool) -> NonEmpty 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)
--
partition :: (a -> Bool) -> NonEmpty a -> ([a], [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" : ...
--
group :: (Foldable f, Eq a) => f a -> [NonEmpty a]
-- | groupBy operates like group, but uses the provided
-- equality predicate instead of ==.
groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]
-- | group1 operates like group, but uses the knowledge that
-- its input is non-empty to produce guaranteed non-empty output.
group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
-- | groupBy1 is to group1 as groupBy is to
-- group.
groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
-- | The isPrefix function returns True if the first
-- argument is a prefix of the second.
isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool
-- | 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.
nub :: Eq a => NonEmpty a -> NonEmpty a
-- | The nubBy function behaves just like nub, except it uses
-- a user-supplied equality predicate instead of the overloaded ==
-- function.
nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty 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.
(!!) :: NonEmpty a -> Int -> a
-- | The zip function takes two streams and returns a stream of
-- corresponding pairs.
zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
-- | The zipWith function generalizes zip. Rather than
-- tupling the elements, the elements are combined using the function
-- passed as the first argument.
zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
-- | The unzip function is the inverse of the zip function.
unzip :: Functor f => f (a, b) -> (f a, f b)
-- | 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.
words :: NonEmpty Char -> NonEmpty String
-- | The unwords function is an inverse operation to words.
-- It joins words with separating spaces.
--
-- Beware: the input ("" :| []) will cause an error.
unwords :: NonEmpty String -> NonEmpty Char
-- | The lines function breaks a stream of characters into a stream
-- of strings at newline characters. The resulting strings do not contain
-- newlines.
lines :: NonEmpty Char -> NonEmpty String
-- | The unlines function is an inverse operation to lines.
-- It joins lines, after appending a terminating newline to each.
unlines :: NonEmpty String -> NonEmpty Char
-- | Converts a normal list to a NonEmpty stream.
--
-- Raises an error if given an empty list.
fromList :: [a] -> NonEmpty a
-- | Convert a stream to a normal list efficiently.
toList :: NonEmpty a -> [a]
-- | nonEmpty efficiently turns a normal list into a NonEmpty
-- stream, producing Nothing if the input is empty.
nonEmpty :: [a] -> Maybe (NonEmpty a)
xor :: NonEmpty Bool -> Bool
instance Typeable1 NonEmpty
instance Eq a => Eq (NonEmpty a)
instance Ord a => Ord (NonEmpty a)
instance Show a => Show (NonEmpty a)
instance Read a => Read (NonEmpty a)
instance Data a => Data (NonEmpty a)
instance Foldable NonEmpty
instance Traversable NonEmpty
instance Monad NonEmpty
instance Applicative NonEmpty
instance Functor NonEmpty
-- | In mathematics, a semigroup is an algebraic structure consisting of a
-- set together with an associative binary operation. A semigroup
-- generalizes a monoid in that there might not exist an identity
-- element. It also (originally) generalized a group (a monoid with all
-- inverses) to a type where every element did not have to have an
-- inverse, thus the name semigroup.
--
-- The use of (<>) in this module conflicts with an
-- operator with the same name that is being exported by Data.Monoid.
-- However, this package re-exports (most of) the contents of
-- Data.Monoid, so to use semigroups and monoids in the same package just
--
--
-- import Data.Semigroup
--
module Data.Semigroup
class Semigroup a where <> = mappend sconcat (a :| as) = go a as where go b (c : cs) = b <> go c cs go b [] = b times1p y0 x0 = f x0 (1 + y0) where f x y | even y = f (x <> x) (y `quot` 2) | y == 1 = x | otherwise = g (x <> x) (unsafePred y `quot` 2) x g x y z | even y = g (x <> x) (y `quot` 2) z | y == 1 = x <> z | otherwise = g (x <> x) (unsafePred y `quot` 2) (x <> z)
(<>) :: Semigroup a => a -> a -> a
sconcat :: Semigroup a => NonEmpty a -> a
times1p :: (Semigroup a, Whole n) => n -> a -> a
newtype Min a
Min :: a -> Min a
getMin :: Min a -> a
newtype Max a
Max :: a -> Max a
getMax :: Max a -> a
-- | Use Option (First a) to get the behavior of
-- First from Data.Monoid.
newtype First a
First :: a -> First a
getFirst :: First a -> a
-- | Use Option (Last a) to get the behavior of
-- Last from Data.Monoid
newtype Last a
Last :: a -> Last a
getLast :: Last a -> a
-- | Provide a Semigroup for an arbitrary Monoid.
newtype WrappedMonoid m
WrapMonoid :: m -> WrappedMonoid m
unwrapMonoid :: WrappedMonoid m -> m
-- | Repeat a value n times.
--
--
-- timesN n a = a <> a <> ... <> a -- using <> (n-1) times
--
--
-- Implemented using times1p.
timesN :: (Whole n, Monoid a) => n -> a -> a
-- | The class of monoids (types with an associative binary operation that
-- has an identity). Instances should satisfy the following laws:
--
--
--
-- The method names refer to the monoid of lists under concatenation, but
-- there are many other instances.
--
-- Minimal complete definition: mempty and mappend.
--
-- Some types can be viewed as a monoid in more than one way, e.g. both
-- addition and multiplication on numbers. In such cases we often define
-- newtypes and make those instances of Monoid, e.g.
-- Sum and Product.
class Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [a] -> a
-- | The dual of a monoid, obtained by swapping the arguments of
-- mappend.
newtype Dual a :: * -> *
Dual :: a -> Dual a
getDual :: Dual a -> a
-- | The monoid of endomorphisms under composition.
newtype Endo a :: * -> *
Endo :: (a -> a) -> Endo a
appEndo :: Endo a -> a -> a
-- | Boolean monoid under conjunction.
newtype All :: *
All :: Bool -> All
getAll :: All -> Bool
-- | Boolean monoid under disjunction.
newtype Any :: *
Any :: Bool -> Any
getAny :: Any -> Bool
-- | Monoid under addition.
newtype Sum a :: * -> *
Sum :: a -> Sum a
getSum :: Sum a -> a
-- | Monoid under multiplication.
newtype Product a :: * -> *
Product :: a -> Product a
getProduct :: Product a -> a
-- | Option is effectively Maybe with a better instance of
-- Monoid, built off of an underlying Semigroup instead of
-- an underlying Monoid.
--
-- Ideally, this type would not exist at all and we would just fix the
-- Monoid instance of Maybe
newtype Option a
Option :: Maybe a -> Option a
getOption :: Option a -> Maybe a
-- | Fold an Option case-wise, just like maybe.
option :: b -> (a -> b) -> Option a -> b
-- | This lets you use a difference list of a Semigroup as a
-- Monoid.
diff :: Semigroup m => m -> Endo m
-- | A generalization of cycle to an arbitrary Semigroup. May
-- fail to terminate for some values in some semigroups.
cycle1 :: Semigroup m => m -> m
instance Typeable1 Min
instance Typeable1 Max
instance Typeable1 First
instance Typeable1 Last
instance Typeable1 WrappedMonoid
instance Typeable1 Option
instance Eq a => Eq (Min a)
instance Ord a => Ord (Min a)
instance Enum a => Enum (Min a)
instance Bounded a => Bounded (Min a)
instance Show a => Show (Min a)
instance Read a => Read (Min a)
instance Hashable a => Hashable (Min a)
instance Data a => Data (Min a)
instance Eq a => Eq (Max a)
instance Ord a => Ord (Max a)
instance Enum a => Enum (Max a)
instance Bounded a => Bounded (Max a)
instance Show a => Show (Max a)
instance Read a => Read (Max a)
instance Hashable a => Hashable (Max a)
instance Data a => Data (Max a)
instance Generic (Max a)
instance Eq a => Eq (First a)
instance Ord a => Ord (First a)
instance Enum a => Enum (First a)
instance Bounded a => Bounded (First a)
instance Show a => Show (First a)
instance Read a => Read (First a)
instance Hashable a => Hashable (First a)
instance Data a => Data (First a)
instance Generic (First a)
instance Eq a => Eq (Last a)
instance Ord a => Ord (Last a)
instance Enum a => Enum (Last a)
instance Bounded a => Bounded (Last a)
instance Show a => Show (Last a)
instance Read a => Read (Last a)
instance Hashable a => Hashable (Last a)
instance Data a => Data (Last a)
instance Generic (Last a)
instance Eq m => Eq (WrappedMonoid m)
instance Ord m => Ord (WrappedMonoid m)
instance Enum m => Enum (WrappedMonoid m)
instance Bounded m => Bounded (WrappedMonoid m)
instance Show m => Show (WrappedMonoid m)
instance Read m => Read (WrappedMonoid m)
instance Hashable m => Hashable (WrappedMonoid m)
instance Data m => Data (WrappedMonoid m)
instance Generic (WrappedMonoid m)
instance Eq a => Eq (Option a)
instance Ord a => Ord (Option a)
instance Show a => Show (Option a)
instance Read a => Read (Option a)
instance Hashable a => Hashable (Option a)
instance Data a => Data (Option a)
instance Generic (Option a)
instance Datatype D1Max
instance Constructor C1_0Max
instance Selector S1_0_0Max
instance Datatype D1First
instance Constructor C1_0First
instance Selector S1_0_0First
instance Datatype D1Last
instance Constructor C1_0Last
instance Selector S1_0_0Last
instance Datatype D1WrappedMonoid
instance Constructor C1_0WrappedMonoid
instance Selector S1_0_0WrappedMonoid
instance Datatype D1Option
instance Constructor C1_0Option
instance Selector S1_0_0Option
instance Ord k => Semigroup (Map k v)
instance Semigroup (IntMap v)
instance Ord a => Semigroup (Set a)
instance Semigroup IntSet
instance Semigroup (Seq a)
instance Semigroup a => Monoid (Option a)
instance Semigroup a => Semigroup (Option a)
instance Traversable Option
instance Foldable Option
instance MonadFix Option
instance MonadPlus Option
instance Alternative Option
instance Monad Option
instance Applicative Option
instance Functor Option
instance Monoid m => Monoid (WrappedMonoid m)
instance Monoid m => Semigroup (WrappedMonoid m)
instance (Hashable a, Eq a) => Semigroup (HashSet a)
instance (Hashable k, Eq k) => Semigroup (HashMap k a)
instance Semigroup Text
instance Semigroup Text
instance Semigroup ByteString
instance Semigroup ByteString
instance MonadFix Last
instance Monad Last
instance Applicative Last
instance Traversable Last
instance Foldable Last
instance Functor Last
instance Semigroup (Last a)
instance MonadFix First
instance Monad First
instance Applicative First
instance Traversable First
instance Foldable First
instance Functor First
instance Semigroup (First a)
instance MonadFix Max
instance Monad Max
instance Applicative Max
instance Traversable Max
instance Foldable Max
instance Functor Max
instance (Ord a, Bounded a) => Monoid (Max a)
instance Ord a => Semigroup (Max a)
instance MonadFix Min
instance Monad Min
instance Applicative Min
instance Traversable Min
instance Foldable Min
instance Functor Min
instance (Ord a, Bounded a) => Monoid (Min a)
instance Ord a => Semigroup (Min a)
instance Semigroup (NonEmpty a)
instance Semigroup (Last a)
instance Semigroup (First a)
instance Semigroup a => Semigroup (Const a b)
instance Num a => Semigroup (Product a)
instance Num a => Semigroup (Sum a)
instance Semigroup Any
instance Semigroup All
instance Semigroup (Endo a)
instance Semigroup a => Semigroup (Dual a)
instance Semigroup Ordering
instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)
instance (Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)
instance (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)
instance (Semigroup a, Semigroup b) => Semigroup (a, b)
instance Semigroup (Either a b)
instance Semigroup a => Semigroup (Maybe a)
instance Semigroup [a]
instance Semigroup b => Semigroup (a -> b)
instance Semigroup ()