Data.Separated.Separated

Documentation

data 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

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 +: empty) == a +: (1+b) +: empty

Methods

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

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

(Semigroup 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 empty separator and the given element value.

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

>>> [1,2] +: (\s -> [s, reverse s, drop 1 s]) +: empty <*> [3,4,5] +: "abc" +: empty
[[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

Semigroup a => Apply (Separated a)

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

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

>>> [1,2] +: (\s -> [s, reverse s, drop 1 s]) +: empty <.> [3,4,5] +: "abc" +: empty
[[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)

Methods

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

show :: Separated a b -> String

showList :: [Separated a b] -> ShowS

Semigroup (Separated a b)

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)

Methods

mempty :: Separated a b

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

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

type SeparatedConsF Separated

type SeparatedConsF Separated = Separated1

type SeparatedConsG Separated

type SeparatedConsG Separated = Separated1

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

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

>>> [] ^. separated
[]

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

data Separated1 b a

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

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 separated1Tail (1 +: 'b' +: 2 +: 'c' +: empty) (single 'a'))
['a',2,'b',3,'c']

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

fmap (+1) (single x) == single x

Methods

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

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

(Semigroup b, 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 empty element and the given separator value.

>>> [1,2] +: reverse +: [3,4] +: empty <*> [5,6,7] +: "abc" +: [8] +: empty
[[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

Semigroup b => Apply (Separated1 b)

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

>>> [1,2] +: reverse +: [3,4] +: empty <.> [5,6,7] +: "abc" +: [8] +: empty
[[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

type SeparatedConsF Separated1

type SeparatedConsF Separated1 = Separated

type SeparatedConsG Separated1

type SeparatedConsG Separated1 = Separated

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 # (single 6)
(6,[])

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

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

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

separated1Head :: Lens (Separated1 a t) (Separated1 a t) a a

A lens on the first element value.

>>> single 7 ^. separated1Head
7

single x ^. separated1Head == (x :: Int)

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

A lens on the tail.

(d +: e +: single x) ^. separated1Tail == e +: x +: empty

empty :: Separated s a

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

One element and one separator.

>>> 7 +- "abc"
[7,"abc"]

>>> 7 +: "abc" +: 8 +- "def"
[7,"abc",8,"def"]

single :: a -> Separated1 a s

Zero element values interspersed with one element.

>>> single 4
[4]

single x ^. separated1Tail == empty

shift :: Iso (Separated1 a s) (Separated1 b t) ([(a, s)], a) ([(b, t)], b)

The isomorphism that shuffles the elements and separators one position.

>>> shift # ([], 6)
[6]

>>> shift # ([(5, 'x')], 6)
[5,'x',6]

>>> single 6 ^. shift
([],6)

>>> (5 +: 'x' +: single 6) ^. shift
([(5,'x')],6)

separatedSwap :: Iso (Separated s a) (Separated t b) (Separated a s) (Separated b t)

The isomorphism that swaps elements with their separators.

>>> separatedSwap # empty
[]

>>> separatedSwap # ('x' +: 6 +: empty)
[6,'x']

>>> empty ^. separatedSwap
[]

>>> ('x' +: 6 +: empty) ^. separatedSwap
[6,'x']

(.++.) :: Separated1 s a -> Separated1 a s -> Separated s a infixr 5

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

>>> single 7 .++. single 'a'
[7,'a']

a +: single 7 .++. single b [a,7,b]

a +: (b :: Separated Int Int) == a +: b --  (a +: (b .++. c)) == ((a +: b) .++ c)

(++.) :: Separated s a -> Separated1 s a -> Separated1 s a infixr 5

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

>>> empty ++. single 7
[7]

>>> empty ++. 6 +: 'x' +: single 7
[6,'x',7]

>>> 'w' +: empty ++. 6 +: 'x' +: single 7
['w',6,'x',7]

(.++) :: Separated1 a s -> Separated s a -> Separated1 a s infixr 5

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

>>> single 7 .++ empty
[7]

>>> single 6 .++ 'x' +: 7 +: empty
[6,'x',7]

>>> 'w' +: single 6 .++ 'x' +: 7 +: empty
['w',6,'x',7]

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

>>> 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)

>>> 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',',']