!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None234 An s that comes before an aAn s that comes after an a s a is isomorphic to (s, a) s a is isomorphic to  a s  ==    f g ( s a) =   f s  g a  f g ( s a) = f s  g a s a is isomorphic to (a, s) s a is isomorphic to  a s  ==    f g ( a s) =   g a  f s  f g ( a s) = g a  f sNone234An a with an s on the left and a t on the rightAn a with an s on each side s t a is isomorphic to  (s, a, t) s a is isomorphic to  (s, a, s) s a is isomorphic to  s s a  f g ( s a s') =   f s  g a  f s'  f g ( s a s') = f s  g a  f s'       NoneNoneNone9:;<=?DLORT4!Append two to make one.#.Prepend a value to a separated-like structure.'.Prepend a value to a separated-like structure.+Generalised interspersion-!Construction of separated values.3#Construct a single separated value.5Structures that have a tail.7$Structures that have a head element.9The  Separated1 type constructor, flipped.;The  Separated type constructor, flipped.=5A list of pairs of separator and value. Separated by a in values b5. There is one more value than there are separators.?5A list of pairs of separator and value. Separated by a in values b>. There are an even number of separators as there are values.ACThe isomorphism to a list of pairs of element and separator values.separated # emptySeparated[](separated # ('x' +: 6 +: emptySeparated) [('x',6)][] ^. separated[][(6, [])] ^. separated[6,[]]B@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]C@The isomorphism to element values interspersed with a separator.pesarated # emptyPesarated[]('a', 'x' +- 6) ^. pesarated1 ['a',6,'x']('x' -: 6 -: emptyPesarated)['x',6]D@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]G-Alternate separated values e.g. `f ~ Parser`..parse (separatedBy (char ',') digit) "test" ""Right []8isLeft (parse (separatedBy (char ',') digit) "test" ",")True0parse (separatedBy (char ',') digit) "test" ",1"Right [',','1']:isLeft (parse (separatedBy (char ',') digit) "test" ",1,")True8parse (separatedBy (char ',') digit) "test" ",1,2,3,4,5"/Right [',','1',',','2',',','3',',','4',',','5']H-Alternate separated values e.g. `f ~ Parser`.8isLeft (parse (separatedBy1 (char ',') digit) "test" "")True0parse (separatedBy1 (char ',') digit) "test" "," Right [',']:isLeft (parse (separatedBy1 (char ',') digit) "test" ",1")True2parse (separatedBy1 (char ',') digit) "test" ",1,"Right [',','1',',']:parse (separatedBy1 (char ',') digit) "test" ",1,2,3,4,5,"3Right [',','1',',','2',',','3',',','4',',','5',',']I-Alternate separated values e.g. `f ~ Parser`..parse (pesaratedBy (char ',') digit) "test" ""Right []8isLeft (parse (pesaratedBy (char ',') digit) "test" ",")True0parse (separatedBy (char ',') digit) "test" ",1"Right [',','1']:isLeft (parse (pesaratedBy (char ',') digit) "test" ",1,")True8parse (pesaratedBy (char ',') digit) "test" ",1,2,3,4,5"/Right [',','1',',','2',',','3',',','4',',','5']J-Alternate separated values e.g. `f ~ Parser`.8isLeft (parse (pesaratedBy1 (char ',') digit) "test" "")True0parse (pesaratedBy1 (char ',') digit) "test" "," Right [',']:isLeft (parse (pesaratedBy1 (char ',') digit) "test" ",1")True2parse (pesaratedBy1 (char ',') digit) "test" ",1,"Right [',','1',',']:parse (pesaratedBy1 (char ',') digit) "test" ",1,2,3,4,5,"3Right [',','1',',','2',',','3',',','4',',','5',',']GThe isomorphism that shuffles the elements and separators one position.shift # ([], 6)[6]shift # ([(5, 'x')], 6) [5,'x',6]singleSeparated 6 ^. shift([],6)((5 +: 'x' +: singleSeparated 6) ^. shift ([(5,'x')],6)LApplies 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.hid -: [1,2] -: reverse -: [3,4] -: emptyPesarated <*> "def" -: [5,6,7] -: "abc" -: [8] -: emptyPesarated!["def",[1,2,5,6,7],"cba",[3,4,8]]MXApplies functions with separator values, using a zipping operation, appending elements.hid -: [1,2] -: reverse -: [3,4] -: emptyPesarated <.> "def" -: [5,6,7] -: "abc" -: [8] -: emptyPesarated!["def",[1,2,5,6,7],"cba",[3,4,8]]R 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) == xOfmap (+1) (singlePesarated x :: Pesarated1 Char Int) == singlePesarated (x + 1)VL('x' -: (6 :: Int) -: emptyPesarated) `mappend` ('y' -: 7 -: emptyPesarated) ['x',6,'y',7]WE('x' -: (6 :: Int) -: emptyPesarated) <> ('y' -: 7 -: emptyPesarated) ['x',6,'y',7]X(show (emptyPesarated :: Pesarated () ())"[]"*show ('x' -: (6 :: Int) -: emptyPesarated) "['x',6]"YApplies 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.K(emptySeparated :: Separated [Int] (String -> [String])) <*> emptySeparated[]b(\s -> [s, reverse s, drop 1 s]) -: [1,2] -: emptyPesarated <*> "abc" -: [3,4,5] -: emptyPesarated [["abc","cba","bc"],[1,2,3,4,5]]ZXApplies functions with element values, using a zipping operation, appending separators.K(emptyPesarated :: Pesarated [Int] (String -> [String])) <.> emptyPesarated[]b(\s -> [s, reverse s, drop 1 s]) -: [1,2] -: emptyPesarated <.> "abc" -: [3,4,5] -: emptyPesarated [["abc","cba","bc"],[1,2,3,4,5]]] Map across a  Pesarated on the element values.(fmap id (x :: Pesarated Int String) == xL\a b -> fmap (+1) (a -: b -: emptyPesarated) == (1+a) -: b -: emptyPesarateda:The isomorphism that swaps elements with their separators.swapped # emptyPesarated[]&swapped # ('x' -: 6 -: emptyPesarated)[6,'x']emptyPesarated ^. swapped[]'('x' -: 6 -: emptyPesarated) ^. swapped[6,'x']cApplies 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.Y[1,2] +: reverse +: [3,4] +: emptySeparated <*> [5,6,7] +: "abc" +: [8] +: emptySeparated[[1,2,5,6,7],"cba",[3,4,8]]dXApplies functions with separator values, using a zipping operation, appending elements.Y[1,2] +: reverse +: [3,4] +: emptySeparated <.> [5,6,7] +: "abc" +: [8] +: emptySeparated[[1,2,5,6,7],"cba",[3,4,8]]g Map across a  Separated1 on the separator values.kfmap (+1) (set tailL (1 +: 'b' +: 2 +: 'c' +: emptySeparated) (singleSeparated 'a' :: Separated1 Char Int))['a',2,'b',3,'c'])fmap id (x :: Separated1 Int String) == xIfmap (+1) (singleSeparated x :: Separated1 Char Int) == singleSeparated xkL('x' +: (6 :: Int) +: emptySeparated) `mappend` ('y' +: 7 +: emptySeparated) ['x',6,'y',7]lE('x' +: (6 :: Int) +: emptySeparated) <> ('y' +: 7 +: emptySeparated) ['x',6,'y',7]m(show (emptySeparated :: Separated () ())"[]"*show ('x' +: (6 :: Int) +: emptySeparated) "['x',6]"nApplies 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.K(emptySeparated :: Separated [Int] (String -> [String])) <*> emptySeparated[]b[1,2] +: (\s -> [s, reverse s, drop 1 s]) +: emptySeparated <*> [3,4,5] +: "abc" +: emptySeparated [[1,2,3,4,5],["abc","cba","bc"]]oXApplies functions with element values, using a zipping operation, appending separators.K(emptySeparated :: Separated [Int] (String -> [String])) <.> emptySeparated[]b[1,2] +: (\s -> [s, reverse s, drop 1 s]) +: emptySeparated <.> [3,4,5] +: "abc" +: emptySeparated [[1,2,3,4,5],["abc","cba","bc"]]r Map across a  Separated on the element values.(fmap id (x :: Separated Int String) == xL\a b -> fmap (+1) (a +: b +: emptySeparated) == a +: (1+b) +: emptySeparatedv:The isomorphism that swaps elements with their separators.swapped # emptySeparated[]&swapped # ('x' +: 6 +: emptySeparated)[6,'x']emptySeparated ^. swapped[]'('x' +: 6 +: emptySeparated) ^. swapped[6,'x']wgAppend a list of pairs of separator and element values to element values interspersed with a separator.V(singleSeparated 7 :: Separated1 Int Char) <++> (emptySeparated :: Separated Char Int)[7]b(singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int) [6,'x',7]i'w' +: (singleSeparated 6 :: Separated1 Int Char) <++> 'x' +: 7 +: (emptySeparated :: Separated Char Int) ['w',6,'x',7]xgAppend element values interspersed with a separator to a list of pairs of separator and element values.V(emptySeparated :: Separated Int Char) <++> (singleSeparated 7 :: Separated1 Int Char)[7]b(emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char) [6,'x',7]i'w' +: (emptySeparated :: Separated Int Char) <++> 6 +: 'x' +: (singleSeparated 7 :: Separated1 Int Char) ['w',6,'x',7]y`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]Ra +: (b :: Separated Int Int) == a +: b -- (a +: (b <++> c)) == ((a +: b) <++> c)One element and one separator.$(7 -+ "abc") :: Pesarated String Int [7,"abc"]27 -: "abc" -: (8 -+ "def") :: Pesarated String Int[7,"abc",8,"def"]One element and one separator.$(7 +- "abc") :: Separated Int String [7,"abc"]27 +: "abc" +: (8 +- "def") :: Separated Int String[7,"abc",8,"def"]2Zero element values interspersed with one element.*(singlePesarated 4 :: Pesarated1 Char Int)[4]F(singlePesarated x :: Pesarated1 Int Char) ^. tailL == emptyPesarated2Zero element values interspersed with one element.*(singleSeparated 4 :: Separated1 Int Char)[4]F(singleSeparated x :: Separated1 Int Char) ^. tailL == emptySeparatedA lens on the tail.[(d -: e -: (singlePesarated x :: Pesarated1 Char Int)) ^. tailL == e -: x -: emptyPesaratedA lens on the tail.[(d +: e +: (singleSeparated x :: Separated1 Int Char)) ^. tailL == e +: x +: emptySeparated"A lens on the first element value.3(singlePesarated 7 :: Pesarated1 Char Int) ^. headL7A(singlePesarated x :: Pesarated1 Char Int) ^. headL == (x :: Int)"A lens on the first element value.3(singleSeparated 7 :: Separated1 Int Char) ^. headL7A(singleSeparated x :: Separated1 Int Char) ^. headL == (x :: Int)p!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*!"#$%&'()*+,-0./123456789:;<=>?@ABCDEFGHIJ*?@=>;<9:ABCD78563412-./0+,EF'()*#$%&!"GHIJ]!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"5&5*5.9        !"#$%&'()*+,-./0123456789:;;<<==>>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&separated-0.3.0-3rzbvVAoTV9Ckg7cZTUa4AData.Separated.BeforeData.Separated.AfterData.Separated.BetweenData.SeparatedData.Separated.InternalBeforeAfterbefore beforeAfterafter afterBeforeBetween $fEqBetween$fFoldableBetween$fFunctorBetween $fOrdBetween$fTraversableBetween $fShowBetween $fEq1BetweenBetween'between$fShow1Between $fEqBetween'$fFoldableBetween'$fFunctorBetween'$fTraversableBetween'$fShowBetween' $fEq1Between'between'betweens$fBitraversableBetween'$fBifoldableBetween'$fBifunctorBetween'$fShow1Between'Appends<++> PesaratedConsPesaratedConsFPesaratedConsG-: SeparatedConsSeparatedConsFSeparatedConsG+:Sprinklesprinkle Construct+--+emptyPesarated1SinglesinglePesaratedSeparated1SinglesingleSeparatedHasTailtailLHasHeadheadL Pesarated1 Pesarated Separated1 Separated separated separated1 pesarated pesarated1skrinple skrinpleMay separatedBy separatedBy1 pesaratedBy pesaratedBy1$fShowPesarated1$fApplicativePesarated1$fApplyPesarated1$fTraversable1Pesarated1$fTraversablePesarated1$fFoldable1Pesarated1$fFoldablePesarated1$fFunctorPesarated1$fBitraversablePesarated1$fBifoldablePesarated1$fBifunctorPesarated1$fMonoidPesarated$fSemigroupPesarated$fShowPesarated$fApplicativePesarated$fApplyPesarated$fTraversablePesarated$fFoldablePesarated$fFunctorPesarated$fBitraversablePesarated$fBifoldablePesarated$fBifunctorPesarated$fSwappedPesarated$fShowSeparated1$fApplicativeSeparated1$fApplySeparated1$fTraversableSeparated1$fFoldableSeparated1$fFunctorSeparated1$fBitraversableSeparated1$fBifoldableSeparated1$fBifunctorSeparated1$fMonoidSeparated$fSemigroupSeparated$fShowSeparated$fApplicativeSeparated$fApplySeparated$fTraversableSeparated$fFoldableSeparated$fFunctorSeparated$fBitraversableSeparated$fBifoldableSeparated$fBifunctorSeparated$fSwappedSeparated&$fAppendsSeparated1SeparatedSeparated1&$fAppendsSeparatedSeparated1Separated1&$fAppendsSeparated1Separated1Separated"$fPesaratedConsPesarated1Pesarated"$fPesaratedConsPesaratedPesarated1"$fSeparatedConsSeparatedSeparated1"$fSeparatedConsSeparated1Separated$fSprinkleSeparated1$fSprinklePesarated$fSprinkleSeparated$fConstructPesarated$fConstructSeparated$fPesarated1SinglePesarated1$fSeparated1SingleSeparated1/$fHasTailPesarated1Pesarated1PesaratedPesarated/$fHasTailSeparated1Separated1SeparatedSeparated$fHasHeadPesarated1Pesarated1tt$fHasHeadSeparated1Separated1aa $fEqSeparated$fOrdSeparated$fEqSeparated1$fOrdSeparated1 $fEqPesarated$fOrdPesarated$fEqPesarated1$fOrdPesarated1$fWrappedSeparated$fRewrappedSeparatedt$fWrappedPesarated$fRewrappedPesaratedt$fWrappedPesarated1$fRewrappedPesarated1t"lens-4.15.4-KUno97tdZMYJKCU13eoExKControl.Lens.Isofrom$fBitraversableBefore'bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkEData.Bitraversable bitraversebase Data.Functor<$>GHC.Base<*>$fBifoldableBeforeData.Bifoldable bifoldMap Data.Monoid<>$fBitraversableAfter$fBifoldableAfter $fEq1Before$fSwappedBefore$fBifunctorBefore $fShow1Before $fEq1After$fSwappedAfter$fBifunctorAfter $fShow1Aftershift showSeparated separatedAp separated1Ap pesarated1ApD:R:UnwrappedSeparatedD:R:UnwrappedPesaratedD:R:UnwrappedPesarated1