Data.Separated

Data types

newtype Separated a b

A list of pairs of separator and value. Separated by a in values b. There are an even number of separators as there are values.

Constructors

Separated [(a, b)]

Instances

Bifunctor Separated

Methods

bimap :: (a -> b) -> (c -> d) -> Separated a c -> Separated b d

first :: (a -> b) -> Separated a c -> Separated b c

second :: (b -> c) -> Separated a b -> Separated a c

Bitraversable Separated

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Separated a b -> f (Separated c d)

Bifoldable Separated

Methods

bifold :: Monoid m => Separated m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Separated a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Separated a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Separated a b -> c

Swapped Separated

The isomorphism that swaps elements with their separators.

>>> swapped # emptySeparated
[]

>>> swapped # ('x' +: 6 +: emptySeparated)
[6,'x']

>>> emptySeparated ^. swapped
[]

>>> ('x' +: 6 +: emptySeparated) ^. swapped
[6,'x']

Methods

swapped :: (Profunctor p, Functor f) => p (Separated b a) (f (Separated d c)) -> p (Separated a b) (f (Separated c d))

Construct Separated

One element and one separator.

>>> (7 +- "abc") :: Separated Int String
[7,"abc"]

>>> 7 +: "abc" +: (8 +- "def") :: Separated Int String
[7,"abc",8,"def"]

Methods

(+-) :: s -> a -> Separated s a

(-+) :: s -> a -> Separated a s

empty :: Separated s a

sprinkle :: s -> [a] -> Separated s a

SeparatedCons Separated1 Separated

Associated Types

type SeparatedConsF (Separated :: * -> * -> *) :: * -> * -> *

type SeparatedConsG (Separated1 :: * -> * -> *) :: * -> * -> *

Methods

(+:) :: a -> Separated1 b a -> Separated a b

SeparatedCons Separated Separated1

Associated Types

type SeparatedConsF (Separated1 :: * -> * -> *) :: * -> * -> *

type SeparatedConsG (Separated :: * -> * -> *) :: * -> * -> *

Methods

(+:) :: a -> Separated b a -> Separated1 a b

Functor (Separated a)

Map across a Separated on the element values.

fmap id (x :: Separated Int String) == x

\a b -> fmap (+1) (a +: b +: emptySeparated) == a +: (1+b) +: emptySeparated

Methods

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

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

Monoid a => Applicative (Separated a)

Applies functions with element values, using a zipping operation, appending separators. The identity operation is an infinite list of the emptySeparated separator and the given element value.

>>> (emptySeparated :: Separated [Int] (String -> [String])) <*> emptySeparated
[]

>>> [1,2] +: (\s -> [s, reverse s, drop 1 s]) +: emptySeparated <*> [3,4,5] +: "abc" +: emptySeparated
[[1,2,3,4,5],["abc","cba","bc"]]

Methods

pure :: a -> Separated a a

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

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

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

Foldable (Separated a)

Methods

fold :: Monoid m => Separated a m -> m

foldMap :: Monoid m => (a -> m) -> Separated a a -> m

foldr :: (a -> b -> b) -> b -> Separated a a -> b

foldr' :: (a -> b -> b) -> b -> Separated a a -> b

foldl :: (b -> a -> b) -> b -> Separated a a -> b

foldl' :: (b -> a -> b) -> b -> Separated a a -> b

foldr1 :: (a -> a -> a) -> Separated a a -> a

foldl1 :: (a -> a -> a) -> Separated a a -> a

toList :: Separated a a -> [a]

null :: Separated a a -> Bool

length :: Separated a a -> Int

elem :: Eq a => a -> Separated a a -> Bool

maximum :: Ord a => Separated a a -> a

minimum :: Ord a => Separated a a -> a

sum :: Num a => Separated a a -> a

product :: Num a => Separated a a -> a

Traversable (Separated a)

Methods

traverse :: Applicative f => (a -> f b) -> Separated a a -> f (Separated a b)

sequenceA :: Applicative f => Separated a (f a) -> f (Separated a a)

mapM :: Monad m => (a -> m b) -> Separated a a -> m (Separated a b)

sequence :: Monad m => Separated a (m a) -> m (Separated a a)

Semigroup a => Apply (Separated a)

Applies functions with element values, using a zipping operation, appending separators.

>>> (emptySeparated :: Separated [Int] (String -> [String])) <.> emptySeparated
[]

>>> [1,2] +: (\s -> [s, reverse s, drop 1 s]) +: emptySeparated <.> [3,4,5] +: "abc" +: emptySeparated
[[1,2,3,4,5],["abc","cba","bc"]]

Methods

(<.>) :: Separated a (a -> b) -> Separated a a -> Separated a b

(.>) :: Separated a a -> Separated a b -> Separated a b

(<.) :: Separated a a -> Separated a b -> Separated a a

(Eq b, Eq a) => Eq (Separated a b)

Methods

(==) :: Separated a b -> Separated a b -> Bool

(/=) :: Separated a b -> Separated a b -> Bool

(Ord b, Ord a) => Ord (Separated a b)

Methods

compare :: Separated a b -> Separated a b -> Ordering

(<) :: Separated a b -> Separated a b -> Bool

(<=) :: Separated a b -> Separated a b -> Bool

(>) :: Separated a b -> Separated a b -> Bool

(>=) :: Separated a b -> Separated a b -> Bool

max :: Separated a b -> Separated a b -> Separated a b

min :: Separated a b -> Separated a b -> Separated a b

(Show a, Show b) => Show (Separated a b)

