Data.NonEmpty.Class

Documentation

class Empty f where

Methods

empty :: f a

Instances

Empty []

Empty Maybe

Empty T

Empty (T f)

class Cons f where

Methods

cons :: a -> f a -> f a

Instances

Cons []

Cons f => Cons (T f)

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

class View f where

Methods

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

Instances

View []

View Maybe

View T

class Singleton f where

Methods

singleton :: a -> f a

Instances

Singleton []

Singleton Maybe

Empty f => Singleton (T f)

class Append f where

Methods

append :: f a -> f a -> f a

Instances

Append []

(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 T

Zip f => Zip (T f)

Zip f => Zip (T f)

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

class Repeat f where

Methods

repeat :: a -> f a

Instances

Repeat []

Repeat f => Repeat (T f)

Repeat f => Repeat (T f)

class Sort f where

Methods

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

Instances

Sort []

Sort Maybe

Sort T

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

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

sort :: (Ord a, Sort f) => f a -> f a

class Reverse f where

Methods

reverse :: f a -> f a

Instances

Reverse []

Reverse Maybe

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 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 []