Data.NonEmpty

This package extends NonEmpty from semigroups to arbitrary Alternative types. The method is the same as for lists, by separating an element from the rest.

There are two natural ways to merge an element x to the rest of the structure xs. The first gives rise to NonEmptyL:

flattenL :: NonEmptyL f a -> f a
flattenL (x :<: xs) = pure x <|> xs

The second gives rise to NonEmptyR:

flattenR :: NonEmptyR f a -> f a
flattenR (xs :>: x) = xs <|> pure x

The instances are made so that flattenL gives a type class morphism between NonEmptyL List and List, and flattenR gives the same for NonEmptyR RList and RList from the package rlist.

Left Non-Empty Alternatives

data NonEmptyL f a

The type NonEmptyL is well suited for cons structures.

Constructors

a :<: (f a) infixr 5

Instances

(Alternative f, Monad f) => Monad (NonEmptyL f)

Functor f => Functor (NonEmptyL f)

Alternative f => Applicative (NonEmptyL f)

Foldable f => Foldable (NonEmptyL f)

(Functor f, Traversable f) => Traversable (NonEmptyL f)

Generic1 (NonEmptyL f)

Alternative f => Comonad (NonEmptyL f)

(Eq a, Eq (f a)) => Eq (NonEmptyL f a)

(Data a, Data (f a), Typeable (* -> *) f) => Data (NonEmptyL f a)

(Ord a, Ord (f a)) => Ord (NonEmptyL f a)

(Read a, Read (f a)) => Read (NonEmptyL f a)

(Show a, Show (f a)) => Show (NonEmptyL f a)

Generic (NonEmptyL f a)

Alternative f => Semigroup (NonEmptyL f a)

type Rep1 (NonEmptyL f)

type Rep (NonEmptyL f a)

Basic functions for NonEmptyL

headL :: NonEmptyL f a -> a

Extracts the structure's singular element. This function is total and equivalent to extract from Comonad.

tailL :: NonEmptyL f a -> f a

Extracts the structure's remaining data. This function is total.

flattenL :: Alternative f => NonEmptyL f a -> f a

Flattens the structure to its base type from the left.

joinL :: (Alternative f, Monad f) => NonEmptyL f (NonEmptyL f a) -> NonEmptyL f a

This is equivalent to join for Monad.

budgeL :: (Alternative f, Alternative g) => NonEmptyL f (g a) -> NonEmptyL f (g a)

Budge the head into the remaining structure from the left, adding an empty head.

Right Non-Empty Alternatives

data NonEmptyR f a

The type NonEmptyR is well suited for snoc structures.

Constructors

(f a) :>: a infixl 5

Instances

Functor f => Functor (NonEmptyR f)

Alternative f => Applicative (NonEmptyR f)

Foldable f => Foldable (NonEmptyR f)

(Functor f, Traversable f) => Traversable (NonEmptyR f)

Generic1 (NonEmptyR f)

Alternative f => Comonad (NonEmptyR f)

(Eq a, Eq (f a)) => Eq (NonEmptyR f a)

(Data a, Data (f a), Typeable (* -> *) f) => Data (NonEmptyR f a)

(Ord a, Ord (f a)) => Ord (NonEmptyR f a)

(Read a, Read (f a)) => Read (NonEmptyR f a)

(Show a, Show (f a)) => Show (NonEmptyR f a)

Generic (NonEmptyR f a)

Alternative f => Semigroup (NonEmptyR f a)

type Rep1 (NonEmptyR f)

type Rep (NonEmptyR f a)

Basic functions for NonEmptyR

lastR :: NonEmptyR f a -> a

Extracts the structure's singular element. This function is total and equivalent to extract from Comonad.

initR :: NonEmptyR f a -> f a

Extracts the structure's remaining data. This function is total.

flattenR :: Alternative f => NonEmptyR f a -> f a

Flattens the structure to its base type from the right.

joinR :: (Alternative f, Monad f) => NonEmptyR f (NonEmptyR f a) -> NonEmptyR f a

This is equivalent to join for Monad.

budgeR :: (Alternative f, Alternative g) => NonEmptyR f (g a) -> NonEmptyR f (g a)

Budge the head into the remaining structure from the right, adding an empty head.