>>> show (emptySeparated :: Separated () ())
"[]"

>>> show ('x' +: (6 :: Int) +: emptySeparated)
"['x',6]"

Methods

showsPrec :: Int -> Separated a b -> ShowS

show :: Separated a b -> String

showList :: [Separated a b] -> ShowS

Semigroup (Separated a b)

>>> ('x' +: (6 :: Int) +: emptySeparated) <> ('y' +: 7 +: emptySeparated)
['x',6,'y',7]

Methods

(<>) :: Separated a b -> Separated a b -> Separated a b

sconcat :: NonEmpty (Separated a b) -> Separated a b

stimes :: Integral b => b -> Separated a b -> Separated a b

Monoid (Separated a b)

>>> ('x' +: (6 :: Int) +: emptySeparated) `mappend` ('y' +: 7 +: emptySeparated)
['x',6,'y',7]

Methods

mempty :: Separated a b

mappend :: Separated a b -> Separated a b -> Separated a b

mconcat :: [Separated a b] -> Separated a b

Wrapped (Separated a0 b0)

Associated Types

type Unwrapped (Separated a0 b0) :: *

Methods

_Wrapped' :: Iso' (Separated a0 b0) (Unwrapped (Separated a0 b0))

(~) * (Separated a0 b0) t0 => Rewrapped (Separated a1 b1) t0

Appends (Separated1 a s) (Separated s a) (Separated1 a s)

Append a list of pairs of separator and element values to element values interspersed with a separator.

>>> (singleSeparated 7 :: Separated1 Int Char) <++> (emptySeparated :: Separated Char Int)
[7]

>>> (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int)
[6,'x',7]

>>> 'w' +: (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int)
['w',6,'x',7]

Methods

(<++>) :: Separated1 a s -> Separated s a -> Separated1 a s

Appends (Separated1 s a) (Separated1 a s) (Separated s a)

Append two lists of separated values to produce a list of pairs of separator and element values.

>>> (singleSeparated 7 :: Separated1 Int Char) <++> (singleSeparated 'a' :: Separated1 Char Int)
[7,'a']

a +: (singleSeparated 7 :: Separated1 Int Char) ++ (singleSeparated b :: Separated1 Char Int) [a,7,b]

a +: (b :: Separated Int Int) == a +: b --  (a +: (b <++> c)) == ((a +: b) <++> c)

Methods

(<++>) :: Separated1 s a -> Separated1 a s -> Separated s a

Appends (Separated s a) (Separated1 s a) (Separated1 s a)

Append element values interspersed with a separator to a list of pairs of separator and element values.

>>> (emptySeparated :: Separated Int Char) <++> (singleSeparated 7 :: Separated1 Int Char)
[7]

>>> (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char)
[6,'x',7]

>>> 'w' +: (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char)
['w',6,'x',7]

Methods

(<++>) :: Separated s a -> Separated1 s a -> Separated1 s a

HasTail (Separated1 a s) (Separated1 a t) (Separated s a) (Separated t a)

A lens on the tail.

(d +: e +: (singleSeparated x :: Separated1 Int Char)) ^. tailL == e +: x +: emptySeparated

Methods

tailL :: Lens (Separated1 a s) (Separated1 a t) (Separated s a) (Separated t a)

type SeparatedConsF Separated

type SeparatedConsF Separated = Separated1

type SeparatedConsG Separated

type SeparatedConsG Separated = Separated1

type Unwrapped (Separated a0 b0)

type Unwrapped (Separated a0 b0) = [(a0, b0)]

data Separated1 b a

A list of pairs of separator and value. Separated by a in values b. There is one more value than there are separators.

Constructors

Separated1 b (Separated a b)

Instances

Bifunctor Separated1

Methods

bimap :: (a -> b) -> (c -> d) -> Separated1 a c -> Separated1 b d

first :: (a -> b) -> Separated1 a c -> Separated1 b c

second :: (b -> c) -> Separated1 a b -> Separated1 a c

Bitraversable Separated1

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Separated1 a b -> f (Separated1 c d)

Bifoldable Separated1

Methods

bifold :: Monoid m => Separated1 m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Separated1 a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Separated1 a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Separated1 a b -> c

Separated1Single Separated1

Zero element values interspersed with one element.

>>> (singleSeparated 4 :: Separated1 Int Char)
[4]

(singleSeparated x  :: Separated1 Int Char) ^. tailL == emptySeparated

Methods

singleSeparated :: a -> Separated1 a s

SeparatedCons Separated1 Separated

Associated Types

type SeparatedConsF (Separated :: * -> * -> *) :: * -> * -> *

type SeparatedConsG (Separated1 :: * -> * -> *) :: * -> * -> *

Methods

(+:) :: a -> Separated1 b a -> Separated a b

SeparatedCons Separated Separated1

Associated Types

type SeparatedConsF (Separated1 :: * -> * -> *) :: * -> * -> *

type SeparatedConsG (Separated :: * -> * -> *) :: * -> * -> *

Methods

(+:) :: a -> Separated b a -> Separated1 a b

Functor (Separated1 b)

Map across a Separated1 on the separator values.

>>> fmap (+1) (set tailL (1 +: 'b' +: 2 +: 'c' +: emptySeparated) (singleSeparated 'a' :: Separated1 Char Int))
['a',2,'b',3,'c']

fmap id (x :: Separated1 Int String) == x

fmap (+1) (singleSeparated x :: Separated1 Char Int) == singleSeparated x

Methods

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

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

Monoid b => Applicative (Separated1 b)

