Control.Monad.List.NonEmpty.Exotic

The usual list monad is only one of infinitely many ways to turn the NonEmpty (list) functor into a monad. This module collects a number of such exotic "non-empty list monads". Most of them have been introduced in the paper Degrading Lists by Dylan McDermott, Maciej Piróg, Tarmo Uustalu (PPDP 2020).

Notes:

• Types marked with "(?)" have not been formally verified to be monads (yet), though they were thoroughly tested with billions of QuickCheck tests.
• Monads in this module are presented in terms of join rather than >>=, while return is singleton, unless stated otherwise for a particular monad (e.g., HeadTails, HeadsTail, or IdXList).
• For readability, code snippets in this documentation assume the OverloadedLists and OverloadedStrings extensions, which allow us to omit some newtype constructors. Example definitions of joins of monads always skip the newtype constructors, that is, assume >>= is always defined as follows for a particular local join.

m >>= f = wrap $ join $ fmap (unwrap . f) $ unwrap m
 where
  join = ...

• Sometimes it is more readable to define the join in terms of possibly-empty lists. In such a case, we call the local function joinList:

m >>= f = wrap $ fromList $ joinList $ map (toList . unwrap . f) $ toList $ unwrap m
 where
  joinList = ...

• The definitions of monads are optimized for readability and not run-time performance. This is because the monads in this module don't seem to be of any practical use, they are more of a theoretical curiosity.

Non-empty monads in general

class IsNonEmpty l where

This class collects types that are isomorphic to non-empty lists. It mimics the IsList class.

Associated Types

type ItemNE l

Methods

fromNonEmpty :: NonEmpty (ItemNE l) -> l

toNonEmpty :: l -> NonEmpty (ItemNE l)

Instances

