Data.NonEmpty.Class

Documentation

class Empty f where

Methods

empty :: f a

Instances

Empty Seq

Defined in Data.NonEmpty.Class

Methods

empty :: Seq a

Empty Set

Defined in Data.NonEmpty.Class

Methods

empty :: Set a

Empty T

Defined in Data.Empty

Methods

empty :: T a

Empty Maybe

Defined in Data.NonEmpty.Class

Methods

empty :: Maybe a

Empty []

Defined in Data.NonEmpty.Class

Methods

empty :: [a]

Empty (Map k)

Defined in Data.NonEmpty.Class

Methods

empty :: Map k a

Empty (T f)

Defined in Data.Optional

Methods

empty :: T f a

class Cons f where

Methods

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

Instances

Cons Seq

Defined in Data.NonEmpty.Class

Methods

cons :: a -> Seq a -> Seq a

Cons []

Defined in Data.NonEmpty.Class

Methods

cons :: a -> [a] -> [a]

Cons f => Cons (T f)

Defined in Data.NonEmptyPrivate

Methods

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

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

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 Seq

Defined in Data.NonEmpty.Class

Methods

snoc :: Seq a -> a -> Seq a

Snoc []

Defined in Data.NonEmpty.Class

Methods

snoc :: [a] -> a -> [a]

Snoc f => Snoc (T f)

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 Seq

Defined in Data.NonEmpty.Class

Methods

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

ViewL Set

Defined in Data.NonEmpty.Class

Methods

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

ViewL T

Defined in Data.Empty

Methods

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

ViewL Maybe

Defined in Data.NonEmpty.Class

Methods

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

ViewL []

Defined in Data.NonEmpty.Class

Methods