Applies functions with separator values, using a zipping operation, appending elements. The identity operation is an infinite list of the emptySeparated element and the given separator value.

>>> [1,2] +: reverse +: [3,4] +: emptySeparated <*> [5,6,7] +: "abc" +: [8] +: emptySeparated
[[1,2,5,6,7],"cba",[3,4,8]]

Methods

pure :: a -> Separated1 b a

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

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

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

Foldable (Separated1 b)

Methods

fold :: Monoid m => Separated1 b m -> m

foldMap :: Monoid m => (a -> m) -> Separated1 b a -> m

foldr :: (a -> b -> b) -> b -> Separated1 b a -> b

foldr' :: (a -> b -> b) -> b -> Separated1 b a -> b

foldl :: (b -> a -> b) -> b -> Separated1 b a -> b

foldl' :: (b -> a -> b) -> b -> Separated1 b a -> b

foldr1 :: (a -> a -> a) -> Separated1 b a -> a

foldl1 :: (a -> a -> a) -> Separated1 b a -> a

toList :: Separated1 b a -> [a]

null :: Separated1 b a -> Bool

length :: Separated1 b a -> Int

elem :: Eq a => a -> Separated1 b a -> Bool

maximum :: Ord a => Separated1 b a -> a

minimum :: Ord a => Separated1 b a -> a

sum :: Num a => Separated1 b a -> a

product :: Num a => Separated1 b a -> a

Traversable (Separated1 b)

Methods

traverse :: Applicative f => (a -> f b) -> Separated1 b a -> f (Separated1 b b)

sequenceA :: Applicative f => Separated1 b (f a) -> f (Separated1 b a)

mapM :: Monad m => (a -> m b) -> Separated1 b a -> m (Separated1 b b)

sequence :: Monad m => Separated1 b (m a) -> m (Separated1 b a)

Semigroup b => Apply (Separated1 b)

Applies functions with separator values, using a zipping operation, appending elements.

>>> [1,2] +: reverse +: [3,4] +: emptySeparated <.> [5,6,7] +: "abc" +: [8] +: emptySeparated
[[1,2,5,6,7],"cba",[3,4,8]]

Methods

(<.>) :: Separated1 b (a -> b) -> Separated1 b a -> Separated1 b b

(.>) :: Separated1 b a -> Separated1 b b -> Separated1 b b

(<.) :: Separated1 b a -> Separated1 b b -> Separated1 b a

(Eq a, Eq b) => Eq (Separated1 b a)

Methods

(==) :: Separated1 b a -> Separated1 b a -> Bool

(/=) :: Separated1 b a -> Separated1 b a -> Bool

(Ord a, Ord b) => Ord (Separated1 b a)

Methods

compare :: Separated1 b a -> Separated1 b a -> Ordering

(<) :: Separated1 b a -> Separated1 b a -> Bool

(<=) :: Separated1 b a -> Separated1 b a -> Bool

(>) :: Separated1 b a -> Separated1 b a -> Bool

(>=) :: Separated1 b a -> Separated1 b a -> Bool

max :: Separated1 b a -> Separated1 b a -> Separated1 b a

min :: Separated1 b a -> Separated1 b a -> Separated1 b a

(Show b, Show a) => Show (Separated1 b a)

Methods

showsPrec :: Int -> Separated1 b a -> ShowS

show :: Separated1 b a -> String

showList :: [Separated1 b a] -> ShowS

HasHead (Separated1 a t) (Separated1 a t) a a

A lens on the first element value.

>>> (singleSeparated 7 :: Separated1 Int Char) ^. headL
7

(singleSeparated x :: Separated1 Int Char) ^. headL == (x :: Int)

Methods

headL :: Lens (Separated1 a t) (Separated1 a t) a a

Appends (Separated1 a s) (Separated s a) (Separated1 a s)

Append a list of pairs of separator and element values to element values interspersed with a separator.

>>> (singleSeparated 7 :: Separated1 Int Char) <++> (emptySeparated :: Separated Char Int)
[7]

>>> (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int)
[6,'x',7]

>>> 'w' +: (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int)
['w',6,'x',7]

Methods

(<++>) :: Separated1 a s -> Separated s a -> Separated1 a s

Appends (Separated1 s a) (Separated1 a s) (Separated s a)

Append two lists of separated values to produce a list of pairs of separator and element values.

>>> (singleSeparated 7 :: Separated1 Int Char) <++> (singleSeparated 'a' :: Separated1 Char Int)
[7,'a']

a +: (singleSeparated 7 :: Separated1 Int Char) ++ (singleSeparated b :: Separated1 Char Int) [a,7,b]

a +: (b :: Separated Int Int) == a +: b --  (a +: (b <++> c)) == ((a +: b) <++> c)

Methods

(<++>) :: Separated1 s a -> Separated1 a s -> Separated s a

Appends (Separated s a) (Separated1 s a) (Separated1 s a)

Append element values interspersed with a separator to a list of pairs of separator and element values.

>>> (emptySeparated :: Separated Int Char) <++> (singleSeparated 7 :: Separated1 Int Char)
[7]

>>> (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char)
[6,'x',7]

>>> 'w' +: (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char)
['w',6,'x',7]

Methods

(<++>) :: Separated s a -> Separated1 s a -> Separated1 s a

HasTail (Separated1 a s) (Separated1 a t) (Separated s a) (Separated t a)

A lens on the tail.

(d +: e +: (singleSeparated x :: Separated1 Int Char)) ^. tailL == e +: x +: emptySeparated

Methods

tailL :: Lens (Separated1 a s) (Separated1 a t) (Separated s a) (Separated t a)

