Safe Haskell	Safe
Language	Haskell98

Data.NonEmpty.Class

Synopsis

class Empty f where
- empty :: f a
class Cons f where
- cons :: a -> f a -> f a
class Snoc f where
- snoc :: f a -> a -> f a
snocDefault :: (Cons f, Traversable f) => f a -> a -> f a
class ViewL f where
- viewL :: f a -> Maybe (a, f a)
class ViewR f where
- viewR :: f a -> Maybe (f a, a)
class (ViewL f, ViewR f) => View f
viewRDefault :: (ViewL f, Traversable f) => f a -> Maybe (f a, a)
class Singleton f where
- singleton :: a -> f a
class Append f where
- append :: f a -> f a -> f a
class Functor f => Zip f where
- zipWith :: (a -> b -> c) -> f a -> f b -> f c
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
- repeat :: a -> f a
class Repeat f => Iterate f where
- iterate :: (a -> a) -> a -> f a
class Sort f where
- sort :: Ord a => f a -> f a
sortDefault :: (Ord a, SortBy f) => f a -> f a
class Sort f => SortBy f where
- sortBy :: (a -> a -> Ordering) -> f a -> f a
class Reverse f where
- reverse :: f a -> f a
class Show f where
- showsPrec :: Show a => Int -> f a -> ShowS
class Arbitrary f where
- arbitrary :: Arbitrary a => Gen (f a)
- shrink :: Arbitrary a => f a -> [f a]
class Arbitrary f => Gen f where
- genOf :: Gen a -> Gen (f a)
class NFData f where
- rnf :: NFData a => f a -> ()

Documentation

class Empty f where #

Methods

empty :: f a #

Instances

Empty [] #
Instance details Defined in Data.NonEmpty.Class Methods empty :: [a] #
Empty Maybe #
Instance details Defined in Data.NonEmpty.Class Methods empty :: Maybe a #
Empty Seq #
Instance details Defined in Data.NonEmpty.Class Methods empty :: Seq a #
Empty Set #
Instance details Defined in Data.NonEmpty.Class Methods empty :: Set a #
Empty T #
Instance details Defined in Data.Empty Methods empty :: T a #
Empty (Map k) #
Instance details Defined in Data.NonEmpty.Class Methods empty :: Map k a #
Empty (T f) #
Instance details Defined in Data.Optional Methods empty :: T f a #

class Cons f where #

Methods

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

Instances