viewL :: [a] -> Maybe (a, [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.

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 Seq

Defined in Data.NonEmpty.Class

Methods

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

ViewR Set

Defined in Data.NonEmpty.Class

Methods

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

ViewR T

Defined in Data.Empty

Methods

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

ViewR Maybe

Defined in Data.NonEmpty.Class

Methods

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

ViewR []

Defined in Data.NonEmpty.Class

Methods

viewR :: [a] -> Maybe ([a], a)

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

Instances

View Seq

Defined in Data.NonEmpty.Class

View Set

Defined in Data.NonEmpty.Class

View T

Defined in Data.Empty

View Maybe

Defined in Data.NonEmpty.Class

View []

Defined in Data.NonEmpty.Class

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

class Singleton f where

Methods

singleton :: a -> f a

Instances

Singleton Seq

Defined in Data.NonEmpty.Class

Methods

singleton :: a -> Seq a

Singleton Set

Defined in Data.NonEmpty.Class

Methods

singleton :: a -> Set a

Singleton Maybe

Defined in Data.NonEmpty.Class

Methods

singleton :: a -> Maybe a

Singleton []

Defined in Data.NonEmpty.Class

Methods

singleton :: a -> [a]

Empty f => Singleton (T f)

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 Seq

Defined in Data.NonEmpty.Class

Methods

append :: Seq a -> Seq a -> Seq a

Append []

Defined in Data.NonEmpty.Class

Methods

append :: [a] -> [a] -> [a]

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

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 Seq

Defined in Data.NonEmpty.Class

Methods

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

Zip T

Defined in Data.Empty

Methods

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

Zip Maybe

Defined in Data.NonEmpty.Class

Methods

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

Zip []

Defined in Data.NonEmpty.Class

Methods

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

Zip f => Zip (T f)

Defined in Data.NonEmptyPrivate

Methods

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

Zip f => Zip (T f)

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 T

Defined in Data.Empty

Methods

repeat :: a -> T a

Repeat Maybe

Defined in Data.NonEmpty.Class

Methods

repeat :: a -> Maybe a

Repeat []

Defined in Data.NonEmpty.Class

Methods

repeat :: a -> [a]

Repeat f => Repeat (T f)

Defined in Data.NonEmptyPrivate

Methods

repeat :: a -> T f a

Repeat f => Repeat (T f)

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 T

Defined in Data.Empty

Methods

iterate :: (a -> a) -> a -> T a

Iterate Maybe

Defined in Data.NonEmpty.Class

Methods

iterate :: (a -> a) -> a -> Maybe a

Iterate []

Defined in Data.NonEmpty.Class

Methods

iterate :: (a -> a) -> a -> [a]

Iterate f => Iterate (T f)

Defined in Data.NonEmptyPrivate

Methods

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

Iterate f => Iterate (T f)

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 Seq

Defined in Data.NonEmpty.Class

Methods

sort :: Ord a => Seq a -> Seq a

Sort Set

Defined in Data.NonEmpty.Class

Methods

sort :: Ord a => Set a -> Set a

Sort T

Defined in Data.Empty

Methods

sort :: Ord a => T a -> T a

Sort Maybe

Defined in Data.NonEmpty.Class

Methods

sort :: Ord a => Maybe a -> Maybe a

Sort []

Defined in Data.NonEmpty.Class

Methods

sort :: Ord a => [a] -> [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).

Defined in Data.NonEmptyPrivate

Methods

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

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

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 Seq

Defined in Data.NonEmpty.Class

Methods

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

SortBy T

Defined in Data.Empty

Methods

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

SortBy Maybe

Defined in Data.NonEmpty.Class

Methods

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

SortBy []

Defined in Data.NonEmpty.Class

Methods

sortBy :: (a -> a -> Ordering) -> [a] -> [a]

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

Defined in Data.NonEmptyPrivate

Methods

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

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

Defined in Data.Optional

Methods

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

class Sort f => SortKey f where

Methods

sortKey :: Ord b => (a -> b) -> f a -> f a

Instances

SortKey Seq

Defined in Data.NonEmpty.Class

Methods

sortKey :: Ord b => (a -> b) -> Seq a -> Seq a

SortKey Maybe

Defined in Data.NonEmpty.Class

Methods

sortKey :: Ord b => (a -> b) -> Maybe a -> Maybe a

SortKey []

Defined in Data.NonEmpty.Class

Methods

sortKey :: Ord b => (a -> b) -> [a] -> [a]

sortKeyGen :: (SortBy f, Functor f, Ord b) => (a -> b) -> f a -> f a

class Reverse f where

Methods

reverse :: f a -> f a

Instances

Reverse Seq

Defined in Data.NonEmpty.Class

Methods

reverse :: Seq a -> Seq a

Reverse T

Defined in Data.Empty

Methods

reverse :: T a -> T a

Reverse Maybe

Defined in Data.NonEmpty.Class

Methods

reverse :: Maybe a -> Maybe a

Reverse []

Defined in Data.NonEmpty.Class

Methods

reverse :: [a] -> [a]

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

Defined in Data.NonEmptyPrivate

Methods

reverse :: T f a -> T f a

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

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 Seq

Defined in Data.NonEmpty.Class

Methods

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

Show Set

Defined in Data.NonEmpty.Class

Methods

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

Show T

Defined in Data.Empty

Methods

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

Show Maybe

Defined in Data.NonEmpty.Class

Methods

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

Show []

Defined in Data.NonEmpty.Class

Methods

showsPrec :: Show a => Int -> [a] -> ShowS

Show f => Show (T f)

Defined in Data.NonEmptyPrivate

Methods

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

Show f => Show (T f)

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 Seq

Defined in Data.NonEmpty.Class

Methods

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

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

Arbitrary T

Defined in Data.Empty

Methods

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

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

Arbitrary Maybe

Defined in Data.NonEmpty.Class

Methods

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

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

Arbitrary []

Defined in Data.NonEmpty.Class

Methods

arbitrary :: Arbitrary a => Gen [a]

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

(Arbitrary k, Ord k) => Arbitrary (Map k)

Defined in Data.NonEmpty.Class

Methods

arbitrary :: Arbitrary a => Gen (Map k a)

shrink :: Arbitrary a => Map k a -> [Map k a]

(Arbitrary k, Ord k) => Arbitrary (T k)

Defined in Data.NonEmpty.Map

Methods

arbitrary :: Arbitrary a => Gen (T k a)

shrink :: Arbitrary a => T k a -> [T k a]

Arbitrary f => Arbitrary (T f)

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)

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 Seq

Defined in Data.NonEmpty.Class

Methods

genOf :: Gen a -> Gen (Seq a)

Gen T

Defined in Data.Empty

Methods

genOf :: Gen a -> Gen (T a)

Gen Maybe

Defined in Data.NonEmpty.Class

Methods

genOf :: Gen a -> Gen (Maybe a)

Gen []

Defined in Data.NonEmpty.Class

Methods

genOf :: Gen a -> Gen [a]

(Arbitrary k, Ord k) => Gen (Map k)

Defined in Data.NonEmpty.Class

Methods

genOf :: Gen a -> Gen (Map k a)

(Arbitrary k, Ord k) => Gen (T k)

Defined in Data.NonEmpty.Map

Methods

genOf :: Gen a -> Gen (T k a)

Gen f => Gen (T f)

Defined in Data.NonEmptyPrivate

Methods

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

Gen f => Gen (T f)

Defined in Data.Optional

Methods

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

class NFData f where

Methods

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

Instances

NFData Set

Defined in Data.NonEmpty.Class

Methods

rnf :: NFData a => Set a -> ()

NFData T

Defined in Data.Empty

Methods

rnf :: NFData a => T a -> ()

NFData T

Defined in Data.NonEmpty.Set

Methods

rnf :: NFData a => T a -> ()

NFData Maybe

Defined in Data.NonEmpty.Class

Methods

rnf :: NFData a => Maybe a -> ()

NFData []

Defined in Data.NonEmpty.Class

Methods

rnf :: NFData a => [a] -> ()

NFData k => NFData (Map k)

Defined in Data.NonEmpty.Class

Methods

rnf :: NFData a => Map k a -> ()

NFData k => NFData (T k)

Defined in Data.NonEmpty.Map

Methods

rnf :: NFData a => T k a -> ()

NFData f => NFData (T f)

Defined in Data.NonEmptyPrivate

Methods

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

NFData f => NFData (T f)

Defined in Data.Optional

Methods

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

NFData f => NFData (T f)

Defined in Data.Zip

Methods

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

(NFData f, NFData g) => NFData (T f g)

Defined in Data.Append

Methods

rnf :: NFData a => T f g a -> ()

class Ix f where

Minimal complete definition

range, (index | indexHorner), inRange

Methods

range :: Ix i => (f i, f i) -> [f i]

index :: Ix i => (f i, f i) -> f i -> Int

inRange :: Ix i => (f i, f i) -> f i -> Bool

rangeSize :: Ix i => (f i, f i) -> Int

rangeSizeIndex :: Ix i => (f i, f i) -> (Int, f i -> Int)

The default implementation causes quadratic runtime on nested index tuple types. This affects the index function, too.

indexHorner :: Ix i => (f i, f i) -> Int -> f i -> Int

A custom implementation of this function allows for an even more efficient implementation of index on nested NonEmpty constructors.

Instances

Ix T

Defined in Data.Empty

Methods

range :: Ix i => (T i, T i) -> [T i]

index :: Ix i => (T i, T i) -> T i -> Int

inRange :: Ix i => (T i, T i) -> T i -> Bool

rangeSize :: Ix i => (T i, T i) -> Int

rangeSizeIndex :: Ix i => (T i, T i) -> (Int, T i -> Int)

indexHorner :: Ix i => (T i, T i) -> Int -> T i -> Int

Ix f => Ix (T f)

forRange $ \b0 -> forRange $ \b1 -> forRange $ \b2 -> let b = FuncHT.unzip $ b0!:b1!:b2!:Empty.Cons in map (Ix.index b) (Ix.range b) == take (Ix.rangeSize b) [0..]

Defined in Data.NonEmptyPrivate

Methods

range :: Ix i => (T f i, T f i) -> [T f i]

index :: Ix i => (T f i, T f i) -> T f i -> Int

inRange :: Ix i => (T f i, T f i) -> T f i -> Bool

rangeSize :: Ix i => (T f i, T f i) -> Int

rangeSizeIndex :: Ix i => (T f i, T f i) -> (Int, T f i -> Int)

indexHorner :: Ix i => (T f i, T f i) -> Int -> T f i -> Int