type SeparatedConsF Separated1

type SeparatedConsF Separated1 = Separated

type SeparatedConsG Separated1

type SeparatedConsG Separated1 = Separated

newtype Pesarated b a

The Separated type constructor, flipped.

Constructors

Pesarated (Separated a b)

Instances

Bifunctor Pesarated

Methods

bimap :: (a -> b) -> (c -> d) -> Pesarated a c -> Pesarated b d

first :: (a -> b) -> Pesarated a c -> Pesarated b c

second :: (b -> c) -> Pesarated a b -> Pesarated a c

Bitraversable Pesarated

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Pesarated a b -> f (Pesarated c d)

Bifoldable Pesarated

Methods

bifold :: Monoid m => Pesarated m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Pesarated a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Pesarated a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Pesarated a b -> c

Swapped Pesarated

The isomorphism that swaps elements with their separators.

>>> swapped # emptyPesarated
[]

>>> swapped # ('x' -: 6 -: emptyPesarated)
[6,'x']

>>> emptyPesarated ^. swapped
[]

>>> ('x' -: 6 -: emptyPesarated) ^. swapped
[6,'x']

Methods

swapped :: (Profunctor p, Functor f) => p (Pesarated b a) (f (Pesarated d c)) -> p (Pesarated a b) (f (Pesarated c d))

Construct Pesarated

One element and one separator.

>>> (7 -+ "abc") :: Pesarated String Int
[7,"abc"]

>>> 7 -: "abc" -: (8 -+ "def") :: Pesarated String Int
[7,"abc",8,"def"]

Methods

(+-) :: s -> a -> Pesarated s a

(-+) :: s -> a -> Pesarated a s

empty :: Pesarated s a

sprinkle :: s -> [a] -> Pesarated s a

PesaratedCons Pesarated1 Pesarated

Associated Types

type PesaratedConsF (Pesarated :: * -> * -> *) :: * -> * -> *

type PesaratedConsG (Pesarated1 :: * -> * -> *) :: * -> * -> *

Methods

(-:) :: b -> Pesarated1 b a -> Pesarated a b

PesaratedCons Pesarated Pesarated1

Associated Types

type PesaratedConsF (Pesarated1 :: * -> * -> *) :: * -> * -> *

type PesaratedConsG (Pesarated :: * -> * -> *) :: * -> * -> *

Methods

(-:) :: b -> Pesarated b a -> Pesarated1 a b

Functor (Pesarated a)

Map across a Pesarated on the element values.

fmap id (x :: Pesarated Int String) == x

\a b -> fmap (+1) (a -: b -: emptyPesarated) == (1+a) -: b -: emptyPesarated

Methods

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

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

Monoid a => Applicative (Pesarated a)

Applies functions with element values, using a zipping operation, appending separators. The identity operation is an infinite list of the emptySeparated separator and the given element value.

>>> (emptySeparated :: Separated [Int] (String -> [String])) <*> emptySeparated
[]

>>> (\s -> [s, reverse s, drop 1 s]) -: [1,2] -: emptyPesarated <*> "abc" -: [3,4,5] -: emptyPesarated
[["abc","cba","bc"],[1,2,3,4,5]]

Methods

pure :: a -> Pesarated a a

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

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

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

Foldable (Pesarated b)

Methods

fold :: Monoid m => Pesarated b m -> m

foldMap :: Monoid m => (a -> m) -> Pesarated b a -> m

foldr :: (a -> b -> b) -> b -> Pesarated b a -> b

foldr' :: (a -> b -> b) -> b -> Pesarated b a -> b

foldl :: (b -> a -> b) -> b -> Pesarated b a -> b

foldl' :: (b -> a -> b) -> b -> Pesarated b a -> b

foldr1 :: (a -> a -> a) -> Pesarated b a -> a

foldl1 :: (a -> a -> a) -> Pesarated b a -> a

toList :: Pesarated b a -> [a]

null :: Pesarated b a -> Bool

length :: Pesarated b a -> Int

elem :: Eq a => a -> Pesarated b a -> Bool

maximum :: Ord a => Pesarated b a -> a

minimum :: Ord a => Pesarated b a -> a

sum :: Num a => Pesarated b a -> a

product :: Num a => Pesarated b a -> a

Traversable (Pesarated b)

Methods

traverse :: Applicative f => (a -> f b) -> Pesarated b a -> f (Pesarated b b)

sequenceA :: Applicative f => Pesarated b (f a) -> f (Pesarated b a)

mapM :: Monad m => (a -> m b) -> Pesarated b a -> m (Pesarated b b)

sequence :: Monad m => Pesarated b (m a) -> m (Pesarated b a)

Semigroup a => Apply (Pesarated a)

Applies functions with element values, using a zipping operation, appending separators.

>>> (emptyPesarated :: Pesarated [Int] (String -> [String])) <.> emptyPesarated
[]

>>> (\s -> [s, reverse s, drop 1 s]) -: [1,2] -: emptyPesarated <.> "abc" -: [3,4,5] -: emptyPesarated
[["abc","cba","bc"],[1,2,3,4,5]]

Methods

(<.>) :: Pesarated a (a -> b) -> Pesarated a a -> Pesarated a b

(.>) :: Pesarated a a -> Pesarated a b -> Pesarated a b

(<.) :: Pesarated a a -> Pesarated a b -> Pesarated a a

(Eq a, Eq b) => Eq (Pesarated b a)

Methods

(==) :: Pesarated b a -> Pesarated b a -> Bool