Cons [] #
Instance details Defined in Data.NonEmpty.Class Methods cons :: a -> [a] -> [a] #
Cons Seq #
Instance details Defined in Data.NonEmpty.Class Methods cons :: a -> Seq a -> Seq a #
Cons f => Cons (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods cons :: a -> T f a -> T f a #
(Cons f, Empty f) => Cons (T f) #
Instance details Defined in Data.Optional Methods cons :: a -> T f a -> T f a #

class Snoc f where #

Methods

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

Instances

Snoc [] #
Instance details Defined in Data.NonEmpty.Class Methods snoc :: [a] -> a -> [a] #
Snoc Seq #
Instance details Defined in Data.NonEmpty.Class Methods snoc :: Seq a -> a -> Seq a #
Snoc f => Snoc (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods snoc :: T f a -> a -> T f a #

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

class ViewL f where #

Methods

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

Instances

ViewL [] #
Instance details Defined in Data.NonEmpty.Class Methods viewL :: [a] -> Maybe (a, [a]) #
ViewL Maybe #
Instance details Defined in Data.NonEmpty.Class Methods viewL :: Maybe a -> Maybe (a, Maybe a) #
ViewL Seq #
Instance details Defined in Data.NonEmpty.Class Methods viewL :: Seq a -> Maybe (a, Seq a) #
ViewL Set #
Instance details Defined in Data.NonEmpty.Class Methods viewL :: Set a -> Maybe (a, Set a) #
ViewL T #
Instance details Defined in Data.Empty Methods viewL :: T a -> Maybe (a, T a) #
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`.
Instance details Defined in Data.NonEmptyPrivate Methods viewL :: T f a -> Maybe (a, T f a) #

class ViewR f where #

Methods

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

Instances

ViewR [] #
Instance details Defined in Data.NonEmpty.Class Methods viewR :: [a] -> Maybe ([a], a) #
ViewR Maybe #
Instance details Defined in Data.NonEmpty.Class Methods viewR :: Maybe a -> Maybe (Maybe a, a) #
ViewR Seq #
Instance details Defined in Data.NonEmpty.Class Methods viewR :: Seq a -> Maybe (Seq a, a) #
ViewR Set #
Instance details Defined in Data.NonEmpty.Class Methods viewR :: Set a -> Maybe (Set a, a) #
ViewR T #
Instance details Defined in Data.Empty Methods viewR :: T a -> Maybe (T a, a) #

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

Instances

View [] #
Instance details Defined in Data.NonEmpty.Class
View Maybe #
Instance details Defined in Data.NonEmpty.Class
View Seq #
Instance details Defined in Data.NonEmpty.Class
View Set #
Instance details Defined in Data.NonEmpty.Class
View T #
Instance details Defined in Data.Empty

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

class Singleton f where #

Methods

singleton :: a -> f a #

Instances

Singleton [] #
Instance details Defined in Data.NonEmpty.Class Methods singleton :: a -> [a] #
Singleton Maybe #
Instance details Defined in Data.NonEmpty.Class Methods singleton :: a -> Maybe a #
Singleton Seq #
Instance details Defined in Data.NonEmpty.Class Methods singleton :: a -> Seq a #
Singleton Set #
Instance details Defined in Data.NonEmpty.Class Methods singleton :: a -> Set a #
Empty f => Singleton (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods singleton :: a -> T f a #

class Append f where #

Methods

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

Instances

Append [] #
Instance details Defined in Data.NonEmpty.Class Methods append :: [a] -> [a] -> [a] #
Append Seq #
Instance details Defined in Data.NonEmpty.Class Methods append :: Seq a -> Seq a -> Seq a #
(Cons f, Append f) => Append (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods append :: T f a -> T f a -> T f a #

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 [] #
Instance details Defined in Data.NonEmpty.Class Methods zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] #
Zip Maybe #
Instance details Defined in Data.NonEmpty.Class Methods zipWith :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c #
Zip Seq #
Instance details Defined in Data.NonEmpty.Class Methods zipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c #
Zip T #
Instance details Defined in Data.Empty Methods zipWith :: (a -> b -> c) -> T a -> T b -> T c #
Zip f => Zip (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods zipWith :: (a -> b -> c) -> T f a -> T f b -> T f c #
Zip f => Zip (T f) #
Instance details Defined in Data.Optional Methods zipWith :: (a -> b -> c) -> T f a -> T f b -> T f c #

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 [] #
Instance details Defined in Data.NonEmpty.Class Methods repeat :: a -> [a] #
Repeat Maybe #
Instance details Defined in Data.NonEmpty.Class Methods repeat :: a -> Maybe a #
Repeat T #
Instance details Defined in Data.Empty Methods repeat :: a -> T a #
Repeat f => Repeat (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods repeat :: a -> T f a #
Repeat f => Repeat (T f) #
Instance details Defined in Data.Optional Methods repeat :: a -> T f a #

class Repeat f => Iterate f where #

Methods

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

Instances

Iterate [] #
Instance details Defined in Data.NonEmpty.Class Methods iterate :: (a -> a) -> a -> [a] #
Iterate Maybe #
Instance details Defined in Data.NonEmpty.Class Methods iterate :: (a -> a) -> a -> Maybe a #
Iterate T #
Instance details Defined in Data.Empty Methods iterate :: (a -> a) -> a -> T a #
Iterate f => Iterate (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods iterate :: (a -> a) -> a -> T f a #
Iterate f => Iterate (T f) #
Instance details Defined in Data.Optional Methods iterate :: (a -> a) -> a -> T f a #

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 [] #
Instance details Defined in Data.NonEmpty.Class Methods sort :: Ord a => [a] -> [a] #
Sort Maybe #
Instance details Defined in Data.NonEmpty.Class Methods sort :: Ord a => Maybe a -> Maybe a #
Sort Seq #
Instance details Defined in Data.NonEmpty.Class Methods sort :: Ord a => Seq a -> Seq a #
Sort Set #
Instance details Defined in Data.NonEmpty.Class Methods sort :: Ord a => Set a -> Set a #
Sort T #
Instance details Defined in Data.Empty Methods sort :: Ord a => T a -> T a #
(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).
Instance details Defined in Data.NonEmptyPrivate Methods sort :: Ord a => T f a -> T f a #
(Insert f, Sort f) => Sort (T f) #
Instance details Defined in Data.Optional Methods sort :: Ord a => T f a -> T f a #

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 [] #
Instance details Defined in Data.NonEmpty.Class Methods sortBy :: (a -> a -> Ordering) -> [a] -> [a] #
SortBy Maybe #
Instance details Defined in Data.NonEmpty.Class Methods sortBy :: (a -> a -> Ordering) -> Maybe a -> Maybe a #
SortBy Seq #
Instance details Defined in Data.NonEmpty.Class Methods sortBy :: (a -> a -> Ordering) -> Seq a -> Seq a #
SortBy T #
Instance details Defined in Data.Empty Methods sortBy :: (a -> a -> Ordering) -> T a -> T a #
(SortBy f, InsertBy f) => SortBy (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods sortBy :: (a -> a -> Ordering) -> T f a -> T f a #
(InsertBy f, SortBy f) => SortBy (T f) #
Instance details Defined in Data.Optional Methods sortBy :: (a -> a -> Ordering) -> T f a -> T f a #

class Reverse f where #

Methods

reverse :: f a -> f a #

Instances

Reverse [] #
Instance details Defined in Data.NonEmpty.Class Methods reverse :: [a] -> [a] #
Reverse Maybe #
Instance details Defined in Data.NonEmpty.Class Methods reverse :: Maybe a -> Maybe a #
Reverse Seq #
Instance details Defined in Data.NonEmpty.Class Methods reverse :: Seq a -> Seq a #
Reverse T #
Instance details Defined in Data.Empty Methods reverse :: T a -> T a #
(Traversable f, Reverse f) => Reverse (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods reverse :: T f a -> T f a #
(Traversable f, Reverse f) => Reverse (T f) #
Instance details Defined in Data.Optional Methods reverse :: T f a -> T f a #

class Show f where #

Methods

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

Instances

Show [] #
Instance details Defined in Data.NonEmpty.Class Methods showsPrec :: Show a => Int -> [a] -> ShowS #
Show Set #
Instance details Defined in Data.NonEmpty.Class Methods showsPrec :: Show a => Int -> Set a -> ShowS #
Show T #
Instance details Defined in Data.Empty Methods showsPrec :: Show a => Int -> T a -> ShowS #
Show f => Show (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods showsPrec :: Show a => Int -> T f a -> ShowS #
Show f => Show (T f) #
Instance details Defined in Data.Optional Methods showsPrec :: Show a => Int -> T f a -> ShowS #

class Arbitrary f where #

Methods

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

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

Instances

Arbitrary [] #
Instance details Defined in Data.NonEmpty.Class Methods arbitrary :: Arbitrary a => Gen [a] # shrink :: Arbitrary a => [a] -> [[a]] #
Arbitrary Maybe #
Instance details Defined in Data.NonEmpty.Class Methods arbitrary :: Arbitrary a => Gen (Maybe a) # shrink :: Arbitrary a => Maybe a -> [Maybe a] #
Arbitrary T #
Instance details Defined in Data.Empty Methods arbitrary :: Arbitrary a => Gen (T a) # shrink :: Arbitrary a => T a -> [T a] #
Arbitrary f => Arbitrary (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods arbitrary :: Arbitrary a => Gen (T f a) # shrink :: Arbitrary a => T f a -> [T f a] #
Arbitrary f => Arbitrary (T f) #
Instance details Defined in Data.Optional Methods arbitrary :: Arbitrary a => Gen (T f a) # shrink :: Arbitrary a => T f a -> [T f a] #

class Arbitrary f => Gen f where #

Methods

genOf :: Gen a -> Gen (f a) #

Instances

Gen [] #
Instance details Defined in Data.NonEmpty.Class Methods genOf :: Gen a -> Gen [a] #
Gen Maybe #
Instance details Defined in Data.NonEmpty.Class Methods genOf :: Gen a -> Gen (Maybe a) #
Gen T #
Instance details Defined in Data.Empty Methods genOf :: Gen a -> Gen (T a) #
Gen f => Gen (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods genOf :: Gen a -> Gen (T f a) #
Gen f => Gen (T f) #
Instance details Defined in Data.Optional Methods genOf :: Gen a -> Gen (T f a) #

class NFData f where #

Methods

rnf :: NFData a => f a -> () #

Instances

NFData [] #
Instance details Defined in Data.NonEmpty.Class Methods rnf :: NFData a => [a] -> () #
NFData Maybe #
Instance details Defined in Data.NonEmpty.Class Methods rnf :: NFData a => Maybe a -> () #
NFData Set #
Instance details Defined in Data.NonEmpty.Class Methods rnf :: NFData a => Set a -> () #
NFData T #
Instance details Defined in Data.Empty Methods rnf :: NFData a => T a -> () #
NFData T #
Instance details Defined in Data.NonEmpty.Set Methods rnf :: NFData a => T a -> () #
NFData k => NFData (Map k) #
Instance details Defined in Data.NonEmpty.Class Methods rnf :: NFData a => Map k a -> () #
NFData f => NFData (T f) #
Instance details Defined in Data.NonEmptyPrivate Methods rnf :: NFData a => T f a -> () #
NFData k => NFData (T k) #
Instance details Defined in Data.NonEmpty.Map Methods rnf :: NFData a => T k a -> () #
NFData f => NFData (T f) #
Instance details Defined in Data.Optional Methods rnf :: NFData a => T f a -> () #
NFData f => NFData (T f) #
Instance details Defined in Data.Zip Methods rnf :: NFData a => T f a -> () #
(NFData f, NFData g) => NFData (T f g) #
Instance details Defined in Data.Append Methods rnf :: NFData a => T f g a -> () #