IsNonEmpty (NonEmpty a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (NonEmpty a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (NonEmpty a)) -> NonEmpty a

toNonEmpty :: NonEmpty a -> NonEmpty (ItemNE (NonEmpty a))

IsNonEmpty (AlphaOmega a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (AlphaOmega a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (AlphaOmega a)) -> AlphaOmega a

toNonEmpty :: AlphaOmega a -> NonEmpty (ItemNE (AlphaOmega a))

IsNonEmpty (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (HeadsTail a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (HeadsTail a)) -> HeadsTail a

toNonEmpty :: HeadsTail a -> NonEmpty (ItemNE (HeadsTail a))

IsNonEmpty (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (HeadTails a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (HeadTails a)) -> HeadTails a

toNonEmpty :: HeadTails a -> NonEmpty (ItemNE (HeadTails a))

IsNonEmpty (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (MazeWalkNE a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (MazeWalkNE a)) -> MazeWalkNE a

toNonEmpty :: MazeWalkNE a -> NonEmpty (ItemNE (MazeWalkNE a))

IsNonEmpty (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (OpDiscreteHybridNE a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (OpDiscreteHybridNE a)) -> OpDiscreteHybridNE a

toNonEmpty :: OpDiscreteHybridNE a -> NonEmpty (ItemNE (OpDiscreteHybridNE a))

IsNonEmpty (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (DiscreteHybridNE a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (DiscreteHybridNE a)) -> DiscreteHybridNE a

toNonEmpty :: DiscreteHybridNE a -> NonEmpty (ItemNE (DiscreteHybridNE a))

IsNonEmpty (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (Keeper a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (Keeper a)) -> Keeper a

toNonEmpty :: Keeper a -> NonEmpty (ItemNE (Keeper a))

ListMonad m => IsNonEmpty (IdXList m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (IdXList m a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (IdXList m a)) -> IdXList m a

toNonEmpty :: IdXList m a -> NonEmpty (ItemNE (IdXList m a))

KnownNat n => IsNonEmpty (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (StutterNE n a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (StutterNE n a)) -> StutterNE n a

toNonEmpty :: StutterNE n a -> NonEmpty (ItemNE (StutterNE n a))

IsNonEmpty (m a) => IsNonEmpty (DualNonEmptyMonad m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (DualNonEmptyMonad m a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (DualNonEmptyMonad m a)) -> DualNonEmptyMonad m a

toNonEmpty :: DualNonEmptyMonad m a -> NonEmpty (ItemNE (DualNonEmptyMonad m a))

(IsNonEmpty (m a), KnownNat p) => IsNonEmpty (ShortRear m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (ShortRear m p a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (ShortRear m p a)) -> ShortRear m p a

toNonEmpty :: ShortRear m p a -> NonEmpty (ItemNE (ShortRear m p a))

(IsNonEmpty (m a), KnownNat p) => IsNonEmpty (ShortFront m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (ShortFront m p a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (ShortFront m p a)) -> ShortFront m p a

toNonEmpty :: ShortFront m p a -> NonEmpty (ItemNE (ShortFront m p a))

class Monad m => NonEmptyMonad m where

In this module, a "non-empty monad" is a monad in which the underlying functor is isomorphic to NonEmpty.

Minimal complete definition

Nothing

Methods

wrap :: NonEmpty a -> m a

wrap :: (IsNonEmpty (m a), ItemNE (m a) ~ a) => NonEmpty a -> m a

unwrap :: m a -> NonEmpty a

unwrap :: (IsNonEmpty (m a), ItemNE (m a) ~ a) => m a -> NonEmpty a

Instances

NonEmptyMonad NonEmpty

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> NonEmpty a

unwrap :: NonEmpty a -> NonEmpty a

NonEmptyMonad AlphaOmega

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> AlphaOmega a

unwrap :: AlphaOmega a -> NonEmpty a

NonEmptyMonad HeadsTail

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> HeadsTail a

unwrap :: HeadsTail a -> NonEmpty a

NonEmptyMonad HeadTails

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> HeadTails a

unwrap :: HeadTails a -> NonEmpty a

NonEmptyMonad MazeWalkNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> MazeWalkNE a

unwrap :: MazeWalkNE a -> NonEmpty a

NonEmptyMonad OpDiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> OpDiscreteHybridNE a

unwrap :: OpDiscreteHybridNE a -> NonEmpty a

NonEmptyMonad DiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> DiscreteHybridNE a

unwrap :: DiscreteHybridNE a -> NonEmpty a

NonEmptyMonad Keeper

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> Keeper a

unwrap :: Keeper a -> NonEmpty a

ListMonad m => NonEmptyMonad (IdXList m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> IdXList m a

unwrap :: IdXList m a -> NonEmpty a

KnownNat n => NonEmptyMonad (StutterNE n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> StutterNE n a

unwrap :: StutterNE n a -> NonEmpty a

NonEmptyMonad m => NonEmptyMonad (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> DualNonEmptyMonad m a

unwrap :: DualNonEmptyMonad m a -> NonEmpty a

(HasShortRear m, KnownNat p) => NonEmptyMonad (ShortRear m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> ShortRear m p a

unwrap :: ShortRear m p a -> NonEmpty a

(HasShortFront m, KnownNat p) => NonEmptyMonad (ShortFront m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> ShortFront m p a

unwrap :: ShortFront m p a -> NonEmpty a

More on non-empty lists

isSingle :: NonEmpty a -> Bool

Check if a list is a singleton.

splitSnoc :: NonEmpty a -> ([a], a)

Split a non empty list to reveal the last element.

nonEmptyConcat :: NonEmpty (NonEmpty a) -> NonEmpty a

concat for non-empty lists.

(+++) :: NonEmpty a -> NonEmpty a -> NonEmpty a

++ for non-empty lists.

nonEmptyAll :: (a -> Bool) -> NonEmpty a -> Bool

all for non-empty lists.

nonEmptyAny :: (a -> Bool) -> NonEmpty a -> Bool

any for non-empty lists.

Monads from magmas

This section contains monads that come about from free algebras of theories with one binary operation, that is, subcalsses of Magma with no additional methods, but additional equations.

class Magma a where

A very simple algebraic theory with one binary operations and no equations.

Methods

(<>) :: a -> a -> a

Instances

Magma (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: MazeWalkNE a -> MazeWalkNE a -> MazeWalkNE a

Magma (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: OpDiscreteHybridNE a -> OpDiscreteHybridNE a -> OpDiscreteHybridNE a

Magma (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: DiscreteHybridNE a -> DiscreteHybridNE a -> DiscreteHybridNE a

Magma (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: Keeper a -> Keeper a -> Keeper a

KnownNat n => Magma (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: StutterNE n a -> StutterNE n a -> StutterNE n a

class NonEmptyMonad m => FreeRBM m (c :: * -> Constraint) | m -> c where

The name of the class stands for free right-braketed (subclass of) magma. (compare FreeRBPM for more detailed explanation).

We consider theories c with one equation of the following shape:

(x <> y) <> z  ==  ...

and normal forms of the following shape:

x <> (y <> ( ... (z <> t) ... ))

An instance FreeRBM m c means that the monad m comes about from free algebras of the theory c. For such monads and theories, we can define the following function:

foldRBM f (toNonEmpty -> toList -> xs) = foldr1 (<>) (map f xs)

which is the unique lifting of an interpretation of generators to a homomorphism (between algebras of this theory) from the list monad to any algebra (an instance) of c.

Note that the default definition of foldRBM is always the right one for right-bracketed subclasses of Magma, so it is enough to declare the relationship, for example:

instance FreeRBM NonEmpty Semigroup

Minimal complete definition

Nothing

Methods

foldRBM :: (Magma a, c a) => (x -> a) -> m x -> a

Instances

FreeRBM NonEmpty Semigroup

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, Semigroup a) => (x -> a) -> NonEmpty x -> a

FreeRBM MazeWalkNE PalindromeMagma

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, PalindromeMagma a) => (x -> a) -> MazeWalkNE x -> a

FreeRBM OpDiscreteHybridNE XZ

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, XZ a) => (x -> a) -> OpDiscreteHybridNE x -> a

FreeRBM DiscreteHybridNE YZ

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, YZ a) => (x -> a) -> DiscreteHybridNE x -> a

FreeRBM Keeper XY

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, XY a) => (x -> a) -> Keeper x -> a

KnownNat n => FreeRBM (StutterNE n) (StutterMagma n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, StutterMagma n a) => (x -> a) -> StutterNE n x -> a

The Keeper monad

class Magma a => XY a

Instances should satisfy the following equation:

(x <> y) <> z  ==  x <> y

Instances

FreeRBM Keeper XY

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, XY a) => (x -> a) -> Keeper x -> a

XY (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

newtype Keeper a

The keeper monad arises from free XY magmas. Its join (in terms of joinList) is given as follows:

joinList xss = map head (takeWhile isSingle (init xss))
                ++ head (dropWhile isSingle (init xss) ++ [last xss])

Examples:

>>> toList $ unwrap (join ["a", "b", "c", "hello", "there"] :: Keeper Char)
"abchello"
>>> toList $ unwrap (join ["a", "b", "c", "hello"] :: Keeper Char)
"abchello"

Constructors

Keeper

Fields

• unKeeper :: NonEmpty a

Instances

Monad Keeper

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: Keeper a -> (a -> Keeper b) -> Keeper b

(>>) :: Keeper a -> Keeper b -> Keeper b

return :: a -> Keeper a

fail :: String -> Keeper a

Functor Keeper

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> Keeper a -> Keeper b

(<$) :: a -> Keeper b -> Keeper a

Applicative Keeper

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> Keeper a

(<*>) :: Keeper (a -> b) -> Keeper a -> Keeper b

liftA2 :: (a -> b -> c) -> Keeper a -> Keeper b -> Keeper c

(*>) :: Keeper a -> Keeper b -> Keeper b

(<*) :: Keeper a -> Keeper b -> Keeper a

HasShortFront Keeper

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

NonEmptyMonad Keeper

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> Keeper a

unwrap :: Keeper a -> NonEmpty a

FreeRBM Keeper XY

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, XY a) => (x -> a) -> Keeper x -> a

IsList (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type Item (Keeper a) :: Type

Methods

fromList :: [Item (Keeper a)] -> Keeper a

fromListN :: Int -> [Item (Keeper a)] -> Keeper a

toList :: Keeper a -> [Item (Keeper a)]

Eq a => Eq (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: Keeper a -> Keeper a -> Bool

(/=) :: Keeper a -> Keeper a -> Bool

Show a => Show (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> Keeper a -> ShowS

show :: Keeper a -> String

showList :: [Keeper a] -> ShowS

IsString (Keeper Char)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fromString :: String -> Keeper Char

XY (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Magma (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: Keeper a -> Keeper a -> Keeper a

IsNonEmpty (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (Keeper a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (Keeper a)) -> Keeper a

toNonEmpty :: Keeper a -> NonEmpty (ItemNE (Keeper a))

type Item (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

type Item (Keeper a) = a

type ItemNE (Keeper a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (Keeper a) = a

The Non-Empty Discrete Hybrid monad

class Magma a => YZ a

Instances should satisfy the following equation:

(x <> y) <> z  ==  y <> z

Instances

FreeRBM DiscreteHybridNE YZ

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, YZ a) => (x -> a) -> DiscreteHybridNE x -> a

YZ (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

newtype DiscreteHybridNE a

The non-empty discrete hybrid monad arises from free YZ magmas. Its join (in terms of joinList) can be given as follows:

joinList xss = map last (init xss) ++ last xss

See the possibly-empty version (DiscreteHybrid) for more details.

Constructors

DiscreteHybridNE

Fields

• unDiscreteHybridNE :: NonEmpty a

Instances

Monad DiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: DiscreteHybridNE a -> (a -> DiscreteHybridNE b) -> DiscreteHybridNE b

(>>) :: DiscreteHybridNE a -> DiscreteHybridNE b -> DiscreteHybridNE b

return :: a -> DiscreteHybridNE a

fail :: String -> DiscreteHybridNE a

Functor DiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> DiscreteHybridNE a -> DiscreteHybridNE b

(<$) :: a -> DiscreteHybridNE b -> DiscreteHybridNE a

Applicative DiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> DiscreteHybridNE a

(<*>) :: DiscreteHybridNE (a -> b) -> DiscreteHybridNE a -> DiscreteHybridNE b

liftA2 :: (a -> b -> c) -> DiscreteHybridNE a -> DiscreteHybridNE b -> DiscreteHybridNE c

(*>) :: DiscreteHybridNE a -> DiscreteHybridNE b -> DiscreteHybridNE b

(<*) :: DiscreteHybridNE a -> DiscreteHybridNE b -> DiscreteHybridNE a

HasShortRear DiscreteHybridNE

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

NonEmptyMonad DiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> DiscreteHybridNE a

unwrap :: DiscreteHybridNE a -> NonEmpty a

FreeRBM DiscreteHybridNE YZ

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, YZ a) => (x -> a) -> DiscreteHybridNE x -> a

Eq a => Eq (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: DiscreteHybridNE a -> DiscreteHybridNE a -> Bool

(/=) :: DiscreteHybridNE a -> DiscreteHybridNE a -> Bool

Show a => Show (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> DiscreteHybridNE a -> ShowS

show :: DiscreteHybridNE a -> String

showList :: [DiscreteHybridNE a] -> ShowS

YZ (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Magma (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: DiscreteHybridNE a -> DiscreteHybridNE a -> DiscreteHybridNE a

IsNonEmpty (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (DiscreteHybridNE a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (DiscreteHybridNE a)) -> DiscreteHybridNE a

toNonEmpty :: DiscreteHybridNE a -> NonEmpty (ItemNE (DiscreteHybridNE a))

type ItemNE (DiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (DiscreteHybridNE a) = a

The Non-Empty Discrete Op-Hybrid monad

class Magma a => XZ a

Instances should satisfy the following equation:

(x <> y) <> z  ==  x <> z

Instances

FreeRBM OpDiscreteHybridNE XZ

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, XZ a) => (x -> a) -> OpDiscreteHybridNE x -> a

XZ (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

newtype OpDiscreteHybridNE a

The non-empty discrete op-hybrid monad arises from free XZ magmas. It is dual to the DiscreteHybridNE monad (but in a different dimension than DualNonEmptyMonad). Its join (in terms of joinList) can be given as follows:

joinList xss = map head (init xss) ++ last xss

Examples:

>>> toList $ unwrap (join ["John", "Ronald", "Reuel", "Tolkien"] :: OpDiscreteHybridNE Char)
"JRRTolkien"

Surprisingly, while the DiscreteHybridNE monad has a counterpart for possibly-empty lists (DiscreteHybrid), the would-be counterpart of OpDiscreteHybridNE obtained by taking first elements in the init is not a monad.

Constructors

OpDiscreteHybridNE

Fields

• unOpDiscreteHybridNE :: NonEmpty a

Instances

Monad OpDiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: OpDiscreteHybridNE a -> (a -> OpDiscreteHybridNE b) -> OpDiscreteHybridNE b

(>>) :: OpDiscreteHybridNE a -> OpDiscreteHybridNE b -> OpDiscreteHybridNE b

return :: a -> OpDiscreteHybridNE a

fail :: String -> OpDiscreteHybridNE a

Functor OpDiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> OpDiscreteHybridNE a -> OpDiscreteHybridNE b

(<$) :: a -> OpDiscreteHybridNE b -> OpDiscreteHybridNE a

Applicative OpDiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> OpDiscreteHybridNE a

(<*>) :: OpDiscreteHybridNE (a -> b) -> OpDiscreteHybridNE a -> OpDiscreteHybridNE b

liftA2 :: (a -> b -> c) -> OpDiscreteHybridNE a -> OpDiscreteHybridNE b -> OpDiscreteHybridNE c

(*>) :: OpDiscreteHybridNE a -> OpDiscreteHybridNE b -> OpDiscreteHybridNE b

(<*) :: OpDiscreteHybridNE a -> OpDiscreteHybridNE b -> OpDiscreteHybridNE a

HasShortFront OpDiscreteHybridNE

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

NonEmptyMonad OpDiscreteHybridNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> OpDiscreteHybridNE a

unwrap :: OpDiscreteHybridNE a -> NonEmpty a

FreeRBM OpDiscreteHybridNE XZ

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, XZ a) => (x -> a) -> OpDiscreteHybridNE x -> a

IsList (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type Item (OpDiscreteHybridNE a) :: Type

Methods

fromList :: [Item (OpDiscreteHybridNE a)] -> OpDiscreteHybridNE a

fromListN :: Int -> [Item (OpDiscreteHybridNE a)] -> OpDiscreteHybridNE a

toList :: OpDiscreteHybridNE a -> [Item (OpDiscreteHybridNE a)]

Eq a => Eq (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: OpDiscreteHybridNE a -> OpDiscreteHybridNE a -> Bool

(/=) :: OpDiscreteHybridNE a -> OpDiscreteHybridNE a -> Bool

Show a => Show (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> OpDiscreteHybridNE a -> ShowS

show :: OpDiscreteHybridNE a -> String

showList :: [OpDiscreteHybridNE a] -> ShowS

IsString (OpDiscreteHybridNE Char)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fromString :: String -> OpDiscreteHybridNE Char

XZ (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Magma (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: OpDiscreteHybridNE a -> OpDiscreteHybridNE a -> OpDiscreteHybridNE a

IsNonEmpty (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (OpDiscreteHybridNE a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (OpDiscreteHybridNE a)) -> OpDiscreteHybridNE a

toNonEmpty :: OpDiscreteHybridNE a -> NonEmpty (ItemNE (OpDiscreteHybridNE a))

type Item (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

type Item (OpDiscreteHybridNE a) = a

type ItemNE (OpDiscreteHybridNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (OpDiscreteHybridNE a) = a

The Non-Empty Maze Walk monad

class Magma a => PalindromeMagma a

Instances should satisfy the following equation:

(x <> y) <> z  ==  x <> (y <> (x <> z))

Instances

FreeRBM MazeWalkNE PalindromeMagma

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, PalindromeMagma a) => (x -> a) -> MazeWalkNE x -> a

PalindromeMagma (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

newtype MazeWalkNE a

The non-empty maze walk monad arises from free PalindromeMagma-s. Its join (in terms of joinList) can be given as follows:

joinList xss = map palindromize (init xss) ++ last xss

See the possibly-empty version (MazeWalk) for more details.

Constructors

MazeWalkNE

Fields

• unMazeWalkNE :: NonEmpty a

Instances

Monad MazeWalkNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: MazeWalkNE a -> (a -> MazeWalkNE b) -> MazeWalkNE b

(>>) :: MazeWalkNE a -> MazeWalkNE b -> MazeWalkNE b

return :: a -> MazeWalkNE a

fail :: String -> MazeWalkNE a

Functor MazeWalkNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> MazeWalkNE a -> MazeWalkNE b

(<$) :: a -> MazeWalkNE b -> MazeWalkNE a

Applicative MazeWalkNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> MazeWalkNE a

(<*>) :: MazeWalkNE (a -> b) -> MazeWalkNE a -> MazeWalkNE b

liftA2 :: (a -> b -> c) -> MazeWalkNE a -> MazeWalkNE b -> MazeWalkNE c

(*>) :: MazeWalkNE a -> MazeWalkNE b -> MazeWalkNE b

(<*) :: MazeWalkNE a -> MazeWalkNE b -> MazeWalkNE a

HasShortFront MazeWalkNE

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

NonEmptyMonad MazeWalkNE

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> MazeWalkNE a

unwrap :: MazeWalkNE a -> NonEmpty a

FreeRBM MazeWalkNE PalindromeMagma

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, PalindromeMagma a) => (x -> a) -> MazeWalkNE x -> a

Eq a => Eq (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: MazeWalkNE a -> MazeWalkNE a -> Bool

(/=) :: MazeWalkNE a -> MazeWalkNE a -> Bool

Show a => Show (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> MazeWalkNE a -> ShowS

show :: MazeWalkNE a -> String

showList :: [MazeWalkNE a] -> ShowS

PalindromeMagma (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Magma (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: MazeWalkNE a -> MazeWalkNE a -> MazeWalkNE a

IsNonEmpty (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (MazeWalkNE a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (MazeWalkNE a)) -> MazeWalkNE a

toNonEmpty :: MazeWalkNE a -> NonEmpty (ItemNE (MazeWalkNE a))

type ItemNE (MazeWalkNE a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (MazeWalkNE a) = a

The Non-Empty Stutter monad

class (KnownNat n, Magma a) => StutterMagma n a

Instances should satisfy the following equation:

(x <> y) <> z  ==  foldr1 (<>) (replicate (n + 2) x)

Instances

KnownNat n => StutterMagma n (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

KnownNat n => FreeRBM (StutterNE n) (StutterMagma n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, StutterMagma n a) => (x -> a) -> StutterNE n x -> a

newtype StutterNE (n :: Nat) a

The non-empty stutter monad arises from free StutterMagma-s. Its join (in terms of joinList) can be given as follows:

joinList xss | any (not . isSingle) (init xss)
             = map head (takeWhile isSingle (init xss))
                ++ replicate (n + 2) (head (head (dropWhile isSingle (init xss))))
             | otherwise
             = map head (init xss) ++ last xss

Examples:

>>> toList $ unwrap (join ["a", "b", "c", "hello", "there"] :: StutterNE 5 Char)
"abchhhhhhh"
>>> toList $ unwrap (join ["a", "b", "c", "hello"] :: StutterNE 5 Char)
"abchello"

Constructors

StutterNE

Fields

• unStutterNE :: NonEmpty a

Instances

KnownNat n => StutterMagma n (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

KnownNat n => Monad (StutterNE n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: StutterNE n a -> (a -> StutterNE n b) -> StutterNE n b

(>>) :: StutterNE n a -> StutterNE n b -> StutterNE n b

return :: a -> StutterNE n a

fail :: String -> StutterNE n a

Functor (StutterNE n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> StutterNE n a -> StutterNE n b

(<$) :: a -> StutterNE n b -> StutterNE n a

KnownNat n => Applicative (StutterNE n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> StutterNE n a

(<*>) :: StutterNE n (a -> b) -> StutterNE n a -> StutterNE n b

liftA2 :: (a -> b -> c) -> StutterNE n a -> StutterNE n b -> StutterNE n c

(*>) :: StutterNE n a -> StutterNE n b -> StutterNE n b

(<*) :: StutterNE n a -> StutterNE n b -> StutterNE n a

KnownNat n => HasShortFront (StutterNE n)

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

KnownNat n => NonEmptyMonad (StutterNE n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> StutterNE n a

unwrap :: StutterNE n a -> NonEmpty a

KnownNat n => FreeRBM (StutterNE n) (StutterMagma n)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

foldRBM :: (Magma a, StutterMagma n a) => (x -> a) -> StutterNE n x -> a

KnownNat n => IsList (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type Item (StutterNE n a) :: Type

Methods

fromList :: [Item (StutterNE n a)] -> StutterNE n a

fromListN :: Int -> [Item (StutterNE n a)] -> StutterNE n a

toList :: StutterNE n a -> [Item (StutterNE n a)]

Eq a => Eq (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: StutterNE n a -> StutterNE n a -> Bool

(/=) :: StutterNE n a -> StutterNE n a -> Bool

Show a => Show (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> StutterNE n a -> ShowS

show :: StutterNE n a -> String

showList :: [StutterNE n a] -> ShowS

KnownNat n => IsString (StutterNE n Char)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fromString :: String -> StutterNE n Char

KnownNat n => Magma (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(<>) :: StutterNE n a -> StutterNE n a -> StutterNE n a

KnownNat n => IsNonEmpty (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (StutterNE n a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (StutterNE n a)) -> StutterNE n a

toNonEmpty :: StutterNE n a -> NonEmpty (ItemNE (StutterNE n a))

type Item (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

type Item (StutterNE n a) = a

type ItemNE (StutterNE n a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (StutterNE n a) = a

Other monads with finite presentation

In contrast to the possibly-empty-list case, there are known non-empty monads that arise from algebraic theories, but ones that cannot be presented with one binary operations (as in monads that come about from subclasses of Magma).

The Head-Tails monad

class HeadTailTail a where

The head-tail-tail algebra has two operations: unary hd (intuitively, it produces a singleton list with the head of the argument as the element) and ternary htt (intuitively, it produces the concat of the head of the first argument and tails of the other two arguments).

Instances should satisfy the following equations:

x                         ==  htt x x (hd x)
hd (hd x)                 ==  hd x
hd (htt x y z)            ==  hd x
htt x y (hd z)            ==  htt x y (hd y)
htt x y (htt z v w)       ==  htt x y (htt y v w)
htt x (hd y) (hd z)       ==  hd x
htt x (hd y) (htt z v w)  ==  htt x v w
htt x (htt y z v) w       ==  htt x z (htt z v w)
htt (hd x) y z            ==  htt x y z
htt (htt x y z) v w       ==  htt x v w

Moreover, when read left-to-right they form a terminating and confluent rewriting system with normal forms of the following shape:

htt x y $ htt y z $ htt z v $ ... $ htt w t (hd t)

Methods

hd :: a -> a

htt :: a -> a -> a -> a

Instances

HeadTailTail (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

hd :: HeadTails a -> HeadTails a

htt :: HeadTails a -> HeadTails a -> HeadTails a -> HeadTails a

newtype HeadTails a

The Head-Tails monad arises from free head-tail-tail algebras. Its unit is a dubleton, that is:

return x = HeadTails (x :| [x])

Its join is defined as:

join ((x :| _) :| xss) = x :| concatMap NonEmpty.tail xss

For example:

>>> toList $ unwrap (join ["John", "Paul", "George", "Ringo"] :: HeadTails Char)
"Jauleorgeingo"

Constructors

HeadTails

Fields

• unHeadTails :: NonEmpty a

Instances

Monad HeadTails

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: HeadTails a -> (a -> HeadTails b) -> HeadTails b

(>>) :: HeadTails a -> HeadTails b -> HeadTails b

return :: a -> HeadTails a

fail :: String -> HeadTails a

Functor HeadTails

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> HeadTails a -> HeadTails b

(<$) :: a -> HeadTails b -> HeadTails a

Applicative HeadTails

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> HeadTails a

(<*>) :: HeadTails (a -> b) -> HeadTails a -> HeadTails b

liftA2 :: (a -> b -> c) -> HeadTails a -> HeadTails b -> HeadTails c

(*>) :: HeadTails a -> HeadTails b -> HeadTails b

(<*) :: HeadTails a -> HeadTails b -> HeadTails a

NonEmptyMonad HeadTails

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> HeadTails a

unwrap :: HeadTails a -> NonEmpty a

IsList (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type Item (HeadTails a) :: Type

Methods

fromList :: [Item (HeadTails a)] -> HeadTails a

fromListN :: Int -> [Item (HeadTails a)] -> HeadTails a

toList :: HeadTails a -> [Item (HeadTails a)]

Eq a => Eq (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: HeadTails a -> HeadTails a -> Bool

(/=) :: HeadTails a -> HeadTails a -> Bool

Show a => Show (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> HeadTails a -> ShowS

show :: HeadTails a -> String

showList :: [HeadTails a] -> ShowS

IsString (HeadTails Char)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fromString :: String -> HeadTails Char

HeadTailTail (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

hd :: HeadTails a -> HeadTails a

htt :: HeadTails a -> HeadTails a -> HeadTails a -> HeadTails a

IsNonEmpty (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (HeadTails a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (HeadTails a)) -> HeadTails a

toNonEmpty :: HeadTails a -> NonEmpty (ItemNE (HeadTails a))

type Item (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

type Item (HeadTails a) = a

type ItemNE (HeadTails a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (HeadTails a) = a

foldHeadTails :: HeadTailTail a => (g -> a) -> HeadTails g -> a

The HeadTails monad arises from free head-tail-tail algebras, so an interpretation of generators g to a head-tail-tail algebra a can be (uniquely) lifted to a homomorphism between head-tail-tail algebras.

The Heads-Tail monad

class HeadHeadTail a where

Instances should satisfy the following equations:

x                    ==  ht x x
hd' (hd' x)          ==  hd' x
hd' (ht x y)         ==  hd' x
hd' (hht x y z)      ==  hd' x
ht x (hd' y)         ==  hd' x
ht x (ht y z)        ==  ht x z
ht x (hht y z v)     ==  hht x z v
ht (hd' x) y         ==  ht x y
ht (ht x y) z        ==  ht x z
ht (hht x y z) v     ==  ht x v
hht x y (hd' z)      ==  hd' x
hht x y (ht z v)     ==  hht x y v
hht x y (hht z v w)  ==  hht x y (hht y v w)
hht x (hd' y) z      ==  hht x y z
hht x (ht y z) v     ==  hht x y v
hht x (hht y z v) w  ==  hht x y w
hht (hd' x) y z      ==  hht x y z
hht (ht x y) z v     ==  hht x z v
hht (hht x y z) v w  ==  hht x v w

Moreover, when read left-to-right they form a terminating and confluent rewriting system with normal forms of the following shape:

hd' x
ht x y
hht x y $ hht y z $ hht z v $ ... $ hht w t u

Methods

hd' :: a -> a

ht :: a -> a -> a

hht :: a -> a -> a -> a

Instances

HeadHeadTail (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

hd' :: HeadsTail a -> HeadsTail a

ht :: HeadsTail a -> HeadsTail a -> HeadsTail a

hht :: HeadsTail a -> HeadsTail a -> HeadsTail a -> HeadsTail a

newtype HeadsTail a

The Heads-Tail monad arises from free head-head-tail algebras. Its unit is a dubleton, that is:

return x = HeadsTail (x :| [x])

Its join is defined as:

join xss@(splitSnoc -> (xss', xs@(_:|ys)))
  | isSingle xss || isSingle xs
  = (NonEmpty.head $ NonEmpty.head xss) :| []
  | otherwise
  = fromList $ map NonEmpty.head xss' ++ ys

For example:

>>> toList $ unwrap (join ["John", "Paul", "George", "Ringo"] :: HeadsTail Char)
"JPGingo"

Constructors

HeadsTail

Fields

• unHeadsTail :: NonEmpty a

Instances

Monad HeadsTail

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: HeadsTail a -> (a -> HeadsTail b) -> HeadsTail b

(>>) :: HeadsTail a -> HeadsTail b -> HeadsTail b

return :: a -> HeadsTail a

fail :: String -> HeadsTail a

Functor HeadsTail

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> HeadsTail a -> HeadsTail b

(<$) :: a -> HeadsTail b -> HeadsTail a

Applicative HeadsTail

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> HeadsTail a

(<*>) :: HeadsTail (a -> b) -> HeadsTail a -> HeadsTail b

liftA2 :: (a -> b -> c) -> HeadsTail a -> HeadsTail b -> HeadsTail c

(*>) :: HeadsTail a -> HeadsTail b -> HeadsTail b

(<*) :: HeadsTail a -> HeadsTail b -> HeadsTail a

NonEmptyMonad HeadsTail

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> HeadsTail a

unwrap :: HeadsTail a -> NonEmpty a

IsList (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type Item (HeadsTail a) :: Type

Methods

fromList :: [Item (HeadsTail a)] -> HeadsTail a

fromListN :: Int -> [Item (HeadsTail a)] -> HeadsTail a

toList :: HeadsTail a -> [Item (HeadsTail a)]

Eq a => Eq (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: HeadsTail a -> HeadsTail a -> Bool

(/=) :: HeadsTail a -> HeadsTail a -> Bool

Show a => Show (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> HeadsTail a -> ShowS

show :: HeadsTail a -> String

showList :: [HeadsTail a] -> ShowS

IsString (HeadsTail Char)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fromString :: String -> HeadsTail Char

HeadHeadTail (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

hd' :: HeadsTail a -> HeadsTail a

ht :: HeadsTail a -> HeadsTail a -> HeadsTail a

hht :: HeadsTail a -> HeadsTail a -> HeadsTail a -> HeadsTail a

IsNonEmpty (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (HeadsTail a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (HeadsTail a)) -> HeadsTail a

toNonEmpty :: HeadsTail a -> NonEmpty (ItemNE (HeadsTail a))

type Item (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

type Item (HeadsTail a) = a

type ItemNE (HeadsTail a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (HeadsTail a) = a

foldHeadsTail :: HeadHeadTail a => (g -> a) -> HeadsTail g -> a

The HeadsTail monad arises from free head-head-tail algebras, so an interpretation of generators g to a head-head-tail algebra a can be (uniquely) lifted to a homomorphism between head-head-tail algebras.

Other monads

The ΑΩ monad (?)

newtype AlphaOmega a

The join of the ΑΩ (Alpha-Omega) monad takes the first element of the first list and the last element of the last list (unless the unit laws require otherwise):

join xss | isSingle xss || nonEmptyAll isSingle xss
         = nonEmptyConcat xss
         | otherwise
         =  NonEmpty.head (NonEmpty.head xss)
         :| NonEmpty.last (NonEmpty.last xss) : []

For example:

>>> toList $ unwrap (join ["John", "Paul", "George", "Ringo"] :: AlphaOmega Char)
"Jo"

Constructors

AlphaOmega

Fields

• unAlphaOmega :: NonEmpty a

Instances

Monad AlphaOmega

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: AlphaOmega a -> (a -> AlphaOmega b) -> AlphaOmega b

(>>) :: AlphaOmega a -> AlphaOmega b -> AlphaOmega b

return :: a -> AlphaOmega a

fail :: String -> AlphaOmega a

Functor AlphaOmega

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> AlphaOmega a -> AlphaOmega b

(<$) :: a -> AlphaOmega b -> AlphaOmega a

Applicative AlphaOmega

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> AlphaOmega a

(<*>) :: AlphaOmega (a -> b) -> AlphaOmega a -> AlphaOmega b

liftA2 :: (a -> b -> c) -> AlphaOmega a -> AlphaOmega b -> AlphaOmega c

(*>) :: AlphaOmega a -> AlphaOmega b -> AlphaOmega b

(<*) :: AlphaOmega a -> AlphaOmega b -> AlphaOmega a

HasShortRear AlphaOmega

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortFront AlphaOmega

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

NonEmptyMonad AlphaOmega

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> AlphaOmega a

unwrap :: AlphaOmega a -> NonEmpty a

IsList (AlphaOmega a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type Item (AlphaOmega a) :: Type

Methods

fromList :: [Item (AlphaOmega a)] -> AlphaOmega a

fromListN :: Int -> [Item (AlphaOmega a)] -> AlphaOmega a

toList :: AlphaOmega a -> [Item (AlphaOmega a)]

Eq a => Eq (AlphaOmega a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: AlphaOmega a -> AlphaOmega a -> Bool

(/=) :: AlphaOmega a -> AlphaOmega a -> Bool

Show a => Show (AlphaOmega a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> AlphaOmega a -> ShowS

show :: AlphaOmega a -> String

showList :: [AlphaOmega a] -> ShowS

IsString (AlphaOmega Char)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fromString :: String -> AlphaOmega Char

IsNonEmpty (AlphaOmega a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (AlphaOmega a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (AlphaOmega a)) -> AlphaOmega a

toNonEmpty :: AlphaOmega a -> NonEmpty (ItemNE (AlphaOmega a))

type Item (AlphaOmega a)

Defined in Control.Monad.List.NonEmpty.Exotic

type Item (AlphaOmega a) = a

type ItemNE (AlphaOmega a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (AlphaOmega a) = a

Constructions on non-empty monads

The dual non-empty list monad

newtype DualNonEmptyMonad m a

Every non-empty list monad has a dual, in which join is defined as

join . reverse . fmap reverse

(where join is the join of the original list monad), while return is

reverse . return

(where return is the return of the original list monad).

Constructors

DualNonEmptyMonad

Fields

• unDualNonEmptyMonad :: m a

Instances

NonEmptyMonad m => Monad (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: DualNonEmptyMonad m a -> (a -> DualNonEmptyMonad m b) -> DualNonEmptyMonad m b

(>>) :: DualNonEmptyMonad m a -> DualNonEmptyMonad m b -> DualNonEmptyMonad m b

return :: a -> DualNonEmptyMonad m a

fail :: String -> DualNonEmptyMonad m a

Functor m => Functor (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> DualNonEmptyMonad m a -> DualNonEmptyMonad m b

(<$) :: a -> DualNonEmptyMonad m b -> DualNonEmptyMonad m a

NonEmptyMonad m => Applicative (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> DualNonEmptyMonad m a

(<*>) :: DualNonEmptyMonad m (a -> b) -> DualNonEmptyMonad m a -> DualNonEmptyMonad m b

liftA2 :: (a -> b -> c) -> DualNonEmptyMonad m a -> DualNonEmptyMonad m b -> DualNonEmptyMonad m c

(*>) :: DualNonEmptyMonad m a -> DualNonEmptyMonad m b -> DualNonEmptyMonad m b

(<*) :: DualNonEmptyMonad m a -> DualNonEmptyMonad m b -> DualNonEmptyMonad m a

HasShortFront m => HasShortRear (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortRear m => HasShortFront (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

NonEmptyMonad m => NonEmptyMonad (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> DualNonEmptyMonad m a

unwrap :: DualNonEmptyMonad m a -> NonEmpty a

Eq (m a) => Eq (DualNonEmptyMonad m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: DualNonEmptyMonad m a -> DualNonEmptyMonad m a -> Bool

(/=) :: DualNonEmptyMonad m a -> DualNonEmptyMonad m a -> Bool

Show (m a) => Show (DualNonEmptyMonad m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> DualNonEmptyMonad m a -> ShowS

show :: DualNonEmptyMonad m a -> String

showList :: [DualNonEmptyMonad m a] -> ShowS

IsNonEmpty (m a) => IsNonEmpty (DualNonEmptyMonad m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (DualNonEmptyMonad m a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (DualNonEmptyMonad m a)) -> DualNonEmptyMonad m a

toNonEmpty :: DualNonEmptyMonad m a -> NonEmpty (ItemNE (DualNonEmptyMonad m a))

type ItemNE (DualNonEmptyMonad m a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (DualNonEmptyMonad m a) = ItemNE (m a)

The Identity ⨉ List monad

data IdXList m a

NonEmpty a is isomorphic to the product (a, [a]). Thus, we can define a monadic structure on it by a product of the identity monad with any list monad. In particular:

return x          = IdXList x (return x)
IdXList x m >>= f = IdXList (componentId $ f x) (m >>= componentM . f)

where return and >>= in definition bodies come from the transformed monad.

Constructors

IdXList

Fields

• componentId :: a
• componentM :: m a

Instances

ListMonad m => Monad (IdXList m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: IdXList m a -> (a -> IdXList m b) -> IdXList m b

(>>) :: IdXList m a -> IdXList m b -> IdXList m b

return :: a -> IdXList m a

fail :: String -> IdXList m a

Functor m => Functor (IdXList m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> IdXList m a -> IdXList m b

(<$) :: a -> IdXList m b -> IdXList m a

ListMonad m => Applicative (IdXList m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> IdXList m a

(<*>) :: IdXList m (a -> b) -> IdXList m a -> IdXList m b

liftA2 :: (a -> b -> c) -> IdXList m a -> IdXList m b -> IdXList m c

(*>) :: IdXList m a -> IdXList m b -> IdXList m b

(<*) :: IdXList m a -> IdXList m b -> IdXList m a

ListMonad m => NonEmptyMonad (IdXList m)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> IdXList m a

unwrap :: IdXList m a -> NonEmpty a

(Eq a, Eq (m a)) => Eq (IdXList m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: IdXList m a -> IdXList m a -> Bool

(/=) :: IdXList m a -> IdXList m a -> Bool

(Show a, Show (m a)) => Show (IdXList m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> IdXList m a -> ShowS

show :: IdXList m a -> String

showList :: [IdXList m a] -> ShowS

ListMonad m => IsNonEmpty (IdXList m a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (IdXList m a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (IdXList m a)) -> IdXList m a

toNonEmpty :: IdXList m a -> NonEmpty (ItemNE (IdXList m a))

type ItemNE (IdXList m a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (IdXList m a) = a

Short-front monads

class NonEmptyMonad m => HasShortFront m

Instances of this class are non-empty list monads for which the ShortFront construction gives a monad.

Instances

HasShortFront NonEmpty

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortFront AlphaOmega

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortFront MazeWalkNE

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortFront OpDiscreteHybridNE

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortFront Keeper

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

KnownNat n => HasShortFront (StutterNE n)

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortRear m => HasShortFront (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

newtype ShortFront m (p :: Nat) a

This is a transformer for a number of monads (instances of the HasShortFront class), whose return is singleton and join takes the prefix of length p + 2 of the result of the join of the transformed monad (unless the unit laws require otherwise):

joinList xss | isSingle xss || all isSingle xss = concat xss
             | otherwise = take (p + 2) (joinList xss)

where joinList in the otherwise branch is the joinList of the transformed monad.

While there are quite a few "short front" monads on non-empty lists, only one such monad on possibly-empty lists is known, StutterKeeper (the short version is ShortStutterKeeper).

Constructors

ShortFront

Fields

• unShortFront :: m a

Instances

(HasShortFront m, KnownNat p) => Monad (ShortFront m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: ShortFront m p a -> (a -> ShortFront m p b) -> ShortFront m p b

(>>) :: ShortFront m p a -> ShortFront m p b -> ShortFront m p b

return :: a -> ShortFront m p a

fail :: String -> ShortFront m p a

Functor m => Functor (ShortFront m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> ShortFront m p a -> ShortFront m p b

(<$) :: a -> ShortFront m p b -> ShortFront m p a

(HasShortFront m, KnownNat p) => Applicative (ShortFront m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> ShortFront m p a

(<*>) :: ShortFront m p (a -> b) -> ShortFront m p a -> ShortFront m p b

liftA2 :: (a -> b -> c) -> ShortFront m p a -> ShortFront m p b -> ShortFront m p c

(*>) :: ShortFront m p a -> ShortFront m p b -> ShortFront m p b

(<*) :: ShortFront m p a -> ShortFront m p b -> ShortFront m p a

(HasShortFront m, KnownNat p) => NonEmptyMonad (ShortFront m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> ShortFront m p a

unwrap :: ShortFront m p a -> NonEmpty a

Eq (m a) => Eq (ShortFront m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: ShortFront m p a -> ShortFront m p a -> Bool

(/=) :: ShortFront m p a -> ShortFront m p a -> Bool

Show (m a) => Show (ShortFront m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> ShortFront m p a -> ShowS

show :: ShortFront m p a -> String

showList :: [ShortFront m p a] -> ShowS

(IsNonEmpty (m a), KnownNat p) => IsNonEmpty (ShortFront m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (ShortFront m p a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (ShortFront m p a)) -> ShortFront m p a

toNonEmpty :: ShortFront m p a -> NonEmpty (ItemNE (ShortFront m p a))

type ItemNE (ShortFront m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (ShortFront m p a) = ItemNE (m a)

Short-rear monads

class NonEmptyMonad m => HasShortRear m

Instances of this class are non-empty list monads for which the ShortRear construction gives a monad.

Instances

HasShortRear NonEmpty

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortRear AlphaOmega

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortRear DiscreteHybridNE

(?)

Defined in Control.Monad.List.NonEmpty.Exotic

HasShortFront m => HasShortRear (DualNonEmptyMonad m)

Defined in Control.Monad.List.NonEmpty.Exotic

newtype ShortRear m (p :: Nat) a

Similar to ShortFront, but gives a monad if restricted to a suffix of the length p + 2.

Constructors

ShortRear

Fields

• unShortRear :: m a

Instances

(HasShortRear m, KnownNat p) => Monad (ShortRear m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(>>=) :: ShortRear m p a -> (a -> ShortRear m p b) -> ShortRear m p b

(>>) :: ShortRear m p a -> ShortRear m p b -> ShortRear m p b

return :: a -> ShortRear m p a

fail :: String -> ShortRear m p a

Functor m => Functor (ShortRear m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

fmap :: (a -> b) -> ShortRear m p a -> ShortRear m p b

(<$) :: a -> ShortRear m p b -> ShortRear m p a

(HasShortRear m, KnownNat p) => Applicative (ShortRear m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

pure :: a -> ShortRear m p a

(<*>) :: ShortRear m p (a -> b) -> ShortRear m p a -> ShortRear m p b

liftA2 :: (a -> b -> c) -> ShortRear m p a -> ShortRear m p b -> ShortRear m p c

(*>) :: ShortRear m p a -> ShortRear m p b -> ShortRear m p b

(<*) :: ShortRear m p a -> ShortRear m p b -> ShortRear m p a

(HasShortRear m, KnownNat p) => NonEmptyMonad (ShortRear m p)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

wrap :: NonEmpty a -> ShortRear m p a

unwrap :: ShortRear m p a -> NonEmpty a

Eq (m a) => Eq (ShortRear m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

(==) :: ShortRear m p a -> ShortRear m p a -> Bool

(/=) :: ShortRear m p a -> ShortRear m p a -> Bool

Show (m a) => Show (ShortRear m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Methods

showsPrec :: Int -> ShortRear m p a -> ShowS

show :: ShortRear m p a -> String

showList :: [ShortRear m p a] -> ShowS

(IsNonEmpty (m a), KnownNat p) => IsNonEmpty (ShortRear m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

Associated Types

type ItemNE (ShortRear m p a) :: Type

Methods

fromNonEmpty :: NonEmpty (ItemNE (ShortRear m p a)) -> ShortRear m p a

toNonEmpty :: ShortRear m p a -> NonEmpty (ItemNE (ShortRear m p a))

type ItemNE (ShortRear m p a)

Defined in Control.Monad.List.NonEmpty.Exotic

type ItemNE (ShortRear m p a) = ItemNE (m a)