(/=) :: Pesarated b a -> Pesarated b a -> Bool

(Ord a, Ord b) => Ord (Pesarated b a)

Methods

compare :: Pesarated b a -> Pesarated b a -> Ordering

(<) :: Pesarated b a -> Pesarated b a -> Bool

(<=) :: Pesarated b a -> Pesarated b a -> Bool

(>) :: Pesarated b a -> Pesarated b a -> Bool

(>=) :: Pesarated b a -> Pesarated b a -> Bool

max :: Pesarated b a -> Pesarated b a -> Pesarated b a

min :: Pesarated b a -> Pesarated b a -> Pesarated b a

(Show a, Show b) => Show (Pesarated b a)

>>> show (emptyPesarated :: Pesarated () ())
"[]"

>>> show ('x' -: (6 :: Int) -: emptyPesarated)
"['x',6]"

Methods

showsPrec :: Int -> Pesarated b a -> ShowS

show :: Pesarated b a -> String

showList :: [Pesarated b a] -> ShowS

Semigroup (Pesarated b a)

>>> ('x' -: (6 :: Int) -: emptyPesarated) <> ('y' -: 7 -: emptyPesarated)
['x',6,'y',7]

Methods

(<>) :: Pesarated b a -> Pesarated b a -> Pesarated b a

sconcat :: NonEmpty (Pesarated b a) -> Pesarated b a

stimes :: Integral b => b -> Pesarated b a -> Pesarated b a

Monoid (Pesarated b a)

>>> ('x' -: (6 :: Int) -: emptyPesarated) `mappend` ('y' -: 7 -: emptyPesarated)
['x',6,'y',7]

Methods

mempty :: Pesarated b a

mappend :: Pesarated b a -> Pesarated b a -> Pesarated b a

mconcat :: [Pesarated b a] -> Pesarated b a

Wrapped (Pesarated b0 a0)

Associated Types

type Unwrapped (Pesarated b0 a0) :: *

Methods

_Wrapped' :: Iso' (Pesarated b0 a0) (Unwrapped (Pesarated b0 a0))

(~) * (Pesarated b0 a0) t0 => Rewrapped (Pesarated b1 a1) t0

HasTail (Pesarated1 a s) (Pesarated1 b s) (Pesarated s a) (Pesarated s b)

A lens on the tail.

(d -: e -: (singlePesarated x :: Pesarated1 Char Int)) ^. tailL == e -: x -: emptyPesarated

Methods

tailL :: Lens (Pesarated1 a s) (Pesarated1 b s) (Pesarated s a) (Pesarated s b)

type PesaratedConsF Pesarated

type PesaratedConsF Pesarated = Pesarated1

type PesaratedConsG Pesarated

type PesaratedConsG Pesarated = Pesarated1

type Unwrapped (Pesarated b0 a0)

type Unwrapped (Pesarated b0 a0) = Separated a0 b0

newtype Pesarated1 a b

The Separated1 type constructor, flipped.

Constructors

Pesarated1 (Separated1 b a)

Instances

Bifunctor Pesarated1

Methods

bimap :: (a -> b) -> (c -> d) -> Pesarated1 a c -> Pesarated1 b d

first :: (a -> b) -> Pesarated1 a c -> Pesarated1 b c

second :: (b -> c) -> Pesarated1 a b -> Pesarated1 a c

Bitraversable Pesarated1

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Pesarated1 a b -> f (Pesarated1 c d)

Bifoldable Pesarated1

Methods

bifold :: Monoid m => Pesarated1 m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Pesarated1 a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Pesarated1 a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Pesarated1 a b -> c

Pesarated1Single Pesarated1

Zero element values interspersed with one element.

>>> (singlePesarated 4 :: Pesarated1 Char Int)
[4]

(singlePesarated x  :: Pesarated1 Int Char) ^. tailL == emptyPesarated

Methods

singlePesarated :: a -> Pesarated1 s a

PesaratedCons Pesarated1 Pesarated

Associated Types

type PesaratedConsF (Pesarated :: * -> * -> *) :: * -> * -> *

type PesaratedConsG (Pesarated1 :: * -> * -> *) :: * -> * -> *

Methods

(-:) :: b -> Pesarated1 b a -> Pesarated a b

PesaratedCons Pesarated Pesarated1

Associated Types

type PesaratedConsF (Pesarated1 :: * -> * -> *) :: * -> * -> *

type PesaratedConsG (Pesarated :: * -> * -> *) :: * -> * -> *

Methods

(-:) :: b -> Pesarated b a -> Pesarated1 a b

Functor (Pesarated1 a)

Map across a Pesarated1 on the separator values.

>>> fmap toUpper (set tailL (1 -: 'b' -: 2 -: 'c' -: empty) (singlePesarated 'z' :: Pesarated1 Int Char) :: Pesarated1 Int Char)
['Z',1,'B',2,'C']

fmap id (x :: Pesarated1 Int String) == x

fmap (+1) (singlePesarated x :: Pesarated1 Char Int) == singlePesarated (x + 1)

Methods

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

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

Monoid a => Applicative (Pesarated1 a)

Applies functions with separator values, using a zipping operation, appending elements. The identity operation is an infinite list of the emptySeparated element and the given separator value.

>>> id -: [1,2] -: reverse -: [3,4] -: emptyPesarated <*> "def" -: [5,6,7] -: "abc" -: [8] -: emptyPesarated
["def",[1,2,5,6,7],"cba",[3,4,8]]

Methods

pure :: a -> Pesarated1 a a

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

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

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

Foldable (Pesarated1 a)

