Data.NonEmpty.Class

Documentation

class Empty f where

Methods

empty :: f a

Instances

Empty []

Empty Maybe

Empty Set

Empty Seq

Empty T

Empty (T f)

class Cons f where

Methods

cons :: a -> f a -> f a infixr 5

Instances

Cons []

Cons Seq

Cons f => Cons (T f)

(Cons f, Empty f) => Cons (T f)

class Snoc f where

Methods

snoc :: f a -> a -> f a

Instances

Snoc []

Snoc Seq

Snoc f => Snoc (T f)

snocDefault :: (Cons f, Traversable f) => f a -> a -> f a

class ViewL f where

Methods

viewL :: f a -> Maybe (a, f a)

Instances

ViewL []

ViewL Maybe

ViewL Set

ViewL Seq

ViewL T

ViewL f => ViewL (T f)

Caution: viewL (NonEmpty.Cons x []) = Nothing because the tail is empty, and thus cannot be NonEmpty!

This instance mainly exist to allow cascaded applications of fetch.

class ViewR f where

Methods

viewR :: f a -> Maybe (f a, a)

Instances

ViewR []

ViewR Maybe

ViewR Set

ViewR Seq

ViewR T

class (ViewL f, ViewR f) => View f

Instances

View []

View Maybe

View Set

View Seq

View T

viewRDefault :: (ViewL f, Traversable f) => f a -> Maybe (f a, a)

class Singleton f where

Methods

singleton :: a -> f a

Instances

Singleton []

Singleton Maybe

Singleton Set

Singleton Seq

Empty f => Singleton (T f)

class Append f where

Methods

append :: f a -> f a -> f a infixr 5

Instances

Append []

Append Seq

(Cons f, Append f) => Append (T f)

class Functor f => Zip f where

It must hold:

fmap f xs
   = zipWith (\x _ -> f x) xs xs
   = zipWith (\_ x -> f x) xs xs

Methods

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

Instances

Zip []

Zip Maybe

Zip Seq

Zip T

Zip f => Zip (T f)

Zip f => Zip (T f)

zipWith3 :: Zip f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

zipWith4 :: Zip f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e

zip :: Zip f => f a -> f b -> f (a, b)

zip3 :: Zip f => f a -> f b -> f c -> f (a, b, c)

zip4 :: Zip f => f a -> f b -> f c -> f d -> f (a, b, c, d)

class Repeat f where

Methods

repeat :: a -> f a

Create a container with as many copies as possible of a given value. That is, for a container with fixed size n, the call repeat x will generate a container with n copies of x.

Instances

Repeat []

Repeat T

Repeat f => Repeat (T f)

Repeat f => Repeat (T f)

class Repeat f => Iterate f where

Methods

iterate :: (a -> a) -> a -> f a

Instances

Iterate []

Iterate T

Iterate f => Iterate (T f)

class Sort f where

We need to distinguish between Sort and SortBy, since there is an instance Sort Set but there cannot be an instance SortBy Set.

Methods

sort :: Ord a => f a -> f a

Instances

Sort []

Sort Maybe

Sort Set

Sort Seq

Sort T

(Sort f, InsertBy f) => Sort (T f)

If you nest too many non-empty lists then the efficient merge-sort (linear-logarithmic runtime) will degenerate to an inefficient insert-sort (quadratic runtime).

(Insert f, Sort f) => Sort (T f)

sortDefault :: (Ord a, SortBy f) => f a -> f a

Default implementation for sort based on sortBy.

class Sort f => SortBy f where

Methods

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

Instances

SortBy []

SortBy Maybe

SortBy Seq

SortBy T

(SortBy f, InsertBy f) => SortBy (T f)

(InsertBy f, SortBy f) => SortBy (T f)

class Reverse f where

Methods

reverse :: f a -> f a

Instances

Reverse []

Reverse Maybe

Reverse Seq

Reverse T

(Traversable f, Reverse f) => Reverse (T f)

(Traversable f, Reverse f) => Reverse (T f)

class Show f where

Methods

showsPrec :: Show a => Int -> f a -> ShowS

Instances

Show []

Show Set

Show T

Show f => Show (T f)

Show f => Show (T f)

class Arbitrary f where

Methods

arbitrary :: Arbitrary a => Gen (f a)

shrink :: Arbitrary a => f a -> [f a]

Instances

Arbitrary []

Arbitrary f => Arbitrary (T f)