Methods

fold :: Monoid m => Pesarated1 a m -> m

foldMap :: Monoid m => (a -> m) -> Pesarated1 a a -> m

foldr :: (a -> b -> b) -> b -> Pesarated1 a a -> b

foldr' :: (a -> b -> b) -> b -> Pesarated1 a a -> b

foldl :: (b -> a -> b) -> b -> Pesarated1 a a -> b

foldl' :: (b -> a -> b) -> b -> Pesarated1 a a -> b

foldr1 :: (a -> a -> a) -> Pesarated1 a a -> a

foldl1 :: (a -> a -> a) -> Pesarated1 a a -> a

toList :: Pesarated1 a a -> [a]

null :: Pesarated1 a a -> Bool

length :: Pesarated1 a a -> Int

elem :: Eq a => a -> Pesarated1 a a -> Bool

maximum :: Ord a => Pesarated1 a a -> a

minimum :: Ord a => Pesarated1 a a -> a

sum :: Num a => Pesarated1 a a -> a

product :: Num a => Pesarated1 a a -> a

Traversable (Pesarated1 a)

Methods

traverse :: Applicative f => (a -> f b) -> Pesarated1 a a -> f (Pesarated1 a b)

sequenceA :: Applicative f => Pesarated1 a (f a) -> f (Pesarated1 a a)

mapM :: Monad m => (a -> m b) -> Pesarated1 a a -> m (Pesarated1 a b)

sequence :: Monad m => Pesarated1 a (m a) -> m (Pesarated1 a a)

Semigroup a => Apply (Pesarated1 a)

Applies functions with separator values, using a zipping operation, appending elements.

>>> id -: [1,2] -: reverse -: [3,4] -: emptyPesarated <.> "def" -: [5,6,7] -: "abc" -: [8] -: emptyPesarated
["def",[1,2,5,6,7],"cba",[3,4,8]]

Methods

(<.>) :: Pesarated1 a (a -> b) -> Pesarated1 a a -> Pesarated1 a b

(.>) :: Pesarated1 a a -> Pesarated1 a b -> Pesarated1 a b

(<.) :: Pesarated1 a a -> Pesarated1 a b -> Pesarated1 a a

(Eq b, Eq a) => Eq (Pesarated1 a b)

Methods

(==) :: Pesarated1 a b -> Pesarated1 a b -> Bool

(/=) :: Pesarated1 a b -> Pesarated1 a b -> Bool

(Ord b, Ord a) => Ord (Pesarated1 a b)

Methods

compare :: Pesarated1 a b -> Pesarated1 a b -> Ordering

(<) :: Pesarated1 a b -> Pesarated1 a b -> Bool

(<=) :: Pesarated1 a b -> Pesarated1 a b -> Bool

(>) :: Pesarated1 a b -> Pesarated1 a b -> Bool

(>=) :: Pesarated1 a b -> Pesarated1 a b -> Bool

max :: Pesarated1 a b -> Pesarated1 a b -> Pesarated1 a b

min :: Pesarated1 a b -> Pesarated1 a b -> Pesarated1 a b

(Show a, Show b) => Show (Pesarated1 a b)

Methods

showsPrec :: Int -> Pesarated1 a b -> ShowS

show :: Pesarated1 a b -> String

showList :: [Pesarated1 a b] -> ShowS

Wrapped (Pesarated1 a0 b0)

Associated Types

type Unwrapped (Pesarated1 a0 b0) :: *

Methods

_Wrapped' :: Iso' (Pesarated1 a0 b0) (Unwrapped (Pesarated1 a0 b0))

(~) * (Pesarated1 a0 b0) t0 => Rewrapped (Pesarated1 a1 b1) t0

HasHead (Pesarated1 a t) (Pesarated1 a t) t t

A lens on the first element value.

>>> (singlePesarated 7 :: Pesarated1 Char Int) ^. headL
7

(singlePesarated x :: Pesarated1 Char Int) ^. headL == (x :: Int)

Methods

headL :: Lens (Pesarated1 a t) (Pesarated1 a t) t t

HasTail (Pesarated1 a s) (Pesarated1 b s) (Pesarated s a) (Pesarated s b)

A lens on the tail.

(d -: e -: (singlePesarated x :: Pesarated1 Char Int)) ^. tailL == e -: x -: emptyPesarated

Methods

tailL :: Lens (Pesarated1 a s) (Pesarated1 b s) (Pesarated s a) (Pesarated s b)

type PesaratedConsF Pesarated1

type PesaratedConsF Pesarated1 = Pesarated

type PesaratedConsG Pesarated1

type PesaratedConsG Pesarated1 = Pesarated

type Unwrapped (Pesarated1 a0 b0)

type Unwrapped (Pesarated1 a0 b0) = Separated1 b0 a0

Iso

separated :: Iso [(a, b)] [(c, d)] (Separated a b) (Separated c d)

The isomorphism to a list of pairs of element and separator values.

>>> separated # emptySeparated
[]

>>> separated # ('x' +: 6 +: emptySeparated)
[('x',6)]

>>> [] ^. separated
[]

>>> [(6, [])] ^. separated
[6,[]]

separated1 :: Iso (a, Separated s a) (b, Separated t b) (Separated1 a s) (Separated1 b t)

The isomorphism to element values interspersed with a separator.

>>> separated1 # (singleSeparated 6)
(6,[])

>>> separated1 # (5 +: 'x' +: singleSeparated 6)
(5,['x',6])

>>> (6, emptySeparated) ^. separated1
[6]

>>> (5, 'x' +- 6) ^. separated1
[5,'x',6]

pesarated :: Iso [(a, b)] [(c, d)] (Pesarated b a) (Pesarated d c)

The isomorphism to element values interspersed with a separator.

>>> pesarated # emptyPesarated
[]

>>> ('a', 'x' +- 6) ^. pesarated1
['a',6,'x']

>>> ('x' -: 6 -: emptyPesarated)
['x',6]

pesarated1 :: Iso (a, Pesarated a s) (b, Pesarated b t) (Pesarated1 s a) (Pesarated1 t b)

The isomorphism to element values interspersed with a separator.

>>> pesarated1 # singlePesarated 6
(6,[])

>>> pesarated1 # (8 -: 'x' -: singlePesarated 6)
(8,['x',6])

>>> (6, empty) ^. pesarated1
[6]

>>> (5, 'x' -+ 6) ^. pesarated1
[5,'x',6]

Viewing

class HasHead s t a b | s -> a, t -> b, s b -> t, t a -> s where

Structures that have a head element.

Minimal complete definition

headL

Methods

headL :: Lens s t a b

Instances

HasHead (Pesarated1 a t) (Pesarated1 a t) t t

A lens on the first element value.

>>> (singlePesarated 7 :: Pesarated1 Char Int) ^. headL
7

(singlePesarated x :: Pesarated1 Char Int) ^. headL == (x :: Int)

Methods

headL :: Lens (Pesarated1 a t) (Pesarated1 a t) t t

HasHead (Separated1 a t) (Separated1 a t) a a

A lens on the first element value.

>>> (singleSeparated 7 :: Separated1 Int Char) ^. headL
7

(singleSeparated x :: Separated1 Int Char) ^. headL == (x :: Int)

Methods

headL :: Lens (Separated1 a t) (Separated1 a t) a a

class HasTail s t a b | s -> a, t -> b, s b -> t, t a -> s where

Structures that have a tail.

Minimal complete definition

tailL

Methods

tailL :: Lens s t a b

Instances

HasTail (Pesarated1 a s) (Pesarated1 b s) (Pesarated s a) (Pesarated s b)

A lens on the tail.

(d -: e -: (singlePesarated x :: Pesarated1 Char Int)) ^. tailL == e -: x -: emptyPesarated

Methods

tailL :: Lens (Pesarated1 a s) (Pesarated1 b s) (Pesarated s a) (Pesarated s b)

HasTail (Separated1 a s) (Separated1 a t) (Separated s a) (Separated t a)

A lens on the tail.

(d +: e +: (singleSeparated x :: Separated1 Int Char)) ^. tailL == e +: x +: emptySeparated

Methods

tailL :: Lens (Separated1 a s) (Separated1 a t) (Separated s a) (Separated t a)

Constructing

class Separated1Single f where

Construct a single separated value.

Minimal complete definition

singleSeparated

Methods

singleSeparated :: a -> f a s

Instances

Separated1Single Separated1

Zero element values interspersed with one element.

>>> (singleSeparated 4 :: Separated1 Int Char)
[4]

(singleSeparated x  :: Separated1 Int Char) ^. tailL == emptySeparated

Methods

singleSeparated :: a -> Separated1 a s

class Pesarated1Single f where

Minimal complete definition

singlePesarated

Methods

singlePesarated :: a -> f s a

Instances

Pesarated1Single Pesarated1

Zero element values interspersed with one element.

>>> (singlePesarated 4 :: Pesarated1 Char Int)
[4]

(singlePesarated x  :: Pesarated1 Int Char) ^. tailL == emptyPesarated

Methods

singlePesarated :: a -> Pesarated1 s a

class Construct f where

Construction of separated values.

Minimal complete definition

(+-), (-+), empty, sprinkle

Methods

(+-) :: s -> a -> f s a infixl 9

(-+) :: s -> a -> f a s

empty :: f s a

sprinkle :: s -> [a] -> f s a

Instances

Construct Pesarated

One element and one separator.

>>> (7 -+ "abc") :: Pesarated String Int
[7,"abc"]

>>> 7 -: "abc" -: (8 -+ "def") :: Pesarated String Int
[7,"abc",8,"def"]

Methods

(+-) :: s -> a -> Pesarated s a

(-+) :: s -> a -> Pesarated a s

empty :: Pesarated s a

sprinkle :: s -> [a] -> Pesarated s a

Construct Separated

One element and one separator.

>>> (7 +- "abc") :: Separated Int String
[7,"abc"]

>>> 7 +: "abc" +: (8 +- "def") :: Separated Int String
[7,"abc",8,"def"]

Methods

(+-) :: s -> a -> Separated s a

(-+) :: s -> a -> Separated a s

empty :: Separated s a

sprinkle :: s -> [a] -> Separated s a

class (f ~ SeparatedConsF g, g ~ SeparatedConsG f) => SeparatedCons f g where

Prepend a value to a separated-like structure.

Minimal complete definition

(+:)

Associated Types

type SeparatedConsF g :: * -> * -> *

type SeparatedConsG f :: * -> * -> *

Methods

(+:) :: a -> f b a -> g a b infixr 5

Instances

SeparatedCons Separated1 Separated

Associated Types

type SeparatedConsF (Separated :: * -> * -> *) :: * -> * -> *

type SeparatedConsG (Separated1 :: * -> * -> *) :: * -> * -> *

Methods

(+:) :: a -> Separated1 b a -> Separated a b

SeparatedCons Separated Separated1

Associated Types

type SeparatedConsF (Separated1 :: * -> * -> *) :: * -> * -> *

type SeparatedConsG (Separated :: * -> * -> *) :: * -> * -> *

Methods

(+:) :: a -> Separated b a -> Separated1 a b

class (f ~ PesaratedConsF g, g ~ PesaratedConsG f) => PesaratedCons f g where

Prepend a value to a separated-like structure.

Minimal complete definition

(-:)

Associated Types

type PesaratedConsF g :: * -> * -> *

type PesaratedConsG f :: * -> * -> *

Methods

(-:) :: b -> f b a -> g a b infixr 5

Instances

PesaratedCons Pesarated1 Pesarated

Associated Types

type PesaratedConsF (Pesarated :: * -> * -> *) :: * -> * -> *

type PesaratedConsG (Pesarated1 :: * -> * -> *) :: * -> * -> *

Methods

(-:) :: b -> Pesarated1 b a -> Pesarated a b

PesaratedCons Pesarated Pesarated1

Associated Types

type PesaratedConsF (Pesarated1 :: * -> * -> *) :: * -> * -> *

type PesaratedConsG (Pesarated :: * -> * -> *) :: * -> * -> *

Methods

(-:) :: b -> Pesarated b a -> Pesarated1 a b

Appending

class Appends a b c | a b -> c where

Append two to make one.

Minimal complete definition

(<++>)

Methods

(<++>) :: a -> b -> c infixr 5

Instances

Appends (Separated1 a s) (Separated s a) (Separated1 a s)

Append a list of pairs of separator and element values to element values interspersed with a separator.

>>> (singleSeparated 7 :: Separated1 Int Char) <++> (emptySeparated :: Separated Char Int)
[7]

>>> (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int)
[6,'x',7]

>>> 'w' +: (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int)
['w',6,'x',7]

Methods

(<++>) :: Separated1 a s -> Separated s a -> Separated1 a s

Appends (Separated1 s a) (Separated1 a s) (Separated s a)

Append two lists of separated values to produce a list of pairs of separator and element values.

>>> (singleSeparated 7 :: Separated1 Int Char) <++> (singleSeparated 'a' :: Separated1 Char Int)
[7,'a']

a +: (singleSeparated 7 :: Separated1 Int Char) ++ (singleSeparated b :: Separated1 Char Int) [a,7,b]

a +: (b :: Separated Int Int) == a +: b --  (a +: (b <++> c)) == ((a +: b) <++> c)

Methods

(<++>) :: Separated1 s a -> Separated1 a s -> Separated s a

Appends (Separated s a) (Separated1 s a) (Separated1 s a)

Append element values interspersed with a separator to a list of pairs of separator and element values.

>>> (emptySeparated :: Separated Int Char) <++> (singleSeparated 7 :: Separated1 Int Char)
[7]

>>> (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char)
[6,'x',7]

>>> 'w' +: (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char)
['w',6,'x',7]

Methods

(<++>) :: Separated s a -> Separated1 s a -> Separated1 s a

Alternating

separatedBy :: Alternative f => f a -> f b -> f (Separated a b)

Alternate separated values e.g. `f ~ Parser`.

>>> parse (separatedBy (char ',') digit) "test" ""
Right []

>>> isLeft (parse (separatedBy (char ',') digit) "test" ",")
True

>>> parse (separatedBy (char ',') digit) "test" ",1"
Right [',','1']

>>> isLeft (parse (separatedBy (char ',') digit) "test" ",1,")
True

>>> parse (separatedBy (char ',') digit) "test" ",1,2,3,4,5"
Right [',','1',',','2',',','3',',','4',',','5']

separatedBy1 :: Alternative f => f b -> f a -> f (Separated1 b a)

Alternate separated values e.g. `f ~ Parser`.

>>> isLeft (parse (separatedBy1 (char ',') digit) "test" "")
True

>>> parse (separatedBy1 (char ',') digit) "test" ","
Right [',']

>>> isLeft (parse (separatedBy1 (char ',') digit) "test" ",1")
True

>>> parse (separatedBy1 (char ',') digit) "test" ",1,"
Right [',','1',',']

>>> parse (separatedBy1 (char ',') digit) "test" ",1,2,3,4,5,"
Right [',','1',',','2',',','3',',','4',',','5',',']

pesaratedBy :: Alternative f => f a -> f b -> f (Pesarated b a)

Alternate separated values e.g. `f ~ Parser`.

>>> parse (pesaratedBy (char ',') digit) "test" ""
Right []

>>> isLeft (parse (pesaratedBy (char ',') digit) "test" ",")
True

>>> parse (separatedBy (char ',') digit) "test" ",1"
Right [',','1']

>>> isLeft (parse (pesaratedBy (char ',') digit) "test" ",1,")
True

>>> parse (pesaratedBy (char ',') digit) "test" ",1,2,3,4,5"
Right [',','1',',','2',',','3',',','4',',','5']

pesaratedBy1 :: Alternative f => f b -> f a -> f (Pesarated1 a b)

Alternate separated values e.g. `f ~ Parser`.

>>> isLeft (parse (pesaratedBy1 (char ',') digit) "test" "")
True

>>> parse (pesaratedBy1 (char ',') digit) "test" ","
Right [',']

>>> isLeft (parse (pesaratedBy1 (char ',') digit) "test" ",1")
True

>>> parse (pesaratedBy1 (char ',') digit) "test" ",1,"
Right [',','1',',']

>>> parse (pesaratedBy1 (char ',') digit) "test" ",1,2,3,4,5,"
Right [',','1',',','2',',','3',',','4',',